Reconfigured for iPerl

RegulValve.adcChannel and Diverter.flowMtrNr4Cmd for GELSENWASSER

.gitattributes

@@ -0,0 +1,2 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto

.gitignore

@@ -1,21 +1,46 @@
+Common/bin/
+Common/obj/
 Config/bin/
 Config/obj/
+Decrypt/bin/
+Decrypt/obj/
 DeviceTest/bin/
 DeviceTest/obj/
 Dirichlet.Numerics/bin
 Dirichlet.Numerics/obj
+Encrypt/bin/
+Encrypt/obj/
+EventViewer/bin/
+EventViewer/obj/
+Events/bin/
+Events/obj/
+GemCard/bin
+GemCard/obj
+GenCode128/bin
+GenCode128/obj
+GraphLib/bin
+GraphLib/obj
+TracingDB/bin
+TracingDB/obj
+RestClient/bin
+RestClient/obj
 Results/bin/
 Results/obj/
 ResultsBrowser/bin/
 ResultsBrowser/obj/
-TestBenchFramework/bin/
-TestBenchFramework/obj/
-TBFSetup/Debug/
-TBFSetup/Release/
+Statistics/bin/
+Statistics/obj/
+TBF/bin/
+TBF/obj/
+ToFirstMonitor/bin/
+ToFirstMonitor/obj/
+ToSecondMonitor/bin/
+ToSecondMonitor/obj/
 Users/bin/
 Users/obj/
 UserManagement/bin/
 UserManagement/obj/
 Doc/
+.vs/
 *.suo
 *.bak

Common/Common.csproj

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{C8939821-BA5C-4988-A3D0-BF53B74865C7}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Common</RootNamespace>
+    <AssemblyName>Common</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</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="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="UIControls\CoolButtonCtrl.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="UIControls\CoolButtonCtrl.Designer.cs">
+      <DependentUpon>CoolButtonCtrl.cs</DependentUpon>
+    </Compile>
+    <Compile Include="UIControls\LviDateTimeColumnComparer.cs" />
+    <Compile Include="UIControls\RoundedRectangle.cs" />
+    <Compile Include="Utils.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UIControls\ListViewEx.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="UIControls\ListViewExtensions.cs" />
+    <Compile Include="UIControls\LviIntColumnComparer.cs" />
+    <Compile Include="UIControls\LviTextColumnComparer.cs" />
+  </ItemGroup>
+  <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>

Common/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 ©  2020")]
+[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("4e3e3538-fd80-47d5-9417-2268afa590cf")]
+
+// 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.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Common/UIControls/CoolButtonCtrl.Designer.cs

@@ -0,0 +1,54 @@
+namespace Common.UIControls
+{
+    partial class CoolButtonCtrl
+    {
+        /// <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 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()
+        {
+            this.SuspendLayout();
+            // 
+            // CoolButton
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.Transparent;
+            this.DoubleBuffered = true;
+            this.Name = "CoolButton";
+            this.Size = new System.Drawing.Size(72, 29);
+            this.Load += new System.EventHandler(this.CoolButtonLoad);
+            this.SizeChanged += new System.EventHandler(this.CoolButtonSizeChanged);
+            this.Paint += new System.Windows.Forms.PaintEventHandler(this.CoolButtonPaint);
+            this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.CoolButtonMouseDown);
+            this.MouseEnter += new System.EventHandler(this.CoolButtonMouseEnter);
+            this.MouseLeave += new System.EventHandler(this.CoolButtonMouseLeave);
+            this.MouseUp += new System.Windows.Forms.MouseEventHandler(this.CoolButtonMouseUp);
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+    }
+}

Common/UIControls/CoolButtonCtrl.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public partial class CoolButtonCtrl : UserControl
+    {
+        private Color _buttonColor;
+        private Color _textColor;
+        private Color _focusColor;
+        private Color _borderColor;
+        private Color _highlightBorderColor;
+        private Color _highlightButtonColor;
+        private Font _buttonFont;
+        private string _buttonText;
+        private bool _mouseOver;
+        private bool _mouseDown;
+
+        public delegate void ButtonClickedArgs(object sender);
+
+        public event ButtonClickedArgs ButtonClicked;
+
+        public Color FocusColor
+        {
+            get { return _focusColor; }
+            set
+            {
+                _focusColor = value;
+                Refresh();
+            }
+        }
+
+        public Color TextColor
+        {
+            get { return _textColor; }
+            set
+            {
+                _textColor = value;
+                Refresh();
+            }
+        }
+
+        public Color HighlightBorderColor
+        {
+            get { return _highlightBorderColor; }
+            set
+            {
+                _highlightBorderColor = value;
+                Refresh();
+            }
+        }
+
+        public Color HighlightButtonColor
+        {
+            get { return _highlightButtonColor; }
+            set
+            {
+                _highlightButtonColor = value;
+                Refresh();
+            }
+        }
+
+        public string ButtonText
+        {
+            get { return _buttonText; }
+            set
+            {
+                _buttonText = value;
+                Refresh();
+            }
+        }
+
+        public Font ButtonFont
+        {
+            get { return _buttonFont; }
+            set
+            {
+                _buttonFont = value;
+                Refresh();
+            }
+        }
+
+        public Color BorderColor
+        {
+            get { return _borderColor; }
+            set
+            {
+                _borderColor = value;
+                Refresh();
+            }
+        }
+
+        public Color ButtonColor
+        {
+            get { return _buttonColor; }
+            set
+            {
+                _buttonColor = value;
+                Refresh();
+            }
+        }
+
+        public CoolButtonCtrl()
+        {
+            InitializeComponent();
+
+            _buttonColor = Color.FromArgb(243, 243, 243);
+            _borderColor = Color.FromArgb(220, 220, 220);
+            _highlightBorderColor = Color.FromArgb(198, 198, 198);
+            _highlightButtonColor = Color.FromArgb(246, 246, 246);
+            _focusColor = Color.FromArgb(77, 144, 254);
+            _buttonFont = new Font("Arial", 8, FontStyle.Bold);
+            _buttonText = "button";
+            _textColor = Color.Black;
+
+            _mouseOver = false;
+            _mouseDown = false;
+
+            LostFocus += CoolButtonFocus;
+            GotFocus += CoolButtonFocus;
+        }
+
+        void CoolButtonFocus(object sender, EventArgs e)
+        {
+            Refresh();
+        }
+
+        private void CoolButtonLoad(object sender, EventArgs e)
+        {
+
+        }
+
+        private void CoolButtonPaint(object sender, PaintEventArgs e)
+        {
+            var bmp = new Bitmap(ClientSize.Width, ClientSize.Height);
+            Graphics g = Graphics.FromImage(bmp);
+
+            if (!_mouseOver)
+            {
+                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
+                GraphicsPath path = RoundedRectangle.Create(0, 0, ClientSize.Width - 4, ClientSize.Height - 4);
+                SizeF fontSize = g.MeasureString(_buttonText, _buttonFont);
+                int horWidth = ((ClientSize.Width - 4 - (int)fontSize.Width) / 2);
+                int verHeight = ((ClientSize.Height - 4 - (int)fontSize.Height) / 2);
+
+                g.FillPath(new SolidBrush(_buttonColor), path);
+                g.DrawPath(Focused ? new Pen(_focusColor) : new Pen(_borderColor), path);
+                g.DrawString(_buttonText, _buttonFont, new SolidBrush(_textColor), horWidth, verHeight);
+            }
+            else
+            {
+                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
+                GraphicsPath path = RoundedRectangle.Create(0, 0, ClientSize.Width - 4, ClientSize.Height - 4);
+                SizeF fontSize = g.MeasureString(_buttonText, _buttonFont);
+                int horWidth = ((ClientSize.Width - 4 - (int)fontSize.Width) / 2);
+                int verHeight = ((ClientSize.Height - 4 - (int)fontSize.Height) / 2);
+
+                g.FillPath(new SolidBrush(_highlightButtonColor), path);
+                g.DrawPath(ContainsFocus ? new Pen(_focusColor) : new Pen(_borderColor), path);
+                g.DrawString(_buttonText, _buttonFont, new SolidBrush(_textColor), horWidth, verHeight);
+
+                Color a1 = Color.FromArgb(255, 198, 198, 198);
+                Color a2 = Color.FromArgb(128, 198, 198, 198);
+                Color a3 = Color.FromArgb(64, 198, 198, 198);
+
+                var shadowBmp = new Bitmap(1, 3);
+                var shadowBmp2 = new Bitmap(3, 1);
+                shadowBmp.SetPixel(0, 0, a1);
+                shadowBmp.SetPixel(0, 1, a2);
+                shadowBmp.SetPixel(0, 2, a3);
+
+                shadowBmp2.SetPixel(0, 0, a1);
+                shadowBmp2.SetPixel(1, 0, a2);
+                shadowBmp2.SetPixel(2, 0, a3);
+
+                for (int z = 4; z < ClientSize.Width - 4; z++)
+                {
+                    g.DrawImage(shadowBmp, z, ClientSize.Height - 4, 1, 3);
+                }
+                for (int z = 4; z < ClientSize.Height - 4; z++)
+                {
+                    g.DrawImage(shadowBmp2, ClientSize.Width - 4, z, 3, 1);
+                }
+                g.DrawPath(Focused ? new Pen(_focusColor) : new Pen(_borderColor), path);
+            }
+
+            e.Graphics.DrawImage(bmp, 0, 0, ClientSize.Width, ClientSize.Height);
+            //bmp.Dispose();
+        }
+
+        private void CoolButtonMouseEnter(object sender, EventArgs e)
+        {
+            _mouseOver = true;
+            Refresh();
+        }
+
+        private void CoolButtonMouseLeave(object sender, EventArgs e)
+        {
+            _mouseOver = false;
+            _mouseDown = false;
+            Refresh();
+        }
+
+        private void CoolButtonSizeChanged(object sender, EventArgs e)
+        {
+            Refresh();
+        }
+
+        private void CoolButtonMouseDown(object sender, MouseEventArgs e)
+        {
+            if (e.Button == MouseButtons.Left)
+                _mouseDown = true;
+        }
+
+        private void CoolButtonMouseUp(object sender, MouseEventArgs e)
+        {
+            if (e.Button != MouseButtons.Left)
+                return;
+            if (_mouseDown)
+            {
+                if (ButtonClicked != null)
+                {
+                    ButtonClicked(this);
+                }
+            }
+            _mouseDown = false;
+        }
+    }
+}

Common/UIControls/CoolButtonCtrl.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=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

Common/UIControls/ListViewEx.cs

@@ -0,0 +1,486 @@
+///
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace Common.UIControls
+{
+	/// <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 SubItemRightClicked;
+        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);
+
+            MouseEventArgs me = (MouseEventArgs)e;
+            if (me.Button == MouseButtons.Right)
+            {
+                /// Right mouse button click function
+                RightClickFunctionSubitemAt(new Point(e.X, e.Y));
+            }
+            else
+            {
+                /// Normal function (=edit item)
+                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));
+			}
+		}
+
+        ///<summary>
+        /// Fire SubItemRightClicked
+        ///</summary>
+        ///<param name="p">Point of click/doubleclick</param>
+        private void RightClickFunctionSubitemAt(Point p)
+        {
+            ListViewItem item;
+            int idx = GetSubItemAt(p.X, p.Y, out item);
+            if (idx >= 0)
+            {
+                OnSubItemRightClicked(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);
+		}
+
+        protected void OnSubItemRightClicked(SubItemEventArgs e)
+        {
+            if (SubItemRightClicked != null) SubItemRightClicked(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; }
+		}
+	}
+}

Common/UIControls/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>

Common/UIControls/ListViewExtensions.cs

@@ -0,0 +1,107 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class ListViewExtensions
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        public struct HDITEM
+        {
+            public Mask mask;
+            public int cxy;
+            [MarshalAs(UnmanagedType.LPTStr)]
+            public string pszText;
+            public IntPtr hbm;
+            public int cchTextMax;
+            public Format fmt;
+            public IntPtr lParam;
+            // _WIN32_IE >= 0x0300 
+            public int iImage;
+            public int iOrder;
+            // _WIN32_IE >= 0x0500
+            public uint type;
+            public IntPtr pvFilter;
+            // _WIN32_WINNT >= 0x0600
+            public uint state;
+
+            [Flags]
+            public enum Mask
+            {
+                Format = 0x4,       // HDI_FORMAT
+            };
+
+            [Flags]
+            public enum Format
+            {
+                SortDown = 0x200,   // HDF_SORTDOWN
+                SortUp = 0x400,     // HDF_SORTUP
+            };
+        };
+
+        public const int LVM_FIRST = 0x1000;
+        public const int LVM_GETHEADER = LVM_FIRST + 31;
+
+        public const int HDM_FIRST = 0x1200;
+        public const int HDM_GETITEM = HDM_FIRST + 11;
+        public const int HDM_SETITEM = HDM_FIRST + 12;
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 msg, IntPtr wParam, ref HDITEM lParam);
+
+        public static void SetSortIcon(this ListViewEx listViewControl, int columnIndex, SortOrder order)
+        {
+            IntPtr columnHeader = SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
+            for (int columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
+            {
+                var columnPtr = new IntPtr(columnNumber);
+                var item = new HDITEM
+                {
+                    mask = HDITEM.Mask.Format
+                };
+
+                if (SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
+                {
+                    throw new Win32Exception();
+                }
+
+                if (order != SortOrder.None && columnNumber == columnIndex)
+                {
+                    switch (order)
+                    {
+                        case SortOrder.Ascending:
+                            item.fmt &= ~HDITEM.Format.SortDown;
+                            item.fmt |= HDITEM.Format.SortUp;
+                            break;
+
+                        case SortOrder.Descending:
+                            item.fmt &= ~HDITEM.Format.SortUp;
+                            item.fmt |= HDITEM.Format.SortDown;
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+                else
+                {
+                    item.fmt &= ~HDITEM.Format.SortDown & ~HDITEM.Format.SortUp;
+                }
+
+                if (SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
+                {
+                    throw new Win32Exception();
+                }
+            }
+        }
+    }
+}

Common/UIControls/LviDateTimeColumnComparer.cs

@@ -0,0 +1,46 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviDateTimeColumnComparer : IComparer
+    {
+        int column;
+        SortOrder order;
+
+        public LviDateTimeColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviDateTimeColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            DateTime valX = DateTime.Parse(((ListViewItem)x).SubItems[column].Text);
+            DateTime valY = DateTime.Parse(((ListViewItem)y).SubItems[column].Text);
+
+            if (valX == valY)
+            {
+                return 0;
+            }
+            else if (order == SortOrder.Ascending)
+            {
+                return (valX > valY) ? 1 : -1;
+            }
+            else
+            {
+                return (valY > valX) ? 1 : -1;
+            }
+        }
+    }
+}

Common/UIControls/LviIntColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviIntColumnComparer : IComparer
+    {
+        int column;
+        SortOrder order;
+
+        public LviIntColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviIntColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            int valX = int.Parse(((ListViewItem)x).SubItems[column].Text);
+            int valY = int.Parse(((ListViewItem)y).SubItems[column].Text);
+            return (order == SortOrder.Descending) ? (valY - valX) : (valX - valY);
+        }
+    }
+}

Common/UIControls/LviTextColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviTextColumnComparer : IComparer
+    {
+        private int column;
+        SortOrder order;
+
+        public LviTextColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviTextColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            string txtX = ((ListViewItem)x).SubItems[column].Text;
+            string txtY = ((ListViewItem)y).SubItems[column].Text;
+            return (order == SortOrder.Descending) ? String.Compare(txtY, txtX) : String.Compare(txtX, txtY);
+        }
+    }
+}

Common/UIControls/RoundedRectangle.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+
+namespace Common.UIControls
+{
+    public abstract class RoundedRectangle
+    {
+        [Flags]
+        public enum RectangleCorners
+        {
+            None = 0, TopLeft = 1, TopRight = 2, BottomLeft = 4, BottomRight = 8,
+            All = TopLeft | TopRight | BottomLeft | BottomRight
+        }
+
+        public static GraphicsPath Create(int x, int y, int width, int height,
+                                          int radius, RectangleCorners corners)
+        {
+            int xw = x + width;
+            int yh = y + height;
+            int xwr = xw - radius;
+            int yhr = yh - radius;
+            int xr = x + radius;
+            int yr = y + radius;
+            int r2 = radius * 2;
+            int xwr2 = xw - r2;
+            int yhr2 = yh - r2;
+
+            var p = new GraphicsPath();
+            p.StartFigure();
+
+            //Top Left Corner
+            if ((RectangleCorners.TopLeft & corners) == RectangleCorners.TopLeft)
+            {
+                p.AddArc(x, y, r2, r2, 180, 90);
+            }
+            else
+            {
+                p.AddLine(x, yr, x, y);
+                p.AddLine(x, y, xr, y);
+            }
+
+            //Top Edge
+            p.AddLine(xr, y, xwr, y);
+
+            //Top Right Corner
+            if ((RectangleCorners.TopRight & corners) == RectangleCorners.TopRight)
+            {
+                p.AddArc(xwr2, y, r2, r2, 270, 90);
+            }
+            else
+            {
+                p.AddLine(xwr, y, xw, y);
+                p.AddLine(xw, y, xw, yr);
+            }
+
+            //Right Edge
+            p.AddLine(xw, yr, xw, yhr);
+
+            //Bottom Right Corner
+            if ((RectangleCorners.BottomRight & corners) == RectangleCorners.BottomRight)
+            {
+                p.AddArc(xwr2, yhr2, r2, r2, 0, 90);
+            }
+            else
+            {
+                p.AddLine(xw, yhr, xw, yh);
+                p.AddLine(xw, yh, xwr, yh);
+            }
+
+            //Bottom Edge
+            p.AddLine(xwr, yh, xr, yh);
+
+            //Bottom Left Corner
+            if ((RectangleCorners.BottomLeft & corners) == RectangleCorners.BottomLeft)
+            {
+                p.AddArc(x, yhr2, r2, r2, 90, 90);
+            }
+            else
+            {
+                p.AddLine(xr, yh, x, yh);
+                p.AddLine(x, yh, x, yhr);
+            }
+
+            //Left Edge
+            p.AddLine(x, yhr, x, yr);
+
+            p.CloseFigure();
+            return p;
+        }
+
+        public static GraphicsPath Create(Rectangle rect, int radius, RectangleCorners c)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius, c); }
+
+        public static GraphicsPath Create(int x, int y, int width, int height, int radius)
+        { return Create(x, y, width, height, radius, RectangleCorners.All); }
+
+        public static GraphicsPath Create(Rectangle rect, int radius)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius); }
+
+        public static GraphicsPath Create(int x, int y, int width, int height)
+        { return Create(x, y, width, height, 5); }
+
+        public static GraphicsPath Create(Rectangle rect)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height); }
+    }
+}

Common/Utils.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Common
+{
+    public class Utils
+    {
+    }
+}

Config/CalendarEvent/ICalendarEvent.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Drawing;
+
+namespace Config.CalendarEvent
+{
+    /// <summary>
+    /// An interface for creating event types
+    /// </summary>
+    public interface ICalendarEvent
+    {
+        DateTime Date { get; set; }                 /// The Date that the event occurs
+        Frequency Frequency { get; set; }           /// A value indicating how often the event occurs
+        bool AllDay { get; set; }                   /// True if the time component of DateTime value can be ignored
+        bool TriggerOnExactDayOnly { get; set; }    /// If this is a recurring event, set this to true to make the event show up only from the day specified forward
+        string Source { get; set; }                 /// Source of this calendar event (becomes the source of the triggered event)
+        string Title { get; set; }                  /// The name of the event (becomes the text of the triggered event)
+        AutoAction AutoAction { get; set; }         /// Automated action to be done or event to be triggered (triggered event Severity)
+        string Parameters { get; set; }             /// Automated action parameters (e.g. name of a procedure to start)
+        int Rank { get; set; }                      /// The ranking of the event that determines the order in which it is displayed on a particular day
+        bool Hidden { get; set; }                   /// True if the event is hidden/invisible, otherwise false
+        bool ReadOnly { get; set; }                 /// True if the event details cannot be modified
+        int BackColor { get; set; }                 /// The color that the event show up in on the calendar
+        int TextColor { get; set; }                 /// The text color of the event
+        bool TooltipEnabled { get; set; }           /// True if a tooltip should be displayed when hovering over the event
+
+        /// <summary>
+        /// Set this to a custom function that will automatically determine if the event should be rendered on a given day.
+        /// This is only executed if <see cref="Frequency"/> is set to custom.
+        /// </summary>
+        CustomRecurringFrequenciesHandler CustomRecurringFunction { get; set; }
+
+        /// <summary>
+        /// A function for cloning an event instance
+        /// </summary>
+        /// <returns>A cloned <see cref="ICalendarEvent"/></returns>
+        ICalendarEvent Clone();
+    }
+
+    /// <summary>
+    /// A delegate for creating custom recurring frequencies
+    /// </summary>
+    /// <param name="evnt">The <see cref="ICalendarEvent"/> in question</param>
+    /// <param name="day">The day in question</param>
+    /// <returns>Should return a boolean value that indicates if the event should be rendered on the day passed in</returns>
+    public delegate bool CustomRecurringFrequenciesHandler(ICalendarEvent evnt, DateTime day);
+}

Config/CalendarEvent/Utils.cs

@@ -0,0 +1,226 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+using Config.Resources;
+
+namespace Config.CalendarEvent
+{
+    /// <summary>
+    /// Enumeration of calendar event actions
+    /// </summary>
+    public enum AutoAction
+    {
+        Undefined,
+        None,               /// No action at all
+        Notification,       /// Trigger a notification event
+        Warning,            /// Trigger a warning event
+        Error,              /// Trigger an error event and stop test bench function
+        FatalErr,           /// Trigger a fatal error and stop test bench function
+        InvokeBeforeCycle,  /// Invoke a maintenance procedure before a cycle after entering order number
+        InvokeInsideCycle,  /// Invoke conditional tests inside a cycle (if any)
+        InvokeAfterCycle,   /// Invoke a maintenance procedure after a cycle after saving results
+        BackupData,
+        Count,
+    }
+
+
+    /// <summary>
+    /// Enumeration of built-in recurring event frequencies
+    /// </summary>
+    public enum Frequency
+    {
+        Undefined,
+        Once,               /// Indicates that the event is non recurring will occur only one time
+        Yearly,             /// Indicates that the event will occur once a year, on the month and day specified
+        Monthly,            /// Indicates that the event will occur every month
+        Weekly,             /// Indicates that the event will occur every week
+        EveryTuTh,          /// Indicates that the event will occur every Tuesday and Thursday
+        EveryMoWeFr,        /// Indicates that the event will occur every Mon, Wed and Fri
+        EveryWkday,         /// Indicates that the event will occur every week day (Mon - Fri)
+        Daily,              /// Indicates that the event will occur every day
+        EveryShift,
+        Custom,             /// Indicates that the recuring schedule of this event is unique
+        Count
+    }
+
+    public class Utils
+    {
+        public static string Action2String(AutoAction action)
+        {
+            return action.ToString();
+        }
+
+        public static AutoAction String2Action(string astr)
+        {
+            for (AutoAction a = AutoAction.None; a < AutoAction.Count; a++)
+            {
+                if (Action2String(a) == astr) return a;
+            }
+            return AutoAction.Undefined;
+        }
+
+        public static string Freq2String(Frequency f)
+        {
+            switch (f)
+            {
+                case Frequency.Custom:      return Strings.Custom;
+                case Frequency.Daily:       return Strings.Daily;
+                case Frequency.EveryMoWeFr: return Strings.Every_Mon_Wed_and_Fri;
+                case Frequency.EveryTuTh:   return Strings.Every_Tue_and_Thu;
+                case Frequency.EveryWkday:  return Strings.Every_Week_Day;
+                case Frequency.EveryShift:  return Strings.Every_shift;
+                case Frequency.Monthly:     return Strings.Every_Month;
+                case Frequency.Once:        return Strings.Once;
+                case Frequency.Weekly:      return Strings.Every_week;
+                case Frequency.Yearly:      return Strings.Every_year;
+                default:                    return string.Empty;
+            }
+        }
+
+        public static Frequency String2Freq(string fstr)
+        {
+            for (Frequency f = Frequency.Once; f < Frequency.Count; f++)
+            {
+                if (Freq2String(f) == fstr) return f;
+            }
+            return Frequency.Undefined;
+        }
+
+
+        /// <summary>
+        /// Determine whether an event date matches given day and time (dt)
+        /// (whether an event needs to be rendered on a specific day).
+        /// </summary>
+        /// <param name="evnt">Calendar event</param>
+        /// <param name="dt">Day and time</param>
+        /// <returns>true = needs to be rendered</returns>
+        public static bool DayMatchesExactly(ICalendarEvent evnt, DateTime dt)
+        {
+            DayOfWeek dow = dt.DayOfWeek;
+
+            switch (evnt.Frequency)
+            {
+                case Frequency.EveryShift:  return (dow == DayOfWeek.Sunday && evnt.Date.Hour >= 22) ||
+                                                   dow == DayOfWeek.Monday ||
+                                                   dow == DayOfWeek.Tuesday ||
+                                                   dow == DayOfWeek.Wednesday ||
+                                                   dow == DayOfWeek.Thursday ||
+                                                   (dow == DayOfWeek.Friday && evnt.Date.Hour < 22);
+
+                case Frequency.Daily:       return true;
+                case Frequency.EveryMoWeFr: return (dow == DayOfWeek.Monday) || (dow == DayOfWeek.Wednesday) || (dow == DayOfWeek.Friday);
+                case Frequency.EveryTuTh:   return (dow == DayOfWeek.Tuesday) || (dow == DayOfWeek.Thursday);
+                case Frequency.EveryWkday:  return (dow != DayOfWeek.Sunday) && (dow != DayOfWeek.Saturday);
+                case Frequency.Weekly:      return evnt.Date.DayOfWeek == dow;
+                case Frequency.Monthly:     return evnt.Date.Day == dt.Day;
+                case Frequency.Yearly:      return evnt.Date.Month == dt.Month && evnt.Date.Day == dt.Day;
+                case Frequency.Once:        return evnt.Date.Year == dt.Year && evnt.Date.Month == dt.Month && evnt.Date.Day == dt.Day;
+                case Frequency.Custom:      return (evnt.CustomRecurringFunction != null) && evnt.CustomRecurringFunction(evnt, dt);
+                default:                    return false;
+            }
+        }
+
+
+        public static bool IsCalendarEventTrigerred(ICalendarEvent evnt, DateTime currentDate)
+        {
+            DateTime evntDT = evnt.AllDay
+                            ? new DateTime(evnt.Date.Year, evnt.Date.Month, evnt.Date.Day, 0, 0, 0)
+                            : evnt.Date;
+
+            if (evnt.Frequency == Frequency.EveryShift)
+            {
+                DateTime dt1 = evntDT;
+                DateTime dt2 = evntDT + new TimeSpan(8, 0, 0);
+                DateTime dt3 = evntDT + new TimeSpan(16, 0, 0);
+                return (currentDate >= dt1) || (currentDate >= dt1) || (currentDate >= dt3);
+            }
+            else if (!evnt.TriggerOnExactDayOnly)
+            {
+                /// Trigger after event expires
+                return (currentDate >= evntDT);
+            }
+            else
+            {
+                /// Trigger event on exact date only
+                return (currentDate >= evntDT) && DayMatchesExactly(evnt, currentDate);
+            }
+        }
+
+
+        /// <summary>
+        /// Called to update event.Date after an event was trigerred and a required action was done.
+        /// </summary>
+        /// <param name="evnt">Calendar event</param>
+        /// <param name="currentDate">Current date and time which triggered the event</param>
+        /// <returns>true when event.Date was updated</returns>
+        public static bool UpdateRecurringDate(ICalendarEvent evnt, DateTime currentDate)
+        {
+            switch (evnt.Frequency)
+            {
+                case Frequency.Yearly:
+                    do {
+                        evnt.Date = evnt.Date.AddYears(1);
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.Monthly:
+                    do {
+                        evnt.Date = evnt.Date.AddMonths(1);
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.Weekly:
+                    do {
+                        evnt.Date += new TimeSpan(7, 0, 0, 0);  /// add one week
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.EveryTuTh:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || ((evnt.Date.DayOfWeek != DayOfWeek.Tuesday) &&
+                                                          (evnt.Date.DayOfWeek != DayOfWeek.Thursday)));
+                    return true;
+
+                case Frequency.EveryMoWeFr:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || ((currentDate.DayOfWeek != DayOfWeek.Monday) &&
+                                                          (currentDate.DayOfWeek != DayOfWeek.Wednesday) &&
+                                                          (currentDate.DayOfWeek != DayOfWeek.Friday)));
+                    return true;
+
+                case Frequency.EveryWkday:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || (currentDate.DayOfWeek == DayOfWeek.Saturday) || (currentDate.DayOfWeek == DayOfWeek.Sunday));
+                    return true;
+
+                case Frequency.Daily:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.EveryShift:
+                    do {
+                        evnt.Date += new TimeSpan(8, 0, 0);     /// add eight hours
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                default:
+                    /// This is not a recurring calendar event, 'Date' was not updated
+                    return false;
+            }
+        }
+    }
+}

Config/Config.csproj

@@ -10,27 +10,30 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Config</RootNamespace>
     <AssemblyName>Config</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
     <PlatformTarget>x86</PlatformTarget>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="FluentNHibernate">
@@ -64,9 +67,11 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CalendarEvent\ICalendarEvent.cs" />
     <Compile Include="Data.cs" />
     <Compile Include="DatabaseSettings.cs" />
     <Compile Include="Entities\BenchPath.cs" />
+    <Compile Include="Entities\CustomEvent.cs" />
     <Compile Include="Entities\Component.cs" />
     <Compile Include="Entities\ComponentProcedure.cs" />
     <Compile Include="Entities\ComponentTest.cs" />
@@ -75,44 +80,45 @@
     <Compile Include="Entities\Group.cs" />
     <Compile Include="Entities\HeatMetersPath.cs" />
     <Compile Include="Entities\IHasItemNr.cs" />
+    <Compile Include="Entities\IHasName.cs" />
     <Compile Include="Entities\IHasValves.cs" />
+    <Compile Include="Entities\IParamsProvider.cs" />
+    <Compile Include="Entities\IperlEnums.cs" />
     <Compile Include="Entities\MeasurementCorrection.cs" />
     <Compile Include="Entities\MetersPath.cs" />
-    <Compile Include="Entities\MeterTestResult.cs" />
     <Compile Include="Entities\OutputPath.cs" />
     <Compile Include="Entities\Procedure.cs" />
-    <Compile Include="Entities\ProcedureHistory.cs" />
+    <Compile Include="Entities\Profile.cs" />
+    <Compile Include="Entities\PTest.cs" />
     <Compile Include="Entities\Test.cs" />
-    <Compile Include="Entities\TestResult.cs" />
     <Compile Include="Entities\TransitionSequence.cs" />
     <Compile Include="Entities\TransitionStep.cs" />
+    <Compile Include="Entities\Uncertainty.cs" />
     <Compile Include="Entities\User.cs" />
     <Compile Include="Entities\VirtualBenchSequence.cs" />
     <Compile Include="Entities\VirtualBenchStep.cs" />
-    <Compile Include="Entities\Watermeter.cs" />
-    <Compile Include="Entities\WMType.cs" />
+    <Compile Include="CalendarEvent\Utils.cs" />
     <Compile Include="FluentCommon.cs" />
+    <Compile Include="Formulas.cs" />
     <Compile Include="Mappings\BenchPathMap.cs" />
     <Compile Include="Mappings\ComponentMap.cs" />
     <Compile Include="Mappings\ComponentProcedureMap.cs" />
     <Compile Include="Mappings\ComponentTestMap.cs" />
+    <Compile Include="Mappings\CustomEventMap.cs" />
     <Compile Include="Mappings\FeedingPathMap.cs" />
     <Compile Include="Mappings\GroupMap.cs" />
     <Compile Include="Mappings\HeatMetersPathMap.cs" />
     <Compile Include="Mappings\MeasurementCorrectionMap.cs" />
     <Compile Include="Mappings\MetersPathMap.cs" />
-    <Compile Include="Mappings\MeterTestResultMap.cs" />
     <Compile Include="Mappings\OutputPathMap.cs" />
     <Compile Include="Mappings\ProcedureMap.cs" />
+    <Compile Include="Mappings\ProfileMap.cs" />
+    <Compile Include="Mappings\PTestMap.cs" />
     <Compile Include="Mappings\TestMap.cs" />
-    <Compile Include="Mappings\TestResultMap.cs" />
     <Compile Include="Mappings\TransitionSequenceMap.cs" />
     <Compile Include="Mappings\TransitionStepMap.cs" />
+    <Compile Include="Mappings\UncertaintyMap.cs" />
     <Compile Include="Mappings\UserMap.cs" />
-    <Compile Include="Mappings\VirtualBenchSequenceMap.cs" />
-    <Compile Include="Mappings\VirtualBenchStepMap.cs" />
-    <Compile Include="Mappings\WatermeterMap.cs" />
-    <Compile Include="Mappings\WMTypeMap.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Resources\Strings.Designer.cs">
       <AutoGen>True</AutoGen>
@@ -120,10 +126,13 @@
       <DependentUpon>Strings.resx</DependentUpon>
     </Compile>
     <Compile Include="Units.cs" />
+    <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\Strings.cs.resx" />
     <EmbeddedResource Include="Resources\Strings.de.resx" />
+    <EmbeddedResource Include="Resources\Strings.fr.resx" />
+    <EmbeddedResource Include="Resources\Strings.it.resx" />
     <EmbeddedResource Include="Resources\Strings.pl.resx" />
     <EmbeddedResource Include="Resources\Strings.resx">
       <SubType>Designer</SubType>

Config/Data.cs

@@ -10,42 +10,78 @@ namespace Config
 
 #if MUNICH
 		public const int WMsCount = 3;
-		public const int LineSize = 1;
-		public const int CompoundWMsCount = 1;
+		public const int LineSize = 3;
+		public const int CompoundWMsCount = 3;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 3;
-#elif DN100 || BADGER_VELKA_TRAT
+#elif DN100 || BADGER_STREDNA_TRAT || BADGER_VELKA_TRAT || CEVAK_200
 		public const int WMsCount = 3;
 		public const int LineSize = 3;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif FUZHOU300 || FUZHOU150 || PT200IL || PUCHONG_PT200 || GENESIS || BERLIN
+#elif FUZHOU_300 || FUZHOU_150 || IZRAEL_200 || GENESIS || SLM_150 || PETERSBURG_200
+		public const int WMsCount = 6;
+		public const int LineSize = 6;
+		public const int CompoundWMsCount = 1;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = 3;
+#elif PUCHONG_200
 		public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 3;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 3;
-#elif TORINO50 || BADGER_MALA_TRAT
+#elif DEWA_300 || ROMA_200
+        public const int WMsCount = 10;
+        public const int LineSize = 10;
+        public const int CompoundWMsCount = 1;
+        public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif DUBAJ_50
+		public const int WMsCount = 10;
+		public const int LineSize = 5;
+		public const int CompoundWMsCount = 0;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif IZRAEL_50
+		public const int WMsCount = 40;
+		public const int LineSize = 10;
+		public const int CompoundWMsCount = 0;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif FUZHOU_100
+		public const int WMsCount = 10;
+		public const int LineSize = 10;
+		public const int CompoundWMsCount = 1;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif TORINO_50 || BADGER_MALA_TRAT || BERLIN || GELSENWASSER
 		public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 1;
-#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40
-		public const int WMsCount = 20;
+#elif TORUN_50 || CEVAK_40 || MURES_40 || FUZHOU_50 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || IZRAEL_25 || ZAMBIA || ZODINO || FEWA_50 || FILIPINY_50 || ALZIR_25
+        public const int WMsCount = 20;
 		public const int LineSize = 10;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif TURA_IPERL
+#elif RUM_MOB
+        public const int WMsCount = 8;
+		public const int LineSize = 8;
+		public const int CompoundWMsCount = 1;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif TURA_IPERL || TURA_IPERL_NEW
 		public const int WMsCount = 40;
 		public const int LineSize = 20;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif TURA_SPECIAL
-		public const int WMsCount = 6;
+#elif TURA_SPECIAL || SENTEC
+        public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
@@ -74,5 +110,9 @@ namespace Config
 		/// Database related: This object reference is set after a successful user login
 		///
 		public static DatabaseSettings CurrentBench;
-	}
+
+        public static double RealDensity = 0;       /// true water density [kg/m3]
+        public static double AtTemperature = 0;     /// measured at temperature [°C]
+        public static double Buoyancy = 0;
+    }
 }

Config/DatabaseSettings.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
 using System.Text;
@@ -15,9 +15,10 @@ namespace Config
         // Public fields
         public string BenchName;
         public bool IsRealBench;
-        public Users.DBSettings ProceduresDBSettings;		/// Config database settings
+        public Users.DBSettings ProceduresDBSettings;	/// Configuration database settings
 		public Users.DBSettings WaterMetersDBSettings;	/// Results database settings
-		public Users.DBSettings UsersDBSettings;		    /// Users database settings
+        public Users.DBSettings EventsDBSettings;	    /// Events database settings
+        public Users.DBSettings UsersDBSettings;		/// Shared configuration database settings
 
         // Constructor
         public DatabaseSettings()
@@ -26,6 +27,7 @@ namespace Config
             IsRealBench = false;
 			ProceduresDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
 			WaterMetersDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
+            EventsDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
 			UsersDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
         }
 
@@ -37,17 +39,19 @@ namespace Config
             result.IsRealBench  = IsRealBench;
 			result.ProceduresDBSettings = (Users.DBSettings)ProceduresDBSettings.Clone();
 			result.WaterMetersDBSettings = (Users.DBSettings)WaterMetersDBSettings.Clone();
-			result.UsersDBSettings = (Users.DBSettings)ProceduresDBSettings.Clone();
+            result.EventsDBSettings = (Users.DBSettings)EventsDBSettings.Clone();
+            result.UsersDBSettings = (Users.DBSettings)UsersDBSettings.Clone();
 
             return result;
         }
 
 		public override string ToString()
 		{
-            return string.Format("{0} config={1} results={2} users={3}",
+            return string.Format("{0} config={1} results={2} events={3} users={4}",
                                  BenchName,
                                  ProceduresDBSettings.ConnectionString,
                                  WaterMetersDBSettings.ConnectionString,
+                                 EventsDBSettings.ConnectionString,
                                  UsersDBSettings.ConnectionString);
 		}
     }

Config/Entities/BenchPath.cs

@@ -1,18 +1,19 @@
 ///
-/// Copyright (c) 2013-2016 Sensus Metering Systems
+/// Copyright (c) 2013-2017 Sensus Metering Systems
 ///
 using System;
 using System.Collections.Generic;
 
 namespace Config.Entities
 {
-	public class BenchPath : IHasItemNr, IHasValves
+	public class BenchPath : IHasName, IHasItemNr, IHasValves
     {
         public virtual int    Id { get; protected set; }
 		public virtual int    ItemNr { get; set; }
 		public virtual string Name { get; set; }
-        public virtual float  Qfrom { get; set; }        /// Water flow in [m3/h]
-        public virtual float  Qto { get; set; }          /// Water flow in [m3/h]
+        public virtual string OriName { get; set; }         /// Not mapped to database
+        public virtual float  Qfrom { get; set; }           /// Water flow in [m3/h]
+        public virtual float  Qto { get; set; }             /// Water flow in [m3/h]
         public virtual string TempMtrUp { get; set; }
         public virtual string TempMtrDown { get; set; }
         public virtual string PressMtrUp { get; set; }

Config/Entities/Component.cs

@@ -1,12 +1,13 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.IO;
 
 namespace Config.Entities
 {
-	public class Component : IHasItemNr
+	public class Component : IHasName, IHasItemNr
 	{
 		public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
@@ -17,12 +18,16 @@ namespace Config.Entities
 		public virtual LogLevel Logging { get; set; }
 		public virtual string Parameters { get; set; }
 		public virtual IList<MeasurementCorrection> Corrections { get; set; }
+        public virtual IList<Uncertainty> Uncertainties { get; set; }
 
 		/// ------------- Additional stuff not mapped into the database -------------
 
 		public Component()
 		{
+            Name = string.Empty;
+            ClassName = string.Empty;
 			Corrections = new List<MeasurementCorrection>();
+            Uncertainties = new List<Uncertainty>();
 		}
 
         public static Component CreateFromCfg(string name, string className, string parentName, int itemNr,
@@ -53,6 +58,59 @@ namespace Config.Entities
 			return result;
 		}
 
+        public virtual void Export(StreamWriter output)
+        {
+            output.WriteLine(Name);
+            output.WriteLine(ClassName);
+            output.WriteLine(ParentName);
+            output.WriteLine(Mode.ToString());
+            output.WriteLine(Logging.ToString());
+            output.Write(Parameters);
+
+            output.Close();
+        }
+
+        public static Component Import(StreamReader input)
+        {
+            Component result = new Component();
+
+            result.Name = input.ReadLine();
+            result.ClassName = input.ReadLine();
+            result.ParentName = input.ReadLine();
+
+            string line = input.ReadLine();
+            if (line.Equals(DebugMode.DetectedOff.ToString())) result.Mode = DebugMode.DetectedOff;
+            else if (line.Equals(DebugMode.DetectedOn.ToString())) result.Mode = DebugMode.DetectedOn;
+            else if (line.Equals(DebugMode.Normal.ToString())) result.Mode = DebugMode.Normal;
+            else if (line.Equals(DebugMode.AutoDetect.ToString())) result.Mode = DebugMode.AutoDetect;
+            else if (line.Equals(DebugMode.FailureDuringOperation.ToString())) result.Mode = DebugMode.FailureDuringOperation;
+            else if (line.Equals(DebugMode.Off.ToString())) result.Mode = DebugMode.Off;
+            else if (line.Equals(DebugMode.Record.ToString())) result.Mode = DebugMode.Record;
+            else if (line.Equals(DebugMode.Reply.ToString())) result.Mode = DebugMode.Reply;
+            else if (line.Equals(DebugMode.Simulate.ToString())) result.Mode = DebugMode.Simulate;
+            else if (line.Equals(DebugMode.Inherit.ToString())) result.Mode = DebugMode.Inherit;
+
+            line = input.ReadLine();
+            if (line.Equals(LogLevel.Off.ToString())) result.Logging = LogLevel.Off;
+            else if (line.Equals(LogLevel.Fatal.ToString())) result.Logging = LogLevel.Fatal;
+            else if (line.Equals(LogLevel.Error.ToString())) result.Logging = LogLevel.Error;
+            else if (line.Equals(LogLevel.Warn.ToString())) result.Logging = LogLevel.Warn;
+            else if (line.Equals(LogLevel.Info.ToString())) result.Logging = LogLevel.Info;
+            else if (line.Equals(LogLevel.Debug.ToString())) result.Logging = LogLevel.Debug;
+            else if (line.Equals(LogLevel.All.ToString())) result.Logging = LogLevel.All;
+
+            result.Parameters = string.Empty;
+            line = input.ReadLine();
+            while (line != null)
+            {
+                result.Parameters += line;
+                result.Parameters += Environment.NewLine;
+                line = input.ReadLine();
+            }
+
+            return result;
+        }
+
 		public virtual string ToString(string indent)
 		{
 			string result = string.Empty;
@@ -70,5 +128,10 @@ namespace Config.Entities
 
 			return result;
 		}
+
+        public override string ToString()
+        {
+            return string.Format("{0} ({1})", Name, ClassName);
+        }
 	}
 }

Config/Entities/ComponentProcedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Procedure Procedure { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentProcedure() { }
+
+        public ComponentProcedure(string name, string parameters, Procedure procedure)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Procedure = procedure;
+        }
+
+
 		public virtual ComponentProcedure Clone(Procedure newProcedure)
 		{
-			ComponentProcedure result = new ComponentProcedure();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-            result.Procedure = newProcedure;
-			return result;
+            return new ComponentProcedure(CmpntName, Parameters, newProcedure);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentProcedure result = new ComponentProcedure();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Procedure = newProcedure;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentProcedure(cmptnName, parameters, newProcedure);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
 	}
 }

Config/Entities/ComponentTest.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Test Test { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentTest() { }
+
+        public ComponentTest(string name, string parameters, Test test)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Test = test;
+        }
+
+
 		public virtual ComponentTest Clone()
 		{
-			ComponentTest result = new ComponentTest();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-			result.Test = Test;
-			return result;
+            return new ComponentTest(CmpntName, Parameters, Test);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentTest result = new ComponentTest();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Test = newTest;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentTest(cmptnName, parameters, newTest);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
     }
 }

Config/Entities/CustomEvent.cs

@@ -0,0 +1,93 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+using Config.CalendarEvent;
+
+namespace Config.Entities
+{
+    public class CustomEvent : Config.CalendarEvent.ICalendarEvent
+    {
+        public virtual int Id { get; protected set; }
+        public virtual DateTime Date { get; set; }               /// The Date that the event occurs
+        public virtual Frequency Frequency { get; set; }         /// A value indicating how often the event occurs
+        public virtual bool AllDay { get; set; }                 /// True if the time component of the date can be ignored
+        public virtual bool TriggerOnExactDayOnly { get; set; }  /// If this is a recurring event, set this to true to make the event show up only from the day specified forward
+        public virtual string Source { get; set; }               /// Source of this calendar event (becomes the source of the triggered event)
+        public virtual string Title { get; set; }                /// The name of the event (becomes the text of the triggered event)
+        public virtual AutoAction AutoAction { get; set; }       /// Automated action to be done or event to be triggered
+        public virtual string Parameters { get; set; }           /// Automated action parameters (e.g. name of a procedure to start)
+        public virtual int Rank { get; set; }                    /// The ranking of the event that determines the order in which it is displayed on a particular day
+        public virtual bool Hidden { get; set; }                 /// True if the event is enabled, otherwise false
+        public virtual bool ReadOnly { get; set; }               /// True if the event details cannot be modified
+        public virtual int BackColor { get; set; }               /// The color that the event show up in on the calendar: (MSB)AARRGGBB(LSB)
+        public virtual int TextColor { get; set; }               /// The text color of the event: (MSB)AARRGGBB(LSB)
+        public virtual bool TooltipEnabled { get; set; }         /// True if a tooltip should be displayed when hovering over the event
+        public virtual CustomRecurringFrequenciesHandler
+                           CustomRecurringFunction { get; set; } /// Not mapped to DB, always null
+
+        /// <summary>
+        /// CustomEvent Constructor
+        /// </summary>
+        public CustomEvent()
+        {
+        }
+
+        public CustomEvent(DateTime dateTime, string text)
+        {
+            Date = dateTime;
+            Frequency = Config.CalendarEvent.Frequency.Once;
+            AllDay = false;
+            TriggerOnExactDayOnly = false;
+            Source = "Calendar";
+            Title = text;
+            AutoAction = AutoAction.None;
+            Parameters = string.Empty;
+            Rank = 2;
+            Hidden = false;
+            ReadOnly = false;
+            BackColor = unchecked((int)0xFFFF5050);
+            TextColor = unchecked((int)0xFFFFFFFF);
+            TooltipEnabled = true;
+            CustomRecurringFunction = null;
+        }
+
+        public virtual Config.CalendarEvent.ICalendarEvent Clone()
+        {
+            return new CustomEvent
+            {
+                Date = this.Date,
+                Frequency = this.Frequency,
+                AllDay = this.AllDay,
+                TriggerOnExactDayOnly = this.TriggerOnExactDayOnly,
+                Source = this.Source,
+                Title = this.Title,
+                AutoAction = this.AutoAction,
+                Parameters = this.Parameters,
+                Rank = this.Rank,
+                Hidden = this.Hidden,
+                ReadOnly = this.ReadOnly,
+                BackColor = this.BackColor,
+                TextColor = this.TextColor,
+                TooltipEnabled = this.TooltipEnabled,
+                CustomRecurringFunction = this.CustomRecurringFunction,
+            };
+        }
+
+        /// <summary>
+        /// Returns true when updated
+        /// </summary>
+        /// <param name="currentDate">Current date and time</param>
+        /// <returns>true when the entity was updated</returns>
+        public virtual bool UpdateRecurringDate(DateTime currentDate)
+        {
+            return Config.CalendarEvent.Utils.UpdateRecurringDate(this, currentDate);
+        }
+
+
+        public override string ToString()
+        {
+            return Title;
+        }
+    }
+}

Config/Entities/Enums.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -38,20 +38,92 @@ namespace Config.Entities
         }
     }
 
-	public enum ProcedureState
+    /// <summary>
+    /// Flags returned by each device configuration control Verify(...) function.
+    /// </summary>
+    public enum CfgUpdateFlags
+    {
+        None = 0,
+        Error = 0x1,			/// Some settings in the user control are invalid and cannot be set
+        Warning = 0x02,			/// Some settings in the user control are suspicious, can be set after user confirmation
+        RestartRqrd = 0x04,		/// TBF program restart is required to apply all changed parameters
+        AnyChange = 0x08,		/// At least one parameter have changed
+        VolatileChange = 0x10,
+        InvokeCfgChange = 0x20,	/// Invoke CfgChange handler of the component 
+    }
+
+    public enum RemoteDBUse
+    {
+        [Description("Local DB only")]          LocalDBOnly,
+        [Description("Remote DB only")]         RemoteDBOnly,
+        [Description("Both DB-s, local 1st")]   BothDBsLocalFirst,
+        [Description("Both DB-s, remote 1st")]  BothDBsRemoteFirst,
+        Count
+    }
+
+    /// <summary>
+    /// Contains a procedure name and a database specification (local/remote).
+    /// </summary>
+    public class ProcedureInfo
+    {
+        public readonly string Name;
+        public readonly bool IsRemote;
+
+        public ProcedureInfo(string name, bool isRemote)
+        {
+            Name = name;
+            IsRemote = isRemote;
+        }
+    }
+
+    public enum ProcedureState
 	{
 		Active,
 		History,
-		Template,
 		Count,
 	}
 
+    public enum ProfileType
+    {
+        Q3R,
+        QnClassColdWater,
+        QnClassHotWater,
+        QpQi,
+        Manual,
+        Count,
+    }
+
+    public enum ErrorLimitType
+    {
+        Manual,
+        QpClass,
+        Count,
+    }
+
 	/// <summary> Kind of meters for the procedure / test </summary>
 	public enum MetersKind
 	{
-		Single,
-		Combined,
-        HeatMeter,
+#if LANG_DE
+		[Description("Wasserzähler")]			Single,
+		[Description("Verbundwasserzähler")]	Combined,
+		[Description("Wärmezähler")]			HeatMeter,
+#elif LANG_FR
+        [Description("Compteurs eau")]          Single,
+        [Description("Mètres composés")]        Combined,
+        [Description("Thermomètres")]           HeatMeter,
+#elif LANG_CS
+		[Description("Vodoměry")]				Single,
+		[Description("Kombinované vodoměry")]	Combined,
+		[Description("Měřiče tepla")]			HeatMeter,
+#elif LANG_RU
+        [Description("Счетчик")]                 Single,
+        [Description("Комбинированный счетчик")] Combined,
+        [Description("Счетчик тепла")]           HeatMeter,
+#else
+        [Description("Water meters")]			Single,
+		[Description("Compound water meters")]	Combined,
+		[Description("Heat meters")]			HeatMeter,
+#endif
 	}
 
 	public enum CompoundMeterId : byte
@@ -67,22 +139,32 @@ namespace Config.Entities
 
 	public enum Medium
 	{
-        [Description("")]  NotSpecified,
-		ColdWater,
-		HotWater,
+        [Description("")]       NotSpecified,
+#if LANG_PL
+        [Description("zimna")]  ColdWater,
+        [Description("ciepła")] HotWater,
+#elif LANG_IT
+        [Description("freddo")] ColdWater,
+        [Description("caldo")]  HotWater,
+#elif LANG_FR
+        [Description("eau froide")] ColdWater,
+        [Description("eau chaude")] HotWater,
+#else
+		[Description("cold")]   ColdWater,
+		[Description("hot")]    HotWater,
+#endif
         Count
     }
 
     public enum Mounting
     {
+        [Description("")]       NotSpecified,
 #if LANG_DE
-        [Description("")]  NotSpecified,
-        [Description("H")] H,              /// horizontal
-        [Description("V")] V,              /// vertical
-        [Description("STR")] S,            /// standrohre
-        [Description("F")] F,              /// fall
+        [Description("H")]      H,         /// horizontal
+        [Description("V")]      V,         /// vertical
+        [Description("STR")]    S,         /// standrohre
+        [Description("F")]      F,         /// fall
 #else
-        [Description("")]  NotSpecified,
         [Description("H")] H,              /// horizontal
         [Description("V")] V,              /// vertical
         [Description("S")] S,              /// steig
@@ -144,6 +226,17 @@ namespace Config.Entities
         Count
     }
 
+    /// <summary> Register reader type </summary>
+    public enum RegisterReaderType
+    {
+        Unknown,
+        Pulses,         /// Sick, optical and similar
+        Camera,         /// CLP1611
+        DataStream,     /// iPerl
+        Manual,         /// Entered by human via form (also from camera images)
+        Count
+    }
+
 	/// <summary> Transition step is finished when this condition is fulfilled </summary>
 	public enum StepCondition
 	{
@@ -155,34 +248,54 @@ namespace Config.Entities
 		Count
 	}
 
+    public enum MeretProtocol
+    {
+        [Description("<undefined>")]        Undefined,
+        [Description("Meret (obsolete)")]   Meret,
+        [Description("Modbus")]             Modbus,
+        Count
+    }
+
 	public enum Publish : sbyte
 	{
 #if LANG_DE
-        /// nemecky
+        /// german
         [Description("nie")]          Never = 0,
         [Description("immer")]        Always = 1,
         [Description("Bildschirm")]   OnScreen = 2,
         [Description("intern")]       Internal = 3,
+#elif LANG_FR
+        [Description("jamais")]       Never = 0,
+        [Description("toujours")]     Always = 1,
+        [Description("À l'écran")]    OnScreen = 2,
+        [Description("interne")]      Internal = 3,
 #elif LANG_CS
-        /// cesky
+        /// czech
         [Description("nikdy")]        Never = 0,
         [Description("vždy")]         Always = 1,
         [Description("na obrazovku")] OnScreen = 2,
         [Description("interně")]      Internal = 3,
 #elif LANG_SK
-        /// slovensky
+        /// slovak
         [Description("nikdy")]        Never = 0,
         [Description("vždy")]         Always = 1,
         [Description("na obrazovku")] OnScreen = 2,
         [Description("interne")]      Internal = 3,
 #elif LANG_PL
-        /// polsky
+        /// polish
         [Description("nigdy")]        Never = 0,
         [Description("zawsze")]       Always = 1,
         [Description("na ekranie")]   OnScreen = 2,
         [Description("wewnętrznie")]  Internal = 3,
+#elif LANG_RU
+        /// russian
+        [Description("никогда")]      Never = 0,
+        [Description("всегда")]       Always = 1,
+        [Description("толька экран")] OnScreen = 2,
+        [Description("внутренно")]    Internal = 3,
 #else
-        [Description("Never")]        Never = 0,
+		/// english
+		[Description("Never")]        Never = 0,
         [Description("Always")]       Always = 1,
         [Description("On screen")]    OnScreen = 2,
         [Description("Internal")]     Internal = 3,
@@ -197,6 +310,10 @@ namespace Config.Entities
 		[Description("Waage")]			Scale,
 		[Description("Spanne")]			Spread,
 		[Description("Standardabw.")]	StdDev,
+#elif LANG_FR
+        [Description("Balance")]        Scale,
+        [Description("Envergure")]      Spread,
+        [Description("Déviation std.")] StdDev,
 #elif LANG_CS
         /// cesky
 		[Description("váhou")]			Scale,
@@ -207,30 +324,46 @@ namespace Config.Entities
 		[Description("Spread")]			Spread,
 		[Description("Std.dev.")]		StdDev,
 #endif
-		Count
+        Count
 	}
 
-    public enum TestRedType
+    /// <summary>
+    /// Three state test results and/or water meter result (Algeria PT25 requirement).
+    /// NearlyOK means error is within error limits not narrowed by uncertainty
+    ///   OK:                   Uncertainty + ErrLimLo <= error <= ErrLimHi - Uncertainty
+    ///   NearlyOK:  not OK but stil          ErrLimLo <= error <= ErrLimHi
+    ///   Nok:       otherwise
+    /// </summary>
+    public enum ThreeState
     {
-        Fix,
-        /// etc.
-		Count,
-	}
+#if LANG_FR
+        [Description("NC")]         Nok,        /// Totally failed: not OK and not NearlyOK
+        [Description("2e/Ff")]      NearlyOK,   /// Nearly OK, not OK but not totally failed 
+        [Description("***")]        OK,         /// OK
+#else
+        [Description("NOK")]        Nok,        /// Totally failed: not OK and not NearlyOK
+        [Description("Nearly OK")]  NearlyOK,   /// Nearly OK, not OK but not totally failed 
+        [Description("OK")]         OK,         /// OK
+#endif
+        Count
+    }
 
-    public enum FQC1
+    public enum TestProfile
     {
-        FQC1,
-        FQP1,
-		Count,
-	}
+        UserDefined,
+        UserDefinedHeatMeter,
+        Protected,                  /// The first protected one
+        ProtectedHeatMeter,
+    }
 
 	public enum Progress
 	{
 		JustStarted,
-		TransitionBefore,
+        TransitionBefore,
 		SwitchingFlowDetection,
 		FlowSetting,
-		Test,
+        Aborted,                /// Use as an argument when a test was aborted
+        Test,
 		TransitionAfter,
 		Completed,
 		Count,
@@ -260,6 +393,14 @@ namespace Config.Entities
 		[Description("Prüfpunktergebnisse")]	TestResult,
 		[Description("Wasserzelledaten")]		MeterData,
 		[Description("Wasserzelleergebnisse")]	MeterResult,
+#elif LANG_FR
+        [Description("Autres")]                         Other,
+        [Description("Données de banc")]                BenchData,
+        [Description("Résultats du banc")]              BenchResult,
+        [Description("Données de test")]                TestData,
+        [Description("Résultats de test")]              TestResult,
+        [Description("Données du compteur d'eau")]      MeterData,
+        [Description("Résultats du compteur d'eau")]    MeterResult,
 #else
 		[Description("Other")]			Other,
 		[Description("Bench data")]		BenchData,
@@ -269,7 +410,7 @@ namespace Config.Entities
 		[Description("Meter data")]		MeterData,
 		[Description("Meter result")]	MeterResult,
 #endif
-		Count,
+        Count,
 	}
 
 	/// <summary> Possible modes of operation of components and devices. </summary>
@@ -286,6 +427,17 @@ namespace Config.Entities
         [Description("Reply")]          Reply,
         [Description("Simuliert")]      Simulate,				/// Test bench simulation, this mode does not require any hardware
         [Description("Geerbt")]         Inherit,
+#elif LANG_FR
+        [Description("Détection automatique: Éteindre")]    DetectedOff = -2,
+        [Description("Détection automatique: Allumé")]      DetectedOn = -1,
+        [Description("Ordinaire")]                          Normal = 0,
+        [Description("Détection automatique")]              AutoDetect,
+        [Description("Erreur d'exécution")]                 FailureDuringOperation,
+        [Description("Éteindre")]                           Off,
+        [Description("Record")]                             Record,
+        [Description("Répondre")]                           Reply,
+        [Description("Simuler")]                            Simulate,
+        [Description("Hériter")]                            Inherit,
 #else
         [Description("Detected off")]   DetectedOff = -2,
         [Description("Detected on")]    DetectedOn = -1,
@@ -298,7 +450,7 @@ namespace Config.Entities
         [Description("Simulate")]       Simulate,				/// Test bench simulation, this mode does not require any hardware
         [Description("Inherit")]        Inherit,
 #endif
-		Count,
+        Count,
     }
 
     public enum LogLevel
@@ -345,6 +497,11 @@ namespace Config.Entities
         [Description("zentriert")]  Center,
         [Description("rechts")]     Right,
         [Description("angepasst")]  Justified,
+#elif LANG_FR
+        [Description("gauche")]     Left,
+        [Description("centré")]     Center,
+        [Description("droit")]      Right,
+        [Description("justifié")]   Justified,
 #else
         [Description("Left")]       Left,
         [Description("Center")]     Center,
@@ -353,5 +510,136 @@ namespace Config.Entities
 #endif
         Count
     }
-}
 
+    public enum VertAlignment
+    {
+        [Description("Top")]        Top,
+        [Description("Middle")]     Middle,
+        [Description("Bottom")]     Bottom,
+    }
+
+    public enum TableForm
+    {
+        None,
+        Rows,
+        Columns,
+        ColumnsPL,
+        Count,
+    }
+
+	public enum ImageRotation
+	{
+		[Description("0 deg")]		None,
+		[Description("90 deg")]		Deg90,
+		[Description("180 deg")]	Deg180,
+		[Description("270 deg")]	Deg270,
+		Count
+	}
+
+    public enum CameraDisplayResolution
+    {
+        Small,
+        Medium,
+        Large,
+        // FullScreen,
+        Count,
+    }
+
+	public enum ErrorFlagsMode : sbyte
+	{
+#if LANG_DE
+		[Description("aus")]		Off,
+		[Description("info")]		Info,
+		[Description("ein")]		On,
+#elif LANG_FR
+        [Description("éteindre")]   Off,
+        [Description("info")]       Info,
+        [Description("allumé")]     On,
+#elif LANG_CS
+		[Description("vypnuto")]	Off,
+		[Description("info")]		Info,
+		[Description("zapnuto")]	On,
+#elif LANG_RU
+        [Description("выкл")]       Off,
+        [Description("инфо")]       Info,
+        [Description("вкл")]        On,
+#elif LANG_PL
+		[Description("nie")]		Off,
+		[Description("info")]		Info,
+		[Description("tak")]		On,
+#else // LANG_EN
+        [Description("off")]		Off,
+		[Description("info")]		Info,
+		[Description("on")]			On,
+#endif
+        Count
+	}
+
+
+    public enum ErrorFlagMask : long
+    {
+        E1 = (1L << 0),    /// shift = 0, E1 = 1L
+        E2 = (1L << 1),
+        E3 = (1L << 2),
+        E4 = (1L << 3),
+        E5 = (1L << 4),
+        E6 = (1L << 5),
+        E7 = (1L << 6),
+        E8 = (1L << 7),
+        E9 = (1L << 8),
+        E10 = (1L << 9),
+        E11 = (1L << 10),
+        E12 = (1L << 11),
+        E13 = (1L << 12),
+        E14 = (1L << 13),
+        E15 = (1L << 14),
+        E16 = (1L << 15),
+        E17 = (1L << 16),
+        E18 = (1L << 17),
+        E19 = (1L << 18),
+        E20 = (1L << 19),
+        E21 = (1L << 20),
+        E22 = (1L << 21),
+        E23 = (1L << 22),
+        E24 = (1L << 23),
+        E25 = (1L << 24),
+        E26 = (1L << 25),       /// iPERL: Invalid Q2 correction factors, mismatch between factors in the water meter and in DB
+        E27 = (1L << 26),       /// iPERL: Wrong counting direction
+        E28 = (1L << 27),       /// iPERL: Missing workflow step (assembly or test)
+        E29 = (1L << 28),
+        E30 = (1L << 29),
+        E31 = (1L << 30),
+        E32 = (1L << 31),
+        E33 = (1L << 32),
+        E34 = (1L << 33),
+        E35 = (1L << 34),
+        E36 = (1L << 35),
+        E37 = (1L << 36),
+        E38 = (1L << 37),
+        E39 = (1L << 38),
+        E40 = (1L << 39),
+        E41 = (1L << 40),
+        E42 = (1L << 41),
+        E43 = (1L << 42),
+        E44 = (1L << 43),
+        E45 = (1L << 44),
+        E46 = (1L << 45),
+        E47 = (1L << 46),
+        E48 = (1L << 47),
+        E49 = (1L << 48),
+        E50 = (1L << 49),
+        E51 = (1L << 50),
+        E52 = (1L << 51),
+        E53 = (1L << 52),
+        E54 = (1L << 53),
+        E55 = (1L << 54),
+        E56 = (1L << 55),
+        E57 = (1L << 56),
+        E58 = (1L << 57),
+        E59 = (1L << 58),
+        E60 = (1L << 59),
+        E61 = (1L << 60),
+        E62 = (1L << 61),
+        E63 = (1L << 62),
+    }
+}

Config/Entities/FeedingPath.cs

@@ -1,16 +1,17 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2017 Sensus Metering Systems
 ///
 using System;
 using System.Collections.Generic;
 
 namespace Config.Entities
 {
-	public class FeedingPath : IHasItemNr, IHasValves
+	public class FeedingPath : IHasName, IHasItemNr, IHasValves
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
 		public virtual string Name { get; set; }
+        public virtual string OriName { get; set; }         /// Not mapped to database
         public virtual float Qfrom { get; set; }            /// Water flow in [m3/h]
         public virtual float Qto { get; set; }              /// Water flow in [m3/h]
 		public virtual string Pump { get; set; }

Config/Entities/Group.cs

@@ -1,14 +1,27 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
+using System.Collections.Generic;
 
 namespace Config.Entities
 {
     public class Group
     {
         public virtual int Id { get; protected set; }
-        public virtual int Gid { get; set; }
-        public virtual string Name { get; set; }
+        public virtual Users.Entities.GID GID { get; set; }
+        public virtual long AccessFlags { get; set; }		/// Bitfield of access flags: bit0 .. bit62
+        public virtual IList<User> Users { get; set; }      /// Group can be a member of a list of users
+
+		public Group()
+		{
+            Users = new List<User>();
+		}
+
+        public Group(Users.Entities.GID gid)
+            : this()
+        {
+			GID = gid;
+		}
     }
 }

Config/Entities/HeatMetersPath.cs

@@ -1,15 +1,16 @@
 ///
-/// Copyright (c) 2016 Sensus Metering Systems
+/// Copyright (c) 2016-2017 Sensus Metering Systems
 ///
 using System;
 
 namespace Config.Entities
 {
-	public class HeatMetersPath : IHasItemNr
+	public class HeatMetersPath : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
 		public virtual string Name { get; set; }
+        public virtual string OriName { get; set; }         /// Not mapped to database
 
         public virtual float TempWarmFrom { get; set; }		/// Warm temperature range from [°C]
         public virtual float TempWarmTo { get; set; }       /// Warm temperature range to [°C]

Config/Entities/IHasName.cs

@@ -0,0 +1,11 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+namespace Config.Entities
+{
+	public interface IHasName
+	{
+		int Id { get; }
+		string Name { get; set; }
+	}
+}

Config/Entities/IParamsProvider.cs

@@ -1,10 +1,19 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
-namespace TBF.BenchControl.Generic
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace Config.Entities
 {
 	public interface IParamsProvider
 	{
+        /// <summary>
+        /// Get XML Serializer
+        /// </summary>
+        XmlSerializer GetSerializer();
+
 		string ComponentName { get; }
 
 		/// <summary>
@@ -13,13 +22,19 @@ namespace TBF.BenchControl.Generic
 		int ParamsCount();
 
 		/// <summary>
-		/// Parameter names
+		/// Returns a parameter name
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ParamName(int ix);
 
+        /// <summary>
+        /// Returns a list of possible values of one parameter (ComboBox when editing) or null (Textbox when editing).
+        /// </summary>
+        /// <param name="ix">Zero based index of the parameter</param>
+        IList<string> ParamValues(int ix);
+
 		/// <summary>
-		/// Parameter values in string form
+		/// Returns a parameter value in the string form
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ToString(int ix);
@@ -43,9 +58,13 @@ namespace TBF.BenchControl.Generic
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		/// <param name="strValue">String representation of the parameter</param>
-		void UpdateParam(int ix, string strValue);
+        CfgUpdateFlags UpdateParam(int ix, string strValue);
 
-		void UpdateDbEntity();
+        /// <summary>
+        /// Updates DB entities for related parameters
+        /// </summary>
+        /// <returns>true when successful</returns>
+        bool UpdateEmbeddedDbEntity();
 
         /// <summary>
         /// Creates an object copy

Config/Entities/IperlEnums.cs

@@ -0,0 +1,44 @@
+///
+/// Copyright (c) 2018 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+
+    public enum Side
+    {
+#if LANG_CS
+        [Description("Levá")]   Left,
+        [Description("Pravá")]  Right,
+#else
+        [Description("Left")]   Left,
+        [Description("Right")]  Right,
+#endif
+        Count
+    }
+
+    public enum FlowDir
+    {
+        R_L,
+        L_R,
+        Count
+    }
+
+    public enum Counting
+    {
+        Arbitrary,
+        Positive,
+        Negative,
+        Count
+    }
+
+    public enum OptoHeadState
+    {
+        Disabled,
+        OptoAndDirOK,
+        OptoNok,
+        DirNok,
+        Count
+    }
+}

Config/Entities/MeasurementCorrection.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 
@@ -8,7 +8,18 @@ namespace Config.Entities
 	public class MeasurementCorrection
 	{
 		public virtual int Id { get; protected set; }
+        public virtual int RangeIx { get; set; }        /// 0..5
 		public virtual float Measurement { get; set; }
 		public virtual float Correction { get; set; }
+
+        public MeasurementCorrection()
+        {
+            RangeIx = 0; 
+        }
+
+        public MeasurementCorrection(int rangeIx)
+        {
+            RangeIx = rangeIx; 
+        }
 	}
 }

Config/Entities/MeterTestResult.cs

@@ -1,67 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-
-namespace Config.Entities
-{
-    public class MeterTestResult
-    {
-        public virtual int Id { get; protected set; }
-        public virtual TestResult TestResult { get; set; }      /// reference to the TestResult entity
-
-		public virtual bool Disabled { get; set; }				/// true = this meter was disabled and the results should be disregarded
-		public virtual string SerialNr { get; set; }
-        public virtual string EndState { get; set; }
-        public virtual float VolumeStart { get; set; }          /// liter
-        public virtual float VolumeEnd { get; set; }            /// liter
-        public virtual float VolumeMeter { get; set; }          /// liter
-        public virtual float VolumeRef { get; set; }            /// liter
-        public virtual float VolumeErrorPct { get; set; }       /// %
-        public virtual float PulsesMeter { get; set; }			/// # of pulses
-        public virtual float PulsesPerLiter { get; set; }		/// Pulses per liter
-        public virtual float PulsesMaster { get; set; }
-        public virtual float Time { get; set; }                 /// sec.
-		public virtual float TimeStart { get; set; }            /// sec. - Not mapped to DB !!!
-		public virtual float TimeEnd { get; set; }              /// sec. - Not mapped to DB !!!
-		public virtual int CalibFactor { get; set; }			/// iPerl calibration factor used during the test - Not mapped to DB !!!
-		public virtual double Q2Correction { get; set; }		/// iPerl Q2 correction used during the test - Not mapped to DB !!!
-		public virtual bool Passed { get; set; }				/// true=test passed - Not mapped to DB !!!															
-
-        public MeterTestResult()
-        {
-            PulsesPerLiter = 1.0f;
-        }
-
-        public MeterTestResult(TestResult testResult)
-            : this()
-        {
-            TestResult = testResult;
-        }
-
-        public virtual MeterTestResult Clone(TestResult testResult)
-        {
-            MeterTestResult result = new MeterTestResult(testResult);
-
-			result.Disabled = Disabled;
-			result.SerialNr = SerialNr;
-            result.EndState = EndState;
-            result.VolumeStart = VolumeStart;
-            result.VolumeEnd = VolumeEnd;
-            result.VolumeMeter = VolumeMeter;
-            result.VolumeRef = VolumeRef;
-            result.VolumeErrorPct = VolumeErrorPct;
-            result.PulsesMeter = PulsesMeter;
-            result.PulsesPerLiter = PulsesPerLiter;
-            result.PulsesMaster = PulsesMaster;
-            result.Time = Time;
-			result.TimeStart = TimeStart;
-			result.TimeEnd = TimeEnd;
-			result.CalibFactor = CalibFactor;
-			result.Q2Correction = Q2Correction;
-			result.Passed = Passed;
-
-            return result;
-        }
-    }
-}

Config/Entities/MetersPath.cs

@@ -1,16 +1,17 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2017 Sensus Metering Systems
 ///
 using System;
 using System.Collections.Generic;
 
 namespace Config.Entities
 {
-	public class MetersPath : IHasItemNr
+	public class MetersPath : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
 		public virtual string Name { get; set; }
+        public virtual string OriName { get; set; }     /// Not mapped to database
 
         /// Sensors
 		public virtual string Sensor1 { get; set; }

Config/Entities/OutputPath.cs

@@ -1,16 +1,17 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2017 Sensus Metering Systems
 ///
 using System;
 using System.Collections.Generic;
 
 namespace Config.Entities
 {
-	public class OutputPath : IHasItemNr, IHasValves
+	public class OutputPath : IHasName, IHasItemNr, IHasValves
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
 		public virtual string Name { get; set; }
+        public virtual string OriName { get; set; }         /// Not mapped to database
         public virtual float Qfrom { get; set; }			/// Water flow in [m3/h]
         public virtual float Qto { get; set; }				/// Water flow in [m3/h]
         public virtual string RegulValve { get; set; }

Config/Entities/PTest.cs

@@ -0,0 +1,337 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using System;
+using System.Globalization;
+using System.IO;
+
+namespace Config.Entities
+{
+    /// <summary>
+    /// Test, consisting of one or more repetitions of the test 'SingleTest'.
+    /// </summary>
+	public class PTest : IHasName, IHasItemNr
+    {
+        public virtual int Id { get; protected set; }
+        public virtual int ItemNr { get; set; }
+        public virtual string Name { get; set; }
+        public virtual int Part { get; set; }				    /// Part=0 ... test of all WM-s                                                               /// Part>0 ... part of a set of tests with the same Name: subset of WM-s is given by MetersPath
+        public virtual double CoefQfrom { get; set; }           /// Water flow low limit in [m3/h]
+        public virtual double CoefQto { get; set; }				/// Water flow high limit in [m3/h]
+        public virtual double ErrLimLo { get; set; }			/// in [%] usually < 0, in case of heat meters: 1=class1, 2=class2, 3=class3
+        public virtual double ErrLimHi { get; set; }			/// in [%] usually > 0, in case of heat meters: -Qn in m3/h
+        public virtual double TempLimLo { get; set; }		    /// Lower limit for the controlled temperature
+        public virtual double TempLimHi { get; set; }		    /// Upper limit for the controlled temperature
+        public virtual double PressLimLo { get; set; }          /// [bar] min. water pressure                                            
+        public virtual double PressLimHi { get; set; }          /// [bar] max. water pressure                                            
+        public virtual sbyte Publish { get; set; }			    /// 0=no, 1=in all protocols, 2=on screen, 3=internal
+        public virtual bool Evaluate { get; set; }
+
+        public virtual sbyte E1 { get; set; }                   ///
+        public virtual sbyte E2 { get; set; }                   ///
+        public virtual sbyte E3 { get; set; }                   ///
+        public virtual sbyte E4 { get; set; }                   ///
+        public virtual sbyte E5 { get; set; }                   ///
+        public virtual sbyte E6 { get; set; }                   ///
+        public virtual sbyte E7 { get; set; }                   ///
+        public virtual sbyte E8 { get; set; }                   ///
+        public virtual sbyte E9 { get; set; }                   /// 0=off, 1=info, 2=evaluate
+        public virtual sbyte E10 { get; set; }                  ///
+        public virtual sbyte E11 { get; set; }                  ///
+        public virtual sbyte E12 { get; set; }                  ///
+        public virtual sbyte E13 { get; set; }                  ///
+        public virtual sbyte E14 { get; set; }                  ///
+        public virtual sbyte E15 { get; set; }                  ///
+        public virtual sbyte E16 { get; set; }                  ///
+        public virtual sbyte E21 { get; set; }                  ///
+
+        public virtual double Delta_Q_pct { get; set; }			/// [%]  max deviation from the mean flow
+        public virtual double Delta_T { get; set; }				/// [°C] max. T_up or T_down deviation from the mean temperature
+        public virtual double Delta_Tup_Tdn { get; set; }		/// [°C] max. difference abs(T_up - T_down)
+        public virtual double TestTime_min { get; set; }		/// [s]
+        public virtual double TestTime_max { get; set; }		/// [s]
+        public virtual double AmbTemp_min { get; set; }			/// [°C] min. ambient temperature
+        public virtual double AmbTemp_max { get; set; }			/// [°C] max. ambient temperature
+
+        public virtual double Coef_E9 { get; set; }				/// Coefficient used in E9, default 0.025
+        public virtual double Coef_E10 { get; set; }			/// Coefficient used in E10, default 0.04
+        public virtual double Coef_E11 { get; set; }			/// Coefficient used in E11, default 0.1
+        public virtual double Coef_E12 { get; set; }			/// Coefficient used in E12, default 1
+        public virtual double Offset_E9 { get; set; }           /// [s] default 0 (no offset)
+        public virtual double Offset_E12 { get; set; }          /// [s] default 0 (no offset)
+
+		public virtual Profile Profile { get; set; }
+
+        /// ------------- Additional stuff not mapped into the database -------------
+
+        public PTest()
+        {
+			///
+			/// Default values
+			///
+            Part = 0;
+            CoefQfrom = 1.0;
+            CoefQto = 1.1;
+            ErrLimLo = -2.0;		/// [%]
+            ErrLimHi = 2.0;			/// [%]
+            TempLimLo = 15.0;	    /// [°C]
+            TempLimHi = 25.0;	    /// [°C]
+            PressLimLo = 0;	        /// [bar]
+            PressLimHi = 16.0;	    /// [bar]
+            Publish = (sbyte)Config.Entities.Publish.Always;
+            Evaluate = true;
+
+            E1 = (sbyte)ErrorFlagsMode.On;
+            E2 = (sbyte)ErrorFlagsMode.On;
+            E3 = (sbyte)ErrorFlagsMode.On;
+            E4 = (sbyte)ErrorFlagsMode.On;
+            E5 = (sbyte)ErrorFlagsMode.On;
+            E6 = (sbyte)ErrorFlagsMode.On;
+            E7 = (sbyte)ErrorFlagsMode.On;
+            E8 = (sbyte)ErrorFlagsMode.On;
+            E9 = (sbyte)ErrorFlagsMode.On;
+            E10 = (sbyte)ErrorFlagsMode.On;
+            E11 = (sbyte)ErrorFlagsMode.On;
+            E12 = (sbyte)ErrorFlagsMode.On;
+            E13 = (sbyte)ErrorFlagsMode.On;
+            E14 = (sbyte)ErrorFlagsMode.On;
+            E15 = (sbyte)ErrorFlagsMode.On;
+            E16 = (sbyte)ErrorFlagsMode.Off;
+            E21 = (sbyte)ErrorFlagsMode.Off;
+
+            Delta_Q_pct = 5.0;		/// [%]
+            Delta_T = 10.0;		    /// [°C]
+            Delta_Tup_Tdn = 10.0;	/// [°C]
+            TestTime_min = 0;		/// [s]
+            TestTime_max = 99999;	/// [s]
+            AmbTemp_min = 5.0;	    /// [°C]
+            AmbTemp_max = 95.0;	    /// [°C]
+
+            Coef_E9 = 0.025;
+            Coef_E10 = 0.04;
+            Coef_E11 = 0.1;
+            Coef_E12 = 1.0;
+            Offset_E9 = 0;          /// [s]
+            Offset_E12 = 0;         /// [s]
+		}
+
+		public PTest(string name, int itemNr, Profile profile)
+			: this()
+		{
+			Name = name;
+			ItemNr = itemNr;
+			Profile = profile;
+		}
+
+        // Makes a new copy of this object (not just a reference)
+        public virtual PTest Clone()
+        {
+            PTest result = new PTest(Name, ItemNr, Profile);
+
+            result.Part = Part;
+            result.CoefQfrom = CoefQfrom;
+            result.CoefQto = CoefQto;
+			result.ErrLimLo = ErrLimLo;
+			result.ErrLimHi = ErrLimHi;
+			result.TempLimLo = TempLimLo;
+			result.TempLimHi = TempLimHi;
+            result.PressLimLo = PressLimLo;
+            result.PressLimHi = PressLimHi;
+            result.Publish = Publish;
+            result.Evaluate = Evaluate;
+
+            result.E1 = E1;
+            result.E2 = E2;
+            result.E3 = E3;
+            result.E4 = E4;
+            result.E5 = E5;
+            result.E6 = E6;
+            result.E7 = E7;
+            result.E8 = E8;
+            result.E9 = E9;
+            result.E10 = E10;
+            result.E11 = E11;
+            result.E12 = E12;
+            result.E13 = E13;
+            result.E14 = E14;
+            result.E15 = E15;
+            result.E16 = E16;
+            result.E21 = E21;
+
+            result.Delta_Q_pct = Delta_Q_pct;
+            result.Delta_T = Delta_T;
+            result.Delta_Tup_Tdn = Delta_Tup_Tdn;
+            result.TestTime_min = TestTime_min;
+            result.TestTime_max = TestTime_max;
+            result.AmbTemp_min = AmbTemp_min;
+            result.AmbTemp_max = AmbTemp_max;
+
+            result.Coef_E9 = Coef_E9;
+            result.Coef_E10 = Coef_E10;
+            result.Coef_E11 = Coef_E11;
+            result.Coef_E12 = Coef_E12;
+            result.Offset_E9 = Offset_E9;
+            result.Offset_E12 = Offset_E12;
+
+            return result;
+        }
+
+        public virtual void Export(StreamWriter output)
+        {
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            output.WriteLine(Name);
+            output.WriteLine(Part);
+            output.WriteLine(CoefQfrom.ToString(ci));
+            output.WriteLine(CoefQto.ToString(ci));
+            output.WriteLine(ErrLimLo.ToString(ci));
+            output.WriteLine(ErrLimHi.ToString(ci));
+			output.WriteLine(TempLimLo.ToString(ci));
+			output.WriteLine(TempLimHi.ToString(ci));
+            output.WriteLine(PressLimLo.ToString(ci));
+            output.WriteLine(PressLimHi.ToString(ci));
+            output.WriteLine(Publish.ToString());
+            output.WriteLine(Evaluate.ToString());
+
+            output.WriteLine(E1.ToString());
+            output.WriteLine(E2.ToString());
+            output.WriteLine(E3.ToString());
+            output.WriteLine(E4.ToString());
+            output.WriteLine(E5.ToString());
+            output.WriteLine(E6.ToString());
+            output.WriteLine(E7.ToString());
+            output.WriteLine(E8.ToString());
+            output.WriteLine(E9.ToString());
+            output.WriteLine(E10.ToString());
+            output.WriteLine(E11.ToString());
+            output.WriteLine(E12.ToString());
+            output.WriteLine(E13.ToString());
+            output.WriteLine(E14.ToString());
+            output.WriteLine(E15.ToString());
+            output.WriteLine(E16.ToString());
+            output.WriteLine(E21.ToString());
+
+            output.WriteLine(Delta_Q_pct.ToString(ci));
+            output.WriteLine(Delta_T.ToString(ci));
+            output.WriteLine(Delta_Tup_Tdn.ToString(ci));
+            output.WriteLine(TestTime_min.ToString(ci)); 
+            output.WriteLine(TestTime_max.ToString(ci));
+            output.WriteLine(AmbTemp_min.ToString(ci));
+            output.WriteLine(AmbTemp_max.ToString(ci));
+            
+            output.WriteLine(Coef_E9.ToString(ci));
+            output.WriteLine(Coef_E10.ToString(ci));
+            output.WriteLine(Coef_E11.ToString(ci));
+            output.WriteLine(Coef_E12.ToString(ci));
+            output.WriteLine(Offset_E9.ToString(ci));
+            output.WriteLine(Offset_E12.ToString(ci));
+        }
+
+        public static PTest Import(StreamReader input, Profile newProfile)
+        {
+            string firstLine = input.ReadLine();
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                return null;
+            }
+
+            CultureInfo ci = CultureInfo.InvariantCulture;
+            PTest tst = new PTest();
+
+            tst.Name = firstLine;
+            tst.Part = int.Parse(input.ReadLine());
+            tst.CoefQfrom = double.Parse(input.ReadLine(), ci);
+			tst.CoefQto = double.Parse(input.ReadLine(), ci);
+			tst.ErrLimLo = double.Parse(input.ReadLine(), ci);
+			tst.ErrLimHi = double.Parse(input.ReadLine(), ci);
+			tst.TempLimLo = double.Parse(input.ReadLine(), ci);
+			tst.TempLimHi = double.Parse(input.ReadLine(), ci);
+            tst.Publish = sbyte.Parse(input.ReadLine());
+            tst.Evaluate = bool.Parse(input.ReadLine());
+
+            /// TODO (E1 .. E21)
+
+            tst.Delta_Q_pct = double.Parse(input.ReadLine(), ci);
+            tst.Delta_T = double.Parse(input.ReadLine(), ci);
+            tst.Delta_Tup_Tdn = double.Parse(input.ReadLine(), ci);
+            tst.TestTime_min = double.Parse(input.ReadLine(), ci);
+            tst.TestTime_max = double.Parse(input.ReadLine(), ci);
+            tst.AmbTemp_min = double.Parse(input.ReadLine(), ci);
+            tst.AmbTemp_max = double.Parse(input.ReadLine(), ci);
+
+            tst.Coef_E9 = double.Parse(input.ReadLine(), ci);
+            tst.Coef_E10 = double.Parse(input.ReadLine(), ci);
+            tst.Coef_E11 = double.Parse(input.ReadLine(), ci);
+            tst.Coef_E12 = double.Parse(input.ReadLine(), ci);
+            tst.Offset_E9 = double.Parse(input.ReadLine(), ci);
+            tst.Offset_E12 = double.Parse(input.ReadLine(), ci);
+
+            tst.Profile = newProfile;
+            return tst;
+        }
+
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            string fmt = string.Format("Test {0} : ", Name) + "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            string firstLine = inp.ReadLine();
+            if (string.IsNullOrEmpty(firstLine)) return string.Format("Test {0} is missing in the file\r\n", Name);
+
+                                 if (Name != firstLine)               { diff.AppendFormat(fmt, "Name", Name, firstLine); };
+            ln = inp.ReadLine(); if (ln != Part.ToString())           { diff.AppendFormat(fmt, "Part", Part.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != CoefQfrom.ToString(ci))    { diff.AppendFormat(fmt, "CoefQfrom", CoefQfrom.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != CoefQto.ToString(ci))      { diff.AppendFormat(fmt, "CoefQto", CoefQto.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != ErrLimLo.ToString(ci))     { diff.AppendFormat(fmt, "ErrLimLo", ErrLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != ErrLimHi.ToString(ci))     { diff.AppendFormat(fmt, "ErrLimHi", ErrLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TempLimLo.ToString(ci))    { diff.AppendFormat(fmt, "TempLimLo", TempLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TempLimHi.ToString(ci))    { diff.AppendFormat(fmt, "TempLimHi", TempLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != PressLimLo.ToString(ci))   { diff.AppendFormat(fmt, "Pressure_min", PressLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != PressLimHi.ToString(ci))   { diff.AppendFormat(fmt, "Pressure_max", PressLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Publish.ToString())        { diff.AppendFormat(fmt, "Publish", Publish.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != Evaluate.ToString())       { diff.AppendFormat(fmt, "Evaluate", Evaluate.ToString(), ln); };
+
+            ln = inp.ReadLine(); if (ln != E1.ToString()) { diff.AppendFormat(fmt, "E1", E1.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E2.ToString()) { diff.AppendFormat(fmt, "E2", E2.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E3.ToString()) { diff.AppendFormat(fmt, "E3", E3.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E4.ToString()) { diff.AppendFormat(fmt, "E4", E4.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E5.ToString()) { diff.AppendFormat(fmt, "E5", E5.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E6.ToString()) { diff.AppendFormat(fmt, "E6", E6.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E7.ToString()) { diff.AppendFormat(fmt, "E7", E7.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E8.ToString()) { diff.AppendFormat(fmt, "E8", E8.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E9.ToString()) { diff.AppendFormat(fmt, "E9", E9.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E10.ToString()) { diff.AppendFormat(fmt, "E10", E10.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E11.ToString()) { diff.AppendFormat(fmt, "E11", E11.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E12.ToString()) { diff.AppendFormat(fmt, "E12", E12.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E13.ToString()) { diff.AppendFormat(fmt, "E13", E13.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E14.ToString()) { diff.AppendFormat(fmt, "E14", E14.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E15.ToString()) { diff.AppendFormat(fmt, "E15", E15.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E16.ToString()) { diff.AppendFormat(fmt, "E16", E16.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != E21.ToString()) { diff.AppendFormat(fmt, "E21", E21.ToString(), ln); };
+
+            ln = inp.ReadLine(); if (ln != Delta_Q_pct.ToString(ci)) { diff.AppendFormat(fmt, "Delta_Q_pct", Delta_Q_pct.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Delta_T.ToString(ci)) { diff.AppendFormat(fmt, "Delta_T", Delta_T.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Delta_Tup_Tdn.ToString(ci)) { diff.AppendFormat(fmt, "Delta_Tup_Tdn", Delta_Tup_Tdn.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TestTime_min.ToString(ci)) { diff.AppendFormat(fmt, "TestTime_min", TestTime_min.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TestTime_max.ToString(ci)) { diff.AppendFormat(fmt, "TestTime_max", TestTime_max.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != AmbTemp_min.ToString(ci)) { diff.AppendFormat(fmt, "AmbTemp_min", AmbTemp_min.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != AmbTemp_max.ToString(ci)) { diff.AppendFormat(fmt, "AmbTemp_max", AmbTemp_max.ToString(ci), ln); };
+
+            ln = inp.ReadLine(); if (ln != Coef_E9.ToString(ci)) { diff.AppendFormat(fmt, "Coef_E9", Coef_E9.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Coef_E10.ToString(ci)) { diff.AppendFormat(fmt, "Coef_E10", Coef_E10.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Coef_E11.ToString(ci)) { diff.AppendFormat(fmt, "Coef_E11", Coef_E11.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Coef_E12.ToString(ci)) { diff.AppendFormat(fmt, "Coef_E12", Coef_E12.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Offset_E9.ToString(ci)) { diff.AppendFormat(fmt, "Offset_E9", Offset_E9.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Offset_E12.ToString(ci)) { diff.AppendFormat(fmt, "Offset_E12", Offset_E12.ToString(ci), ln); };
+
+            return diff.ToString();
+        }
+
+		public override string ToString()
+		{
+			return string.Format("{0}", Name);
+		}
+    }
+}

Config/Entities/Procedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -11,7 +11,7 @@ namespace Config.Entities
     /// <summary>
     /// Stores one test procedure, supports revisions and history log
     /// </summary>
-	public class Procedure : IHasItemNr
+	public class Procedure : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
@@ -27,21 +27,43 @@ namespace Config.Entities
 		public virtual ProcedureState ProcedureState { get; set; }
 		public virtual int Revision { get; set; }
 		public virtual int PredecessorId { get; set; }
-		public virtual bool ObtainedByCopy { get; set; }
-		/// 
-		public virtual MetersKind MetersKind { get; set; }
+		public virtual bool ObtainedByCopy { get; set; }		/// Initial version of this procedure was a copy of another procedure
+        /// 
+		public virtual MetersKind MetersKind { get; set; }		/// single / compound / heat meters
 		public virtual string Watermeters { get; set; }			/// Water meter name or Id
-		public virtual string ProtocolTitle { get; set; }		/// Title of the printed and saved protocol
+        public virtual bool Protected { get; set; }             /// true = procedure cannot be changed by a testing specialist
+		public virtual bool MustBeComplete { get; set; }        /// true = procedure can be finished just when all tests were finished
+		public virtual bool ManualCtrlDisabled { get; set; }	/// true = manual control of valves, etc. is disabled
 
 		public virtual string DataEntry { get; set; }			/// Component to use for data entry
-		public virtual string ResultsPrinter { get; set; }		/// Component to use for printing the results
-		public virtual string ResultsWriter { get; set; }		/// Component to use for saving the results into the file
-		public virtual string TransitionStart { get; set; }
+		public virtual string ResultsPrinter { get; set; }		/// Component for printing results
+		public virtual string ResultsWriter { get; set; }		/// Component for saving results into a file
+        public virtual string EventTriggers { get; set; }       /// Component for analysing results and triggering events
+        public virtual string TransitionStart { get; set; }
 		public virtual string TransitionEnd { get; set; }
 
+        public virtual string AltProcName { get; set; }		    /// Alternative procedure name (null or string.Empty = no alt. procedure)
+        public virtual int AltProcPeriod { get; set; }			/// Period of alternative procedures (0 = no alt. procedure)
+
+        public virtual float DN { get; set; }                   /// Not mapped to DB, valid in ProceduresCtrl for procedure filtering only
+        public virtual float Qn { get; set; }                   ///   - ' ' -
+        public virtual string MClass { get; set; }              ///   - ' ' -
+        public virtual string Producer { get; set; }            ///   - ' ' -
+
 		public virtual IList<ComponentProcedure> MoreParams { get; set; }
 		public virtual IList<Test> Tests { get; set; }
 
+        /// Wrapper
+        public virtual IList<Test> RegularTests()
+        {
+            IList<Test> rslt = new List<Test>();
+            foreach (var t in Tests)
+            {
+                if ((t.Name.Length > 0 && t.Name[0] != '[') || !t.Name.Contains("]"))  rslt.Add(t);
+            }
+            return rslt;
+        }
+
         /// ------------- Additional stuff not mapped into the database -------------
 
         public Procedure()
@@ -57,7 +79,14 @@ namespace Config.Entities
 			LastChgUser = CreationUser;
 			LastChgTime = CreationTime;
 			MetersKind = Entities.MetersKind.Single;
-			ProtocolTitle = "Watermeter test protocol";
+			Watermeters = string.Empty;
+			Description = string.Empty;
+			LongDescription = string.Empty;
+
+            DN = 0;
+            Qn = 0;
+            MClass = string.Empty;
+            Producer = string.Empty;
         }
 
 		public Procedure(string name, int itemNr)
@@ -79,21 +108,28 @@ namespace Config.Entities
 			result.LastChgUser = LastChgUser;
 			result.LastChgTime = LastChgTime;
 			result.LongDescription = LongDescription;
-
 			result.ProcedureState = ProcedureState;
 			result.Revision = Revision;
 			result.PredecessorId = Id;
 			result.ObtainedByCopy = ObtainedByCopy;
-
 			result.MetersKind = MetersKind;
 			result.Watermeters = Watermeters;
-			result.ProtocolTitle = ProtocolTitle;
-
+            result.Protected = Protected;
+            result.MustBeComplete = MustBeComplete;
+			result.ManualCtrlDisabled = ManualCtrlDisabled;
 			result.DataEntry = DataEntry;
 			result.ResultsPrinter = ResultsPrinter;
 			result.ResultsWriter = ResultsWriter;
-			result.TransitionStart = TransitionStart;
+            result.EventTriggers = EventTriggers;
+            result.TransitionStart = TransitionStart;
 			result.TransitionEnd = TransitionEnd;
+            result.AltProcName = AltProcName;
+            result.AltProcPeriod = AltProcPeriod;
+
+            result.DN = DN;
+            result.Qn = Qn;
+            result.MClass = MClass;
+            result.Producer = Producer;
 
 			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone(result)); }
 			foreach (var test in Tests) { result.Tests.Add(test.Clone()); }
@@ -112,10 +148,13 @@ namespace Config.Entities
 			output.WriteLine(LastChgTime.ToString(CultureInfo.InvariantCulture));
 			output.WriteLine(MetersKind.ToString());
             output.WriteLine(Watermeters);
-            output.WriteLine(ProtocolTitle);
+            output.WriteLine(Protected.ToString());
+            output.WriteLine(MustBeComplete.ToString());
+			output.WriteLine(ManualCtrlDisabled.ToString());
             output.WriteLine(DataEntry);
             output.WriteLine(ResultsPrinter);
             output.WriteLine(ResultsWriter);
+            output.WriteLine(EventTriggers);
             output.WriteLine(TransitionStart); 
             output.WriteLine(TransitionEnd);
 
@@ -142,10 +181,13 @@ namespace Config.Entities
             string line = input.ReadLine();
             result.MetersKind = line.Equals(MetersKind.Single.ToString()) ? MetersKind.Single : (line.Equals(MetersKind.Combined.ToString()) ? MetersKind.Combined : MetersKind.HeatMeter);
             result.Watermeters = input.ReadLine();
-            result.ProtocolTitle = input.ReadLine();
+            result.Protected = bool.Parse(input.ReadLine());
+            result.MustBeComplete = bool.Parse(input.ReadLine());
+			result.ManualCtrlDisabled = bool.Parse(input.ReadLine());
             result.DataEntry = input.ReadLine();
             result.ResultsPrinter = input.ReadLine();
             result.ResultsWriter = input.ReadLine();
+            result.EventTriggers = input.ReadLine();
             result.TransitionStart = input.ReadLine();
             result.TransitionEnd = input.ReadLine();
 
@@ -170,6 +212,95 @@ namespace Config.Entities
             return result;
         }
 
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            const string fmt = "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+
+            ln = inp.ReadLine();            /// skip ItemNr
+            ln = inp.ReadLine(); if (ln != Name)                          { diff.AppendFormat(fmt, "Name", Name, ln); };
+            ln = inp.ReadLine(); if (ln != Description)                   { diff.AppendFormat(fmt, "Description", Description, ln); };
+            ln = inp.ReadLine();            /// skip CreationUser
+            ln = inp.ReadLine();            /// skip CreationTime
+            ln = inp.ReadLine();            /// skip LastChgUser
+            ln = inp.ReadLine();            /// skip LastChgTime
+            ln = inp.ReadLine(); if (ln != MetersKind.ToString())         { diff.AppendFormat(fmt, "MetersKind", MetersKind, ln); };
+            ln = inp.ReadLine(); if (ln != Watermeters)                   { diff.AppendFormat(fmt, "Watermeters", Watermeters, ln); };
+
+            ln = inp.ReadLine(); if (ln != Protected.ToString())          { diff.AppendFormat(fmt, "Protected", Protected, ln); };
+            ln = inp.ReadLine(); if (ln != MustBeComplete.ToString())     { diff.AppendFormat(fmt, "MustBeComplete", MustBeComplete, ln); };
+            ln = inp.ReadLine(); if (ln != ManualCtrlDisabled.ToString()) { diff.AppendFormat(fmt, "ManualCtrlDisabled", ManualCtrlDisabled, ln); };
+            ln = inp.ReadLine(); if (ln != DataEntry)                     { diff.AppendFormat(fmt, "DataEntry", DataEntry, ln); };
+            ln = inp.ReadLine(); if (ln != ResultsPrinter)                { diff.AppendFormat(fmt, "ResultsPrinter", ResultsPrinter, ln); };
+            ln = inp.ReadLine(); if (ln != ResultsWriter)                 { diff.AppendFormat(fmt, "ResultsWriter", ResultsWriter, ln); };
+            ln = inp.ReadLine(); if (ln != EventTriggers)                 { diff.AppendFormat(fmt, "EventTriggers", EventTriggers, ln); };
+            ln = inp.ReadLine(); if (ln != TransitionStart)               { diff.AppendFormat(fmt, "TransitionStart", TransitionStart, ln); };
+            ln = inp.ReadLine(); if (ln != TransitionEnd)                 { diff.AppendFormat(fmt, "TransitionEnd", TransitionEnd, ln); };
+
+            /// TODO Compare componentprocedure-s
+            while (ComponentProcedure.Import(inp, null) != null)
+            {
+            }
+
+
+            //foreach (var test in Tests)
+            //{
+            //    string testDiff = test.Compare(inp);
+            //    if (testDiff.Contains(
+            //}
+
+            //bool extraTestsInFile = true;
+            //while (Test.Import(inp, null) != null) { extraTestsInFile = true; }
+
+            return diff.ToString();
+        }
+
+        public virtual ComponentProcedure GetProcedureParamsEntity(string cmpntName)
+        {
+            foreach (var procPrms in MoreParams)
+            {
+                if (procPrms.CmpntName == cmpntName) return procPrms;
+            }
+            return null;
+        }
+
+
+        /// <summary>
+        /// Processes the selection done by the bench control panel in the main sequence.
+        /// </summary>
+        /// <param name="selection">Selection.Q1, .Q2, .Q3 or .Test</param>
+        /// <returns>The selected test or null</returns>
+        public virtual Test GetTest(string expandedTestName, out int testIx, out int repetNr)
+        {
+            for (int ix = 0; ix < Tests.Count; ix++)
+            {
+                Test test = Tests[ix];
+                if (test.Name.Equals(expandedTestName))
+                {
+                    /// Name is not expanded => Repeats==1
+                    testIx = ix;
+                    repetNr = 1;
+                    return test;
+                }
+
+                for (int r = 1; r <= test.Repeats; r++)
+                {
+                    if (test.GetExpandedTestName(r).Equals(expandedTestName))
+                    {
+                        testIx = ix;
+                        repetNr = r;
+                        return test;
+                    }
+                }
+            }
+
+            testIx = 0;
+            repetNr = 1;
+            return null;
+        }
+
+
 		public override string ToString()
 		{
 			return string.Format("{0}, rev.{1}", Name, Revision);

Config/Entities/ProcedureHistory.cs

@@ -1,31 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-
-namespace Config.Entities
-{
-    public class ProcedureHistory
-    {
-        public virtual int Id { get; protected set; }
-        public virtual Procedure Current { get; set; }
-        public virtual IList<Procedure> OldProcedures { get; set; }
-
-        /// ------------- Additional stuff not mapped into the database -------------
-
-        public ProcedureHistory()
-        {
-            Current = new Procedure();
-            OldProcedures = new List<Procedure>();
-        }
-
-        public virtual ProcedureHistory Clone()
-        {
-            ProcedureHistory result = new ProcedureHistory();
-            result.Current = Current.Clone();
-            foreach (Procedure p in OldProcedures) result.OldProcedures.Add(p.Clone());
-            return result;
-        }
-    }
-}

Config/Entities/Profile.cs

@@ -0,0 +1,143 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace Config.Entities
+{
+    /// <summary>
+    /// Stores one test procedure, supports revisions and history log
+    /// </summary>
+	public class Profile : IHasName, IHasItemNr
+    {
+        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; }			    /// Short description
+		public virtual string CreationUser { get; set; }		    /// Name of the user who has created or changed this procedure
+		public virtual DateTime CreationTime { get; set; }		    /// Date and time of the creation or change
+		public virtual string LastChgUser { get; set; }			    /// Name of the user who has created or changed this procedure
+		public virtual DateTime LastChgTime { get; set; }		    /// Date and time of the creation or change
+        public virtual ProfileType ProfileType { get; set; }
+        public virtual ErrorLimitType ErrorLimitType { get; set; }
+
+		public virtual IList<PTest> Tests { get; set; }
+
+        /// ------------- Additional stuff not mapped into the database -------------
+
+        public Profile()
+        {
+			Tests = new List<PTest>();
+
+			///
+			/// Default values
+			/// 
+			CreationUser = (Users.GlobalData.CurrentUser != null) ? Users.GlobalData.CurrentUser.UserName : null;
+			CreationTime = DateTime.Now;
+			LastChgUser = CreationUser;
+			LastChgTime = CreationTime;
+			Description = string.Empty;
+        }
+
+		public Profile(string name, int itemNr)
+			: this()
+		{
+			Name = name;
+			ItemNr = itemNr;
+		}
+
+        public virtual Profile Clone()
+        {
+            Profile result = new Profile();
+
+			result.ItemNr = ItemNr;
+			result.Name = Name;
+			result.Description = Description;
+			result.CreationUser = CreationUser;
+			result.CreationTime = CreationTime;
+			result.LastChgUser = LastChgUser;
+			result.LastChgTime = LastChgTime;
+            result.ProfileType = ProfileType;
+            result.ErrorLimitType = ErrorLimitType;
+
+			foreach (var test in Tests) { result.Tests.Add(test.Clone()); }
+
+            return result;
+        }
+
+        public virtual void Export(StreamWriter output)
+        {
+			output.WriteLine(ItemNr.ToString(CultureInfo.InvariantCulture));
+            output.WriteLine(Name);
+            output.WriteLine(Description);
+            output.WriteLine(CreationUser);
+			output.WriteLine(CreationTime.ToString(CultureInfo.InvariantCulture));
+            output.WriteLine(LastChgUser);
+			output.WriteLine(LastChgTime.ToString(CultureInfo.InvariantCulture));
+
+            foreach (var test in Tests) { test.Export(output); }
+            output.WriteLine();
+
+            output.Close();
+        }
+
+        public static Profile Import(StreamReader input)
+        {
+            Profile result = new Profile();
+
+			result.ItemNr = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+            result.Name = input.ReadLine();
+            result.Description = input.ReadLine();
+            result.CreationUser = input.ReadLine();
+			result.CreationTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+            result.LastChgUser = input.ReadLine();
+			result.LastChgTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+            string line = input.ReadLine();
+
+            while (true)
+            {
+                PTest tst = PTest.Import(input, result);
+                if (tst == null)
+                    break;
+                else
+                    result.Tests.Add(tst);
+            }
+
+            return result;
+        }
+
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            const string fmt = "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+
+            ln = inp.ReadLine();            /// skip ItemNr
+            ln = inp.ReadLine(); if (ln != Name)                          { diff.AppendFormat(fmt, "Name", Name, ln); };
+            ln = inp.ReadLine(); if (ln != Description)                   { diff.AppendFormat(fmt, "Description", Description, ln); };
+            ln = inp.ReadLine();            /// skip CreationUser
+            ln = inp.ReadLine();            /// skip CreationTime
+            ln = inp.ReadLine();            /// skip LastChgUser
+            ln = inp.ReadLine();            /// skip LastChgTime
+
+            //foreach (var test in Tests)
+            //{
+            //    string testDiff = test.Compare(inp);
+            //    if (testDiff.Contains(
+            //}
+
+            //bool extraTestsInFile = true;
+            //while (Test.Import(inp, null) != null) { extraTestsInFile = true; }
+
+            return diff.ToString();
+        }
+
+		public override string ToString()
+		{
+			return string.Format("{0}", Name);
+		}
+    }
+}

Config/Entities/Test.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -11,26 +11,31 @@ namespace Config.Entities
     /// <summary>
     /// Test, consisting of one or more repetitions of the test 'SingleTest'.
     /// </summary>
-	public class Test : IHasItemNr
+	public class Test : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
         public virtual int ItemNr { get; set; }
         public virtual string Name { get; set; }	
-		public virtual int Part { get; set; }			/// Part=0 ... test of all WM-s
-														/// Part>0 ... part of a set of tests with the same Name: subset of WM-s is given by MetersPath
-		public virtual sbyte Publish { get; set; }		/// 0=no, 1=in all protocols, 2=on screen, 3=internal
-		public virtual bool Evaluate { get; set; }
-		public virtual float Qfrom { get; set; }        /// Water flow low limit in [m3/h]
-        public virtual float Qto { get; set; }          /// Water flow high limit in [m3/h]
-		public virtual float Volume { get; set; }       /// Test volume (target) in [l]
-        public virtual float TstTime { get; set; }      /// Test time (estimate) in [s]
+		public virtual int Part { get; set; }				/// Part=0 ... test of all WM-s
+															/// Part>0 ... part of a set of tests with the same Name: subset of WM-s is given by MetersPath
+        public virtual TestProfile Profile { get; set; }    /// UserDefined, Protected, UserDefinedHeatMeter, ProtectedHeatMeter
+        public virtual sbyte Publish { get; set; }			/// 0=no, 1=in all protocols, 2=on screen, 3=internal
+		public virtual bool DoEvaluate { get; set; }
+        public virtual float Qtg { get; set; }              /// Target water flow [m3/h]
+        public virtual float Qfrom { get; set; }			/// Water flow low limit in [m3/h]
+        public virtual float Qto { get; set; }				/// Water flow high limit in [m3/h]
+		public virtual float Volume { get; set; }			/// Test volume (target) in [l]
+        public virtual float TstTime { get; set; }			/// Test time (estimate) in [s]
         public virtual string Method { get; set; }
-        public virtual float ErrLimLo { get; set; }     /// in [%] (usually < 0)
-        public virtual float ErrLimHi { get; set; }     /// in [%] (usually > 0)
-        public virtual float Uncertainty { get; set; }	///	int [%] makes error limits tighter: 0 <= Uncertainty <= abs(ErrLimXx)
+        public virtual float ErrLimLo { get; set; }			/// in [%] usually < 0, in case of heat meters: 1=class1, 2=class2, 3=class3
+        public virtual float ErrLimHi { get; set; }			/// in [%] usually > 0, in case of heat meters: -Qn in m3/h
+        public virtual float Uncertainty { get; set; }		///	int [%] makes error limits tighter: 0 <= Uncertainty <= abs(ErrLimXx)
         public virtual int Repeats { get; set; }
-        public virtual bool Draining { get; set; }
-        public virtual bool Zeroing { get; set; }
+        public virtual bool DoDraining { get; set; }
+        public virtual bool DoDrainingAfter { get; set; }
+		public virtual bool DoControlWaterTemp { get; set; }
+		public virtual float TempLimLo { get; set; }		/// Lower limit for the controlled temperature
+		public virtual float TempLimHi { get; set; }		/// Upper limit for the controlled temperature
 		public virtual float PumpPower { get; set; }		/// Power of the pump in [%] in the range 0 .. 100.0f, use values 0% and 100% for non-FM pumps
         public virtual int MassRepeats { get; set; }		/// Number of mass. measurements at the beginning/end of test, 0 = default (=5)
         public virtual float MassSpread { get; set; }		/// Max spread of mass. measurements at the beginning/end of test, 0 = default
@@ -40,7 +45,7 @@ namespace Config.Entities
         public virtual int TimePump2StartV { get; set; }	/// Delay time from the start of the pump to opening the start valve in [s]
         public virtual int TimeStop2Mass { get; set; }		/// Delay time from the test end (diverted) to the 2nd mass measuremen in [s]
 		public virtual double TolerRed { get; set; }		///  = Filter
-        public virtual TestRedType RedType { get; set; }
+        public virtual string RedType { get; set; }
 		public virtual string FeedingPath { get; set; }
 		public virtual string BenchPath { get; set; }
 		public virtual string OutputPath { get; set; }
@@ -50,9 +55,11 @@ namespace Config.Entities
 #endif
         public virtual string RelTransBefore { get; set; }
 		public virtual string RelTransBetween { get; set; }
-		public virtual string RelTransAfter { get; set; }
 		public virtual string TransitionAfter { get; set; }
 
+        public virtual bool IsOuterLoopStart { get; set; }  /// Not mapped to database
+        public virtual bool IsOuterLoopEnd { get; set; }    /// Not mapped to database
+
 		public virtual IList<ComponentTest> MoreParams { get; set; }
 
 		public virtual Procedure Procedure { get; set; }
@@ -66,11 +73,16 @@ namespace Config.Entities
 			///
 			/// Default values
 			///
-			Publish = (sbyte)Config.Entities.Publish.Always;
-			Evaluate = true;
+            Part = 0;
+            Profile = TestProfile.UserDefined;
+            Publish = (sbyte)Config.Entities.Publish.Always;
+			DoEvaluate = true;
 			Repeats = 1;
-			Draining = false;
-			Zeroing = false;
+			DoDraining = false;
+			DoDrainingAfter = false;
+			DoControlWaterTemp = false;
+			TempLimLo = 15.0f;
+			TempLimHi = 25.0f;
 			ErrLimLo = -2.0f;				/// [%] lower error limit
 			ErrLimHi = 2.0f;				/// [%] upper error limit
 			Uncertainty = 0;
@@ -85,7 +97,6 @@ namespace Config.Entities
             TolerRed = 0;					/// = Filter parameter
 			RelTransBefore  = string.Empty;
 			RelTransBetween = string.Empty;
-			RelTransAfter   = string.Empty;
 			TransitionAfter = string.Empty;
 		}
 
@@ -103,15 +114,24 @@ namespace Config.Entities
             Test result = new Test(Name, ItemNr, Procedure);
 
 			result.Part = Part;
-			result.Publish = Publish;
-			result.Evaluate = Evaluate;
+            result.Profile = Profile;
+            result.Publish = Publish;
+			result.DoEvaluate = DoEvaluate;
+            result.Qtg = Qtg;
 			result.Qfrom = Qfrom;
             result.Qto = Qto;
 			result.Volume = Volume;
 			result.TstTime = TstTime;
+			result.Method = Method;
+			result.ErrLimLo = ErrLimLo;
+			result.ErrLimHi = ErrLimHi;
+			result.Uncertainty = Uncertainty;
 			result.Repeats = Repeats;
-            result.Draining = Draining;
-            result.Zeroing = Zeroing;
+            result.DoDraining = DoDraining;
+            result.DoDrainingAfter = DoDrainingAfter;
+			result.DoControlWaterTemp = DoControlWaterTemp;
+			result.TempLimLo = TempLimLo;
+			result.TempLimHi = TempLimHi;
 			result.PumpPower = PumpPower;
             result.MassRepeats = MassRepeats;
             result.MassSpread = MassSpread;
@@ -120,10 +140,6 @@ namespace Config.Entities
             result.TimeFlow2Mass = TimeFlow2Mass;
             result.TimePump2StartV = TimePump2StartV;
 			result.TimeStop2Mass = TimeStop2Mass;
-			result.Method = Method;
-			result.ErrLimLo = ErrLimLo;
-            result.ErrLimHi = ErrLimHi;
-			result.Uncertainty = Uncertainty;
 			result.TolerRed = TolerRed;
             result.RedType = RedType;
 			result.FeedingPath = FeedingPath;
@@ -135,7 +151,6 @@ namespace Config.Entities
 #endif
 			result.RelTransBefore = RelTransBefore;
 			result.RelTransBetween = RelTransBetween;
-			result.RelTransAfter = RelTransAfter;
 			result.TransitionAfter = TransitionAfter;
 			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
 
@@ -144,36 +159,42 @@ namespace Config.Entities
 
         public virtual void Export(StreamWriter output)
         {
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
             output.WriteLine(Name);
-            output.WriteLine(Part.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Publish.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Evaluate.ToString());
-            output.WriteLine(Qfrom.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Qto.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Volume.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(TstTime.ToString(CultureInfo.InvariantCulture));
+            output.WriteLine(Part.ToString(ci));
+            output.WriteLine(Publish.ToString(ci));
+            output.WriteLine(DoEvaluate.ToString());
+            output.WriteLine(Qtg.ToString(ci));
+            output.WriteLine(Qfrom.ToString(ci));
+            output.WriteLine(Qto.ToString(ci));
+            output.WriteLine(Volume.ToString(ci));
+            output.WriteLine(TstTime.ToString(ci));
             output.WriteLine(Method);
-            output.WriteLine(ErrLimLo.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(ErrLimHi.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Uncertainty.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Repeats.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(Draining.ToString());
-            output.WriteLine(Zeroing.ToString());
-            output.WriteLine(PumpPower.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(MassRepeats.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(MassSpread.ToString(CultureInfo.InvariantCulture));
-			output.WriteLine(((byte)MassMethod).ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(TimeBeforeFlow.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(TimeFlow2Mass.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(TimePump2StartV.ToString(CultureInfo.InvariantCulture));
-            output.WriteLine(TimeStop2Mass.ToString(CultureInfo.InvariantCulture));
+            output.WriteLine(ErrLimLo.ToString(ci));
+            output.WriteLine(ErrLimHi.ToString(ci));
+            output.WriteLine(Uncertainty.ToString(ci));
+            output.WriteLine(Repeats.ToString(ci));
+            output.WriteLine(DoDraining.ToString());
+            output.WriteLine(DoDrainingAfter.ToString());
+			output.WriteLine(DoControlWaterTemp.ToString());
+			output.WriteLine(TempLimLo.ToString(ci));
+			output.WriteLine(TempLimHi.ToString(ci));
+			output.WriteLine(PumpPower.ToString(ci));
+            output.WriteLine(MassRepeats.ToString(ci));
+            output.WriteLine(MassSpread.ToString(ci));
+			output.WriteLine(((byte)MassMethod).ToString(ci));
+            output.WriteLine(TimeBeforeFlow.ToString(ci));
+            output.WriteLine(TimeFlow2Mass.ToString(ci));
+            output.WriteLine(TimePump2StartV.ToString(ci));
+            output.WriteLine(TimeStop2Mass.ToString(ci));
             output.WriteLine(FeedingPath);
             output.WriteLine(BenchPath);
             output.WriteLine(OutputPath);
             output.WriteLine(MetersPath);
             output.WriteLine(RelTransBefore);
             output.WriteLine(RelTransBetween);
-            output.WriteLine(RelTransAfter);
+            output.WriteLine(Profile);
             output.WriteLine(TransitionAfter);
 
             foreach (var prms in MoreParams) { prms.Export(output); }
@@ -183,40 +204,51 @@ namespace Config.Entities
         public static Test Import(StreamReader input, Procedure newProcedure)
         {
             string firstLine = input.ReadLine();
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                return null;
+            }
 
-            if (string.IsNullOrEmpty(firstLine)) return null;
-
+            CultureInfo ci = CultureInfo.InvariantCulture;
             Test tst = new Test();
+
             tst.Name = firstLine;
-			tst.Part = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Publish = sbyte.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Evaluate = bool.Parse(input.ReadLine());
-			tst.Qfrom = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Qto = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Volume = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.TstTime = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+			tst.Part = int.Parse(input.ReadLine(), ci);
+			tst.Publish = sbyte.Parse(input.ReadLine(), ci);
+			tst.DoEvaluate = bool.Parse(input.ReadLine());
+            tst.Qtg = float.Parse(input.ReadLine(), ci);
+            tst.Qfrom = float.Parse(input.ReadLine(), ci);
+			tst.Qto = float.Parse(input.ReadLine(), ci);
+			tst.Volume = float.Parse(input.ReadLine(), ci);
+			tst.TstTime = float.Parse(input.ReadLine(), ci);
             tst.Method = input.ReadLine();
-			tst.ErrLimLo = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.ErrLimHi = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Uncertainty = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.Repeats = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-            tst.Draining = bool.Parse(input.ReadLine());
-			tst.Zeroing = bool.Parse(input.ReadLine());
-			tst.PumpPower = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.MassRepeats = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.MassSpread = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.MassMethod = (MassMethod)byte.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.TimeBeforeFlow = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.TimeFlow2Mass = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.TimePump2StartV = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
-			tst.TimeStop2Mass = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+			tst.ErrLimLo = float.Parse(input.ReadLine(), ci);
+			tst.ErrLimHi = float.Parse(input.ReadLine(), ci);
+			tst.Uncertainty = float.Parse(input.ReadLine(), ci);
+			tst.Repeats = int.Parse(input.ReadLine(), ci);
+            tst.DoDraining = bool.Parse(input.ReadLine());
+			tst.DoDrainingAfter = bool.Parse(input.ReadLine());
+			tst.DoControlWaterTemp = bool.Parse(input.ReadLine());
+			tst.TempLimLo = float.Parse(input.ReadLine(), ci);
+			tst.TempLimHi = float.Parse(input.ReadLine(), ci);
+			tst.PumpPower = float.Parse(input.ReadLine(), ci);
+			tst.MassRepeats = int.Parse(input.ReadLine(), ci);
+			tst.MassSpread = float.Parse(input.ReadLine(), ci);
+			tst.MassMethod = (MassMethod)byte.Parse(input.ReadLine(), ci);
+			tst.TimeBeforeFlow = int.Parse(input.ReadLine(), ci);
+			tst.TimeFlow2Mass = int.Parse(input.ReadLine(), ci);
+			tst.TimePump2StartV = int.Parse(input.ReadLine(), ci);
+			tst.TimeStop2Mass = int.Parse(input.ReadLine(), ci);
             tst.FeedingPath = input.ReadLine();
             tst.BenchPath = input.ReadLine();
             tst.OutputPath = input.ReadLine();
             tst.MetersPath = input.ReadLine();
             tst.RelTransBefore = input.ReadLine();
             tst.RelTransBetween = input.ReadLine();
-            tst.RelTransAfter = input.ReadLine();
+            string line = input.ReadLine();
+            tst.Profile = line.Equals(TestProfile.ProtectedHeatMeter.ToString()) ? TestProfile.ProtectedHeatMeter
+                          : line.Equals(TestProfile.UserDefinedHeatMeter.ToString()) ? TestProfile.UserDefinedHeatMeter
+                          : line.Equals(TestProfile.Protected.ToString()) ? TestProfile.Protected : TestProfile.UserDefined;  /// UserDefined is the default
             tst.TransitionAfter = input.ReadLine();
 
             while (true)
@@ -232,11 +264,179 @@ namespace Config.Entities
             return tst;
         }
 
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            string fmt = string.Format("Test {0} : ", Name) + "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            string firstLine = inp.ReadLine();
+            if (string.IsNullOrEmpty(firstLine)) return string.Format("Test {0} is missing in the file\r\n", Name);
+
+                                 if (Name != firstLine)                     { diff.AppendFormat(fmt, "Name", Name, firstLine); };
+            ln = inp.ReadLine(); if (ln != Part.ToString(ci))               { diff.AppendFormat(fmt, "Part", Part.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Publish.ToString(ci))            { diff.AppendFormat(fmt, "Publish", Publish.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != DoEvaluate.ToString(ci))         { diff.AppendFormat(fmt, "Evaluate", DoEvaluate.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Qtg.ToString(ci))                { diff.AppendFormat(fmt, "Qtg", Qtg.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Qfrom.ToString(ci))              { diff.AppendFormat(fmt, "Qfrom", Qfrom.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Qto.ToString(ci))                { diff.AppendFormat(fmt, "Qto", Qto.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Volume.ToString(ci))             { diff.AppendFormat(fmt, "Volume", Volume.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TstTime.ToString(ci))            { diff.AppendFormat(fmt, "TstTime", TstTime.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Method)                          { diff.AppendFormat(fmt, "Method", Method, ln); };
+            ln = inp.ReadLine(); if (ln != ErrLimLo.ToString(ci))           { diff.AppendFormat(fmt, "ErrLimLo", ErrLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != ErrLimHi.ToString(ci))           { diff.AppendFormat(fmt, "ErrLimHi", ErrLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Uncertainty.ToString(ci))        { diff.AppendFormat(fmt, "Uncertainty", Uncertainty.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Repeats.ToString(ci))            { diff.AppendFormat(fmt, "Repeats", Repeats.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != DoDraining.ToString(ci))         { diff.AppendFormat(fmt, "Draining", DoDraining.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != DoDrainingAfter.ToString(ci))    { diff.AppendFormat(fmt, "Zeroing", DoDrainingAfter.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != DoControlWaterTemp.ToString())   { diff.AppendFormat(fmt, "DoControlWaterTemp", DoControlWaterTemp.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TempLimLo.ToString(ci))          { diff.AppendFormat(fmt, "TempLimLo", TempLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TempLimHi.ToString(ci))          { diff.AppendFormat(fmt, "TempLimHi", TempLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != PumpPower.ToString(ci))          { diff.AppendFormat(fmt, "PumpPower", PumpPower.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != MassRepeats.ToString(ci))        { diff.AppendFormat(fmt, "MassRepeats", MassRepeats.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != MassSpread.ToString(ci))         { diff.AppendFormat(fmt, "MassSpread", MassSpread.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != ((byte)MassMethod).ToString(ci)) { diff.AppendFormat(fmt, "MassMethod", ((byte)MassMethod).ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TimeBeforeFlow.ToString(ci))     { diff.AppendFormat(fmt, "TimeBeforeFlow", TimeBeforeFlow.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TimeFlow2Mass.ToString(ci))      { diff.AppendFormat(fmt, "TimeFlow2Mass", TimeFlow2Mass.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TimePump2StartV.ToString(ci))    { diff.AppendFormat(fmt, "TimePump2StartV", TimePump2StartV.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TimeStop2Mass.ToString(ci))      { diff.AppendFormat(fmt, "TimeStop2Mass", TimeStop2Mass.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != FeedingPath)                     { diff.AppendFormat(fmt, "FeedingPath", FeedingPath, ln); };
+            ln = inp.ReadLine(); if (ln != BenchPath)                       { diff.AppendFormat(fmt, "BenchPath", BenchPath, ln); };
+            ln = inp.ReadLine(); if (ln != OutputPath)                      { diff.AppendFormat(fmt, "OutputPath", OutputPath, ln); };
+            ln = inp.ReadLine(); if (ln != MetersPath)                      { diff.AppendFormat(fmt, "MetersPath", MetersPath, ln); };
+            ln = inp.ReadLine(); if (ln != RelTransBefore)                  { diff.AppendFormat(fmt, "RelTransBefore", RelTransBefore, ln); };
+            ln = inp.ReadLine(); if (ln != RelTransBetween)                 { diff.AppendFormat(fmt, "RelTransBetween", RelTransBetween, ln); };
+            ln = inp.ReadLine(); if (ln != Profile.ToString())            { diff.AppendFormat(fmt, "RelTransAfter", Profile, ln); };
+            ln = inp.ReadLine(); if (ln != TransitionAfter)                 { diff.AppendFormat(fmt, "TransitionAfter", TransitionAfter, ln); };
+
+            return diff.ToString();
+        }
+
+        public virtual ComponentTest GetTestParamsEntity(string cmpntName)
+        {
+            foreach (var tstPrms in MoreParams)
+            {
+                if (tstPrms.CmpntName == cmpntName) return tstPrms;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Return test title for a this test and a given repetition number
+        /// </summary>
+        /// <param name="repetitonNr">1 .. Nr. repetitions</param>
+        /// <returns>Test title (string)</returns>
+        public virtual string GetExpandedTestName(int repetitionNr)
+        {
+            if (Repeats == 1)
+            {
+                if (Part == 0)
+                {
+                    /// Single test
+                    return Name;
+                }
+                else
+                {
+                    /// A part of a single test
+                    return string.Format("{0} ({1})", Name, Part);
+                }
+            }
+            else
+            {
+                /// More test repetitions
+                return string.Format("{0} ({1}/{2})", Name, repetitionNr, Repeats);
+            }
+        }
+
+        public virtual double GetErrLimLo(double volumeCTV, double testTime)
+        {
+            if (ErrLimLo <= ErrLimHi)
+            {
+                return ErrLimLo;                        /// Error limit of a water meter
+            }
+            else
+            {
+                /// Metrological class and nominal flow of a heat meter
+                int metrClass = (int)Math.Round(ErrLimLo);
+                double Qp = Math.Abs(ErrLimHi);
+                double Q = (testTime == 0) ? 1 : Math.Max(3.6 * volumeCTV / testTime, 0.00001); /// Div. by zero avoided
+
+                /// Calculate the error limit of a heat meter
+                switch (metrClass)
+                {
+                    default:
+                    case 1: return -Math.Min(3.5, 1.0 + 0.01 * Qp / Q);
+                    case 2: return -Math.Min(5.0, 2.0 + 0.02 * Qp / Q);
+                    case 3: return -Math.Min(5.0, 3.0 + 0.05 * Qp / Q);
+                }
+            }
+        }
+
+        public virtual double GetErrLimHi(double volumeCTV, double testTime)
+        {
+            if (ErrLimLo <= ErrLimHi)
+            {
+                return ErrLimHi;                        /// Error limit of a water meter
+            }
+            else
+            {
+                /// Metrological class and nominal flow of a heat meter
+                int metrClass = (int)Math.Round(ErrLimLo);
+                double Qp = Math.Abs(ErrLimHi);
+                double Q = (testTime == 0) ? 1 : Math.Max(3.6 * volumeCTV / testTime, 0.00001); /// Div. by zero avoided
+
+                /// Calculate the error limit of a heat meter
+                switch (metrClass)
+                {
+                    default:
+                    case 1: return +Math.Min(3.5, 1.0 + 0.01 * Qp / Q);
+                    case 2: return +Math.Min(5.0, 2.0 + 0.02 * Qp / Q);
+                    case 3: return +Math.Min(5.0, 3.0 + 0.05 * Qp / Q);
+                }
+            }
+        }
+
+		public virtual bool IsPartCompatible(int waterMeterPartNr)
+		{
+			if ((this.Part == 0) || (waterMeterPartNr == 0)) return true;
+
+			if ((this.Part % 10) == waterMeterPartNr) return true;
+			if (((this.Part / 10) % 10) == waterMeterPartNr) return true;
+			if (((this.Part / 100) % 10) == waterMeterPartNr) return true;
+			if (((this.Part / 1000) % 10) == waterMeterPartNr) return true;
+
+			return false;
+		}
+
+		/// <summary>
+		/// Determines whether tests part number is OK.
+		/// Examples of correct part number are:
+		///	1, 2, 12, 21 in case of max. part nr.== 2
+		///	1, 2, 3, 4, 12, 13, 14, 23, 24, 34, 123, 124, 134, 234, 1234 in case of max. part nr.== 4
+		/// </summary>
+		/// <param name="partNr">Tests par tnumber</param>
+		/// <returns>true when Part number is OK</returns>
+		public static bool IsGoodPartNr(int partNr)
+		{
+			bool firstDigitIsOK  = ((partNr % 10) > 0) && ((partNr % 10) <= Config.Data.MaxPartNr);
+			bool secondDigitIsOK = (((partNr/10) % 10) > 0) && (((partNr/10) % 10) <= Config.Data.MaxPartNr);
+			bool thirdDigitIsOK  = (((partNr/100) % 10) > 0) && (((partNr/100) % 10) <= Config.Data.MaxPartNr);
+			bool fourthDigitIsOK = (((partNr/1000) % 10) > 0) && (((partNr/1000) % 10) <= Config.Data.MaxPartNr);
+
+			if (firstDigitIsOK && (partNr / 10 == 0)) return true;
+			if (firstDigitIsOK && secondDigitIsOK && (partNr / 100 == 0)) return true;
+			if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && (partNr / 1000 == 0)) return true;
+			if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && fourthDigitIsOK && (partNr / 10000 == 0)) return true;
+
+			return false;
+		}
+
 		public override string ToString()
 		{
 			string partStr = (Part > 0) ? string.Format(", part {0}", Part) : string.Empty;
 
-			return string.Format("{0}(P.{1},{2}){3}", Name, ((Publish)Publish).ToString(), Evaluate ? "E" : "-", partStr);
+			return string.Format("{0}(P.{1},{2}){3}", Name, ((Publish)Publish).ToString(), DoEvaluate ? "E" : "-", partStr);
 		}
     }
 }

Config/Entities/TestResult.cs

@@ -1,176 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-
-namespace Config.Entities
-{
-    public class TestResult
-    {
-        public virtual int Id { get; protected set; }
-		public virtual string Name { get; set; }
-		public virtual int BatchNr { get; set; }
-		public virtual string PurchaseOrder { get; set; }
-		public virtual MetersKind MetersKind { get; set; }
-		public virtual IList<MeterTestResult> Meters { get; set; }
-		public virtual IList<MeterTestResult> CombinedMeters { get; set; }
-
-        /// Value copied from the procedure (Entities.Procedure)
-        public virtual string ProcedureName { get; set; }
-		public virtual string ProtocolTitle { get; set; }
-
-		/// Values copied from the test (Entities.Test)
-        public virtual int TestId { get; set; }				/// Test entity ID to distinguish between tests with the same name
-		public virtual string TestName { get; set; }
-		public virtual int Part { get; set; }
-		public virtual bool DoNotEvaluate { get; set; }		///        Not mapped to the database
-		public virtual bool DoNotPublish { get; set; }		///        Not mapped to the database
-		public virtual float Qfrom { get; set; }			/// [m3/h] Water flow low limit
-		public virtual float Qto { get; set; }				/// [m3/h] Water flow high limit
-		public virtual float Volume { get; set; }			/// [l]    Target test volume
-		public virtual float TstTime { get; set; }			/// [s]    Test time estimate
-		public virtual int Repeats { get; set; }
-		public virtual bool Emptying { get; set; }
-		public virtual bool Zeroing { get; set; }
-		public virtual float PumpPower { get; set; }		/// Power of the pump in [%] in the range 0 .. 100.0f, use values 0% and 100% for non-FM pumps
-		public virtual int Time2MassMsrmt { get; set; }
-		public virtual string Method { get; set; }
-		public virtual float ErrLimLo { get; set; }			/// [%]    Lower error limit (usually < 0)
-		public virtual float ErrLimHi { get; set; }			/// [%]    Upper error limit (usually > 0)
-		public virtual float Uncertainty { get; set; }		///	[%]    Makes error limits tighter: 0 <= Uncertainty <= abs(ErrLimXx)
-		
-		/// To be replaced by the virtual bench component parameters
-		public virtual string FeedingPath { get; set; }
-		public virtual string BenchPath { get; set; }
-		public virtual string OutputPath { get; set; }
-		public virtual string MetersPath { get; set; }
-
-		/// Results
-		public virtual DateTime TimeStart { get; set; }     ///         Date and time of the test start
-		public virtual DateTime TimeEnd { get; set; }       ///         Date and time of the test end
-		public virtual int RepetitionNr { get; set; }       ///         Repetition number from the set of repeated tests (1...)
-		public virtual float AmbientTempAve { get; set; }   /// [deg.C] Average ambient air temperature
-        public virtual float AmbientPressAve { get; set; }  ///         Average ambient air pressure
-		public virtual float AmbientHumiAve { get; set; }   /// [%]     Average ambient air relative humidity
-		public virtual float PressInAvrg { get; set; }      /// [Bar]   Input water pressure (average)
-		public virtual float PressInStart { get; set; }     /// [Bar]
-		public virtual float PressInEnd { get; set; }       /// [Bar]
-		public virtual float PressOutAvrg { get; set; }     /// [Bar]
-		public virtual float PressOutStart { get; set; }    /// [Bar]
-		public virtual float PressOutEnd { get; set; }      /// [Bar]
-		public virtual float TempInAvrg { get; set; }		/// [deg.C]
-		public virtual float TempInStart { get; set; }		/// [deg.C]
-		public virtual float TempInEnd { get; set; }		/// [deg.C]
-		public virtual float TempOutAvrg { get; set; }		/// [deg.C]
-		public virtual float TempOutStart { get; set; }		/// [deg.C]
-		public virtual float TempOutEnd { get; set; }		/// [deg.C]
-		public virtual float TempDivAvrg { get; set; }		/// [deg.C]
-		public virtual float TempDivStart { get; set; }		/// [deg.C]
-		public virtual float TempDivEnd { get; set; }		/// [deg.C]
-		public virtual float MassStartRaw { get; set; }		/// [kg]
-		public virtual float MassStart { get; set; }		/// [kg]
-		public virtual float MassEndRaw { get; set; }		/// [kg]
-		public virtual float MassEnd { get; set; }			/// [kg]
-		public virtual float MassDiff { get; set; }			/// [kg]
-		public virtual float DensityIn { get; set; }		/// [kg/m3]
-		public virtual float DensityOut { get; set; }		/// [kg/m3]
-		public virtual float DensityDiv { get; set; }		/// [kg/m3]
-		public virtual float Buoyancy { get; set; }												///TODO -> map
-		public virtual float FlowMass { get; set; }         /// [kg/h]  calculated from conventional true value
-		public virtual float FlowVolume { get; set; }       /// [l/h]   calculated from conventional true value
-        public virtual float VolumeCTV { get; set; }        /// [l]     Volume conventional true value
-        public virtual float VolumeMaster { get; set; }     /// [l]     Volume from the master flow meter
-        public virtual float Time { get; set; }             /// [s]     Measurement time in seconds
-        public virtual float ErrorMaster { get; set; }		/// [%]
-        public virtual float PulsesMaster { get; set; }
-        public virtual float ConstMaster { get; set; }      /// [pls/l] Pulses per liter master flow meter
-		public virtual float QRise { get; set; }			///         Detected Q_rise of a composed meter
-		public virtual float QFall { get; set; }			///         Detected Q_fall of a composed meter
-		public virtual float TimeDivStart0 { get; set; }
-        public virtual float TimeDivStart1 { get; set; }
-        public virtual float TimeDivStart2 { get; set; }
-        public virtual float TimeDivStart3 { get; set; }
-        public virtual float TimeDivStart4 { get; set; }
-        public virtual float TimeDivStart5 { get; set; }
-        public virtual float TimeDivEnd0 { get; set; }
-        public virtual float TimeDivEnd1 { get; set; }
-        public virtual float TimeDivEnd2 { get; set; }
-        public virtual float TimeDivEnd3 { get; set; }
-        public virtual float TimeDivEnd4 { get; set; }
-        public virtual float TimeDivEnd5 { get; set; }
-
-		public TestResult()
-		{
-			Meters = new List<MeterTestResult>();
-			CombinedMeters = new List<MeterTestResult>();
-		}
-        
-		public TestResult(MetersKind kind)
-			: this()
-        {
-			MetersKind = kind;
-
-			if (kind == MetersKind.Single)
-			{
-				for (int i = 0; i < Config.Data.WMsCount; i++) Meters.Add(new MeterTestResult(this));
-			}
-			else if (kind == MetersKind.Combined)
-			{
-				for (int i = 0; i < 2 * Config.Data.CompoundWMsCount; i++) Meters.Add(new MeterTestResult(this));
-				for (int i = 0; i < Config.Data.CompoundWMsCount; i++) CombinedMeters.Add(new MeterTestResult(this));
-			}
-            else if (kind == MetersKind.HeatMeter)
-            {
-                /// TODO: Verify if this is OK
-                for (int i = 0; i < Config.Data.WMsCount; i++) Meters.Add(new MeterTestResult(this));
-            }
-        }
-
-		public TestResult(Test test, int repetitionNr, MetersKind kind)
-			: this(kind)
-        {
-			if (test.Repeats == 1)
-			{
-                Name = test.Name;
-			}
-			else
-			{
-				Name = string.Format("{0} ({1}/{2})", test.Name, repetitionNr, test.Repeats);
-			}
-			RepetitionNr = repetitionNr;
-
-            /// Copy test parameters from Entities.Procedure object
-            ProcedureName = test.Procedure.Name;
-			ProtocolTitle = test.Procedure.ProtocolTitle;
-
-			/// Copy test parameters from Entities.Test object
-            TestId = test.Id;
-			TestName = test.Name;
-			Part = test.Part;
-			Qfrom = test.Qfrom;
-			Qto = test.Qto;
-			Volume = test.Volume;
-			TstTime = test.TstTime;
-			Repeats = test.Repeats;
-			Emptying = test.Draining;
-			Zeroing = test.Zeroing;
-			PumpPower = PumpPower;
-			Time2MassMsrmt = test.TimeStop2Mass;
-			Method = test.Method;
-			ErrLimLo = test.ErrLimLo;
-			ErrLimHi = test.ErrLimHi;
-			Uncertainty = test.Uncertainty;
-
-			FeedingPath = test.FeedingPath;
-			BenchPath = test.BenchPath;
-			OutputPath = test.OutputPath;
-			MetersPath = test.MetersPath;
-		}
-
-        public override string ToString()
-        {
-			return string.Format("batch={0}, procedure={1}, test={2}, {3} {4}", BatchNr, ProcedureName, TestName, TimeStart.ToShortDateString(), TimeStart.ToShortTimeString());
-        }
-    }
-}

Config/Entities/TransitionSequence.cs

@@ -1,19 +1,23 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
+using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
 
 namespace Config.Entities
 {
 	/// <summary>
 	/// Stores one transition sequence containing a list of transition steps
 	/// </summary>
-	public class TransitionSequence : IHasItemNr
+	public class TransitionSequence : IHasName, IHasItemNr
 	{
 		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; }			/// Short description
+        public virtual string OriName { get; set; }             /// Not mapped to database
+        public virtual string Description { get; set; }			/// Short description
 		public virtual IList<TransitionStep> TransitionSteps { get; set; }
 
 		public TransitionSequence()
@@ -36,5 +40,56 @@ namespace Config.Entities
 			foreach (var step in TransitionSteps) { result.TransitionSteps.Add(step.Clone()); }
             return result;
         }
-	}
+
+        public virtual void Export(StreamWriter output)
+        {
+            output.WriteLine(ItemNr.ToString(CultureInfo.InvariantCulture));
+            output.WriteLine(Name);
+            output.WriteLine(Description);
+
+            foreach (var step in TransitionSteps) { step.Export(output); }
+            output.WriteLine();
+
+            output.Close();
+        }
+
+        public static TransitionSequence Import(StreamReader input)
+        {
+            TransitionSequence result = new TransitionSequence();
+
+            result.ItemNr = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
+            result.Name = input.ReadLine();
+            result.Description = input.ReadLine();
+
+            while (true)
+            {
+                TransitionStep step = TransitionStep.Import(input, result);
+                if (step == null)
+                    break;
+                else
+                    result.TransitionSteps.Add(step);
+            }
+
+            return result;
+        }
+
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            const string fmt = "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+
+            ln = inp.ReadLine();            /// skip ItemNr
+            ln = inp.ReadLine(); if (ln != Name) { diff.AppendFormat(fmt, "Name", Name, ln); };
+            ln = inp.ReadLine(); if (ln != Description) { diff.AppendFormat(fmt, "Description", Description, ln); };
+
+            //foreach (var step in TransitionSteps)
+            //{
+            //    string testDiff = step.Compare(inp);
+            //    if (testDiff.Contains(
+            //}
+
+            return diff.ToString();
+        }
+    }
 }

Config/Entities/TransitionStep.cs

@@ -1,8 +1,10 @@
 ///
-/// Copyright (c) 2013-2015, 2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
 
 namespace Config.Entities
 {
@@ -61,5 +63,64 @@ namespace Config.Entities
             result += indent + "PumpsWithFMPct = " + PumpWithFMPcts + Environment.NewLine;
             return result;
 		}
+
+        public virtual void Export(StreamWriter output)
+        {
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            output.WriteLine(ItemNr.ToString(ci));
+            output.WriteLine(Duration.ToString(ci));
+            output.WriteLine(Message);
+            output.WriteLine(EndCondition);
+            output.WriteLine(ValvesOpen);
+            output.WriteLine(ValvesClose);
+            output.WriteLine(RegulValvesPct);
+            output.WriteLine(PumpWithFMPcts);
+        }
+
+        public static TransitionStep Import(StreamReader input, TransitionSequence newSequence)
+        {
+            string firstLine = input.ReadLine();
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                return null;
+            }
+
+            CultureInfo ci = CultureInfo.InvariantCulture;
+            int itemNr = int.Parse(firstLine, ci);
+            TransitionStep tst = new TransitionStep(itemNr, newSequence);
+
+            tst.Duration = int.Parse(input.ReadLine(), ci);
+            tst.Message = input.ReadLine();
+            tst.EndCondition = input.ReadLine();
+            tst.ValvesOpen = input.ReadLine();
+            tst.ValvesClose = input.ReadLine();
+            tst.RegulValvesPct = input.ReadLine();
+            tst.PumpWithFMPcts = input.ReadLine();
+
+            return tst;
+        }
+
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            string fmt = string.Format("Step {0} : ", ItemNr) + "{0} = {1}\r\n (in the file {2})\r\n";
+            string ln;
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            string firstLine = inp.ReadLine();
+            if (string.IsNullOrEmpty(firstLine)) return string.Format("TransitionStep {0} is missing in the compared file\r\n", ItemNr);
+
+            if (ItemNr.ToString() != firstLine) { diff.AppendFormat(fmt, "ItemNr", ItemNr, firstLine); };
+            ln = inp.ReadLine(); if (ln != Duration.ToString(ci)) { diff.AppendFormat(fmt, "Duration", Duration.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Message) { diff.AppendFormat(fmt, "Message", Message, ln); };
+            ln = inp.ReadLine(); if (ln != EndCondition) { diff.AppendFormat(fmt, "EndCondition", EndCondition, ln); };
+            ln = inp.ReadLine(); if (ln != ValvesOpen) { diff.AppendFormat(fmt, "ValvesOpen", ValvesOpen, ln); };
+            ln = inp.ReadLine(); if (ln != ValvesClose) { diff.AppendFormat(fmt, "ValvesClose", ValvesClose, ln); };
+            ln = inp.ReadLine(); if (ln != RegulValvesPct) { diff.AppendFormat(fmt, "RegulValvesPct", RegulValvesPct, ln); };
+            ln = inp.ReadLine(); if (ln != PumpWithFMPcts) { diff.AppendFormat(fmt, "PumpWithFMPcts", PumpWithFMPcts, ln); };
+
+            return diff.ToString();
+        }
 	}
 }

Config/Entities/Uncertainty.cs

@@ -0,0 +1,20 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+    public class Uncertainty
+    {
+        public virtual int Id { get; protected set; }
+        public virtual float Measurement { get; set; }
+        public virtual float MainUncertainty { get; set; }
+        public virtual float Resolution { get; set; }
+        public virtual float DriftPerYr { get; set; }
+        public virtual float Conditions { get; set; }
+        public virtual float UncertaintyOfCorrection { get; set; }
+
+        public Uncertainty() { }
+    }
+}

Config/Entities/User.cs

@@ -1,18 +1,22 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
 
 namespace Config.Entities
 {
-    public class User //: Users.IUser
+    public class User
     {
 		public virtual int Id { get; protected set; }
         public virtual string UserName { get; set; }	/// = name, alias, abbreviation
 		public virtual string FullName { get; set; }	/// = description
-		public virtual int Number { get; set; }
+        public virtual string Tag { get; set; }
+        public virtual int Number { get; set; }
 		public virtual string Password { get; set; }
+        public virtual string Password2 { get; set; }
+        public virtual string Password3 { get; set; }
+        public virtual string Password4 { get; set; }
         public virtual DateTime LastPwChange { get; set; }
         public virtual IList<Group> Groups { get; set; }   //User can be a member of a list of groups
 
@@ -20,5 +24,24 @@ namespace Config.Entities
         {
             Groups = new List<Group>();
         }
-    }
+
+		/// <summary>
+		/// Adds a group to the user.
+		/// </summary>
+		/// <param name="group">Group to be added</param>
+		public virtual void AddGroup(Group group)
+		{
+			Groups.Add(group);
+		}
+
+		/// <summary>
+		/// Encrypts and sets users password.
+		/// </summary>
+		/// <param name="password">Unencrypted password</param>
+		public virtual void SetPassword(string password)
+		{
+			Password = Users.Entities.User.getHash(password);
+			LastPwChange = DateTime.Now;
+		}
+	}
 }

Config/Entities/VirtualBenchSequence.cs

@@ -1,17 +1,19 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.IO;
 
 namespace Config.Entities
 {
-    public class VirtualBenchSequence : IHasItemNr
+	public class VirtualBenchSequence : IHasName, IHasItemNr
     {
 		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; }			/// Short description
+        public virtual string OriName { get; set; }             /// Not mapped to database
+        public virtual string Description { get; set; }			/// Short description
         public virtual IList<VirtualBenchStep> VirtualBenchSteps { get; set; }
 
 		public VirtualBenchSequence()
@@ -34,5 +36,24 @@ namespace Config.Entities
             foreach (var step in VirtualBenchSteps) { result.VirtualBenchSteps.Add(step.Clone()); }
             return result;
         }
+
+        public virtual void Export(StreamWriter output)
+        {
+            /// TODO
+        }
+
+        public static VirtualBenchSequence Import(StreamReader input)
+        {
+            VirtualBenchSequence result = new VirtualBenchSequence();
+            /// TODO
+            return result;
+        }
+
+        public virtual string Compare(StreamReader inp)
+        {
+            System.Text.StringBuilder diff = new System.Text.StringBuilder();
+            /// TODO
+            return diff.ToString();
+        }
     }
 }

Config/Entities/WMType.cs

@@ -1,78 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-/// This class holds the watermeter type specific data 
-/// that have all watermaters of the same type in common
-
-namespace Config.Entities
-{
-    public class WMType
-    {
-        // mapped
-        public virtual int Id { get; protected set; }           /// primary key
-        public virtual DateTime CreateTime { get; set; }        /// Date and time of the creation or change
-        public virtual string CreateUserName { get; set; }      /// Name of the user who has created or changed this procedure
-        public virtual string CreateDescription { get; set; }   /// Description\
-         
-        public virtual string Name { get; set; }                /// type name
-        public virtual float PulseRate { get; set; }            /// Pulses per Liter
-
-        // not yet mapped
-        public virtual int IdentNr { get; protected set; }      /// identification number of watermeter tzpe
-        public virtual int Diameter { get; set; }               /// nominal diameter
-        public virtual int Pressure { get; set; }               /// nominal pressure
-        public virtual int Length { get; set; }                 /// construction length
-        public virtual int Temperatur { get; set; }             /// nominal temperature in C
-        public virtual float NominalFlow { get; set; }          /// nominal flow Qn
-       
-        /// ------------- Additional stuff not mapped into the database -------------
-
-        public WMType()
-        {
-        }
-
-        public static WMType DefaultWMType()
-        {
-            WMType procedure = new WMType()
-            {
-                CreateTime = DateTime.Now,
-				CreateUserName = Users.GlobalData.CurrentUser.UserName,
-                CreateDescription = "A default water meter created.",
-                Name = "Watermeter",
-                PulseRate = 1000,
-            };
-            return procedure;
-        }
-
-        public virtual WMType Clone()
-        {
-            WMType result = new WMType();
-
-            result.CreateTime = CreateTime;
-            result.CreateUserName = CreateUserName;
-            result.CreateDescription = CreateDescription;
-            result.Name = Name;
-            result.PulseRate = PulseRate;
-
-            return result;
-        }
-
-        public override string ToString()
-        {
-            string result = "";
-            result += "WMTpe: " + Environment.NewLine;
-            result += "    Name        = " + Name + Environment.NewLine;
-            result += "    Created by  = " + CreateUserName + Environment.NewLine;
-            result += "    Created on  = " + CreateTime.ToString() + Environment.NewLine;
-            result += "    Description = " + CreateDescription + Environment.NewLine;
-            result += "    Pulse rate  = " + PulseRate.ToString() + Environment.NewLine;
-            return result;
-        }
-    }
-}
-

Config/Entities/Watermeter.cs

@@ -1,40 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-using NHibernate;
-using FluentNHibernate;
-
-namespace Config.Entities
-{
-    public class Watermeter
-    {
-        public virtual int Id { get; protected set; }           /// primary key
-
-        public virtual DateTime CreateTime { get; set; }        /// Date and time of the creation or change
-        public virtual string CreateUserName { get; set; }      /// Name of the user who has created or changed this procedure
-        public virtual string CreateDescription { get; set; }   /// Description
-
-        /// mapped
-        public virtual string Serial { get; set; }              /// serial number 
-        public virtual WMType WMType { get; set; }              /// type of watermeter                                              
-                                                                /// 
-
-		/// <summary>
-		/// Load a watermeter from the database
-		/// </summary>
-		public static Watermeter LoadBySerialnr(string SerialNr)
-        {
-            IList<Watermeter> ListOfWatermeters = FluentCommon.CreateSession(Users.Entities.DBKind.Results)
-				.CreateQuery("FROM Watermeter WHERE Serial = :SerialNrParameter")
-				.SetParameter("SerialNrParameter", SerialNr)
-				.List<Watermeter>();
-            if (ListOfWatermeters.Count > 0) return ListOfWatermeters.ElementAt(0);
-            return null;
-        }
-    }
-}

Config/FluentCommon.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Windows.Forms;
@@ -39,7 +39,11 @@ namespace Config
 					dbType = Data.CurrentBench.WaterMetersDBSettings.DbType;
 					connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
                     break;
-			}
+                case Users.Entities.DBKind.RemoteConfig:
+                    dbType = Data.CurrentBench.UsersDBSettings.DbType;
+                    connectionString = Data.CurrentBench.UsersDBSettings.ConnectionString;
+                    break;
+            }
 
             return CreateSessionFactory(database, dbType, connectionString, false);
 		}
@@ -69,6 +73,7 @@ namespace Config
                 {
                     default:
 					case Users.Entities.DBKind.Config:
+                    case Users.Entities.DBKind.RemoteConfig:
                         cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
                         break;
                     case Users.Entities.DBKind.Results:
@@ -114,43 +119,14 @@ namespace Config
 		/// Create a NHibernate session for the given database
 		public static ISession CreateSession(Users.Entities.DBKind database)
 		{
-			int ix = (int)database;
-			if (ix < 0 || ix >= (int)Users.Entities.DBKind.Count) return null;
+            if (database < 0 || database >= Users.Entities.DBKind.Count) return null;
 
-			if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
+            int ix = (int)database;
+            if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
 
 			return SessionFactories[ix].OpenSession();
 		}
 
-		public static void SaveToDb(Users.Entities.DBKind database, object obj)
-		{
-			SaveToDb(CreateSession(database), obj);
-		}
-
-		public static void SaveToDb(ISession session, object obj)
-		{
-            using (var transaction = session.BeginTransaction())
-            {
-                session.SaveOrUpdate(obj);
-                try { transaction.Commit(); }
-                catch { }
-            }
-        }
-
-		public static void DeleteFromDb(Users.Entities.DBKind database, object obj)
-		{
-			DeleteFromDb(CreateSession(database), obj);
-		}
-
-		public static void DeleteFromDb(ISession session, object obj)
-        {
-            using (var transaction = session.BeginTransaction())
-            {
-                session.Delete(obj);
-                transaction.Commit();
-            }
-        }
-
         /// <summary>
         /// Create an empty users database.
 		/// Database contains only the user 'admin' and the control board component 'CB'.
@@ -169,68 +145,49 @@ namespace Config
                 using (var transaction = session.BeginTransaction())
                 {
                     ///
-                    /// Prepare all groups
+					/// Create user 'admin'
                     ///
-					var testers					= new Users.Entities.Group((int)Users.Grp.GID.Testers, Strings.Tester);
-					var testingSpecialists		= new Users.Entities.Group((int)Users.Grp.GID.TestingSpecialists, Strings.Testing_Specialist);
-					var headOfLab				= new Users.Entities.Group((int)Users.Grp.GID.HeadOfLab, Strings.Head_of_Lab);
-					var maintenanceSpecialists	= new Users.Entities.Group((int)Users.Grp.GID.MaintenanceSpecialists, Strings.Maintenance_Specialist);
-					var metrologists			= new Users.Entities.Group((int)Users.Grp.GID.Metrologists, Strings.Metrologist);
-					var calibrationSpecialists	= new Users.Entities.Group((int)Users.Grp.GID.CalibrationSpecialists, Strings.Calibration_Specialist);
-					var administrators			= new Users.Entities.Group((int)Users.Grp.GID.Administrators, Strings.Administrator);
-
-					/// Create the user 'admin' add his groups
-                    var admin = new Users.Entities.User
+                    var admin = new Config.Entities.User
                     {
 						UserName = Data.AdminUsername,
                         FullName = Strings.Administrator,
                         LastPwChange = DateTime.Now
                     };
 					admin.SetPassword(Data.AdminPassword);
-                    admin.AddGroup(testers);
-                    admin.AddGroup(testingSpecialists);
-                    admin.AddGroup(headOfLab);
-                    admin.AddGroup(maintenanceSpecialists);
-                    admin.AddGroup(metrologists);
-                    admin.AddGroup(calibrationSpecialists);
-                    admin.AddGroup(administrators);
 
-                    session.SaveOrUpdate(admin);
-
-					///// Create the control board component
-					//var cmpnt = (new BenchControl.Elde.ControlBoardCfg(new BenchControl.Elde.ControlBoardFactory())).CreateDbEntity();
-					//session.SaveOrUpdate(cmpnt);
+                    ///
+                    /// Prepare all groups, add some of them to admin
+                    ///
+                    for (Users.Entities.GID gid = 0; gid < Users.Entities.GID.NrOfGroups; gid++)
+                    {
+                        Config.Entities.Group group = new Config.Entities.Group(gid);
+                        switch (gid)
+                        {
+                            case Users.Entities.GID.Testers:
+                            case Users.Entities.GID.TestingSpecialists:
+                            case Users.Entities.GID.HeadOfLab:
+                            case Users.Entities.GID.MaintenanceSpecialists:
+                            case Users.Entities.GID.Metrologists:
+                            case Users.Entities.GID.CalibrationSpecialists:
+                            case Users.Entities.GID.Administrators:
+#if TURA_IPERL || TURA_IPERL_NEW || TURA_SPECIAL
+                            case Users.Entities.GID.TraceabilityManagement:
+#elif KEMPNO_50 || KRAKOW_50 || TORUN_50 || WARSAW_END
+                            case Users.Entities.GID.MetrologicalAuthority:
+                            case Users.Entities.GID.WaterMeterAuthority:
+#endif
+                                admin.AddGroup(group);
+                                session.SaveOrUpdate(group);    /// Save this group
+                                break;
+                        }
+                    }
 
+                    session.SaveOrUpdate(admin);                /// Save user 'admin'
                     transaction.Commit();
                 }
             }
 
             return true;
         }
-
-        /// <summary>
-        /// Create an empty water meters database
-        /// </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 CreateEmptyResultsDB(Users.Entities.DBType dbType, string connectionString)
-        {
-			ISessionFactory sessionFactory = CreateSessionFactory(Users.Entities.DBKind.Results, dbType, connectionString, true);
-            if (sessionFactory == null) return false;
-
-            /// Populate the database
-            //using (var session = sessionFactory.OpenSession())
-            //{
-            //    using (var transaction = session.BeginTransaction())
-            //    {
-            //        /// Create one component
-            //        var cmpnt = (new BenchControl.Elde.ControlBoardCfg("CB", 1)).CreateDbEntity();
-            //        session.SaveOrUpdate(cmpnt);
-            //        transaction.Commit();
-            //    }
-            //}
-            return true;
-        }
     }
 }

Config/Formulas.cs

@@ -1,24 +1,33 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
 using log4net;
 
-namespace TBF.BenchControl
+namespace Config
 {
     public static class Formulas
     {
 		private static readonly ILog log = LogManager.GetLogger(typeof(Formulas));
 
-        ///
-        /// Tables to calculate specific enthalpy
-        ///
-        private static readonly int[] Ii;
-        private static readonly int[] Ji;
-        private static readonly double[] ni;
 
-		private static readonly double[] Di;
+        ///
+        /// Wrappers
+        ///
+        public static double RealDensity() { return Data.RealDensity; }
+        public static double AtTemperature() { return Data.AtTemperature; }
+        public static double Buoyancy() { return Data.Buoyancy; }
+
+
+        /// Private tables with coeficients to calculate specific enthalpy
+        static readonly int[] Ii;
+        static readonly int[] Ji;
+        static readonly double[] ni;
+
+        /// Private table with coeficients to calculate temperature of a platinum thermometer
+        static readonly double[] Di;
+
 
         /// <summary> 
 		/// Constructor
@@ -83,19 +92,50 @@ namespace TBF.BenchControl
 				 0.191203,
 				 0.049025,
 			};
+        }
 
+        /// <summary>
+        /// Calculate density of distilled water from temperature
+        /// </summary>
+        /// <param name="t">ITS-90 temperature in [°C]</param>
+        /// <returns>Density in [kg/m3]</returns>
+        public static double DistilledWaterDensityFromTemp(double t)
+        {
+            if (t <= 40)
+            {
+                const double c0 = 999.839564;
+                const double c1 = 0.067998613;
+                const double c2 = -0.0091101468;
+                const double c3 = 0.00010058299;
+                const double c4 = -0.0000011275659;
+                const double c5 = 6.5985371e-09;
+
+                return ((((c5 * t + c4) * t + c3) * t + c2) * t + c1) * t + c0;
+            }
+            else
+            {
+                const double a0 = 9.9983952E2;
+                const double a1 = 1.6952577E1;
+                const double a2 = -7.9905127E-3;
+                const double a3 = -4.6241757E-5;
+                const double a4 = 1.0584601E-7;
+                const double a5 = -2.8103006E-10;
+                const double b = 1.6887236E-2;
+
+                return (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t + a0) / (1.0 + b * t);
+            }
         }
 
 		/// <summary>
-		/// Calculate density of distilled water from temperature
+		/// Calculate density of distilled water from temperature (obsolete)
 		/// </summary>
-		/// <param name="t">Temperature in [degC]</param>
+		/// <param name="t">IPTS-68 temperature in [°C]</param>
 		/// <returns>Density in [kg/m3]</returns>
-        public static double DistilledWaterDensityFromTemp(double t)
+        public static double DistilledWaterDensityFromTempIPTS68(double t)
         {
             const double a0 = 999.842594;
             const double a1 = 0.06793952;
-            const double a2 = -0.00909529;
+            const double a2 = -0.009095290;
             const double a3 = 0.0001001685;
             const double a4 = -0.000001120083;
             const double a5 = 6.536332e-09;
@@ -103,21 +143,48 @@ namespace TBF.BenchControl
             return ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t + a0;
         }
 
+		/// <summary>
+		/// Calculate density by comparing calculated data and data from a certificate
+		/// </summary>
+		/// <param name="realDensity">Density from a certificate in [kg/m3]</param>
+		/// <param name="atTemperature">Temperature from a certificate in [°C]</param>
+		/// <returns>Density correction in [kg/m3]</returns>
+		public static double DensityCorrection(double realDensity, double atTemperature)
+		{
+			/// Calculated data
+			double calculatedDensity = DistilledWaterDensityFromTemp(atTemperature);
+
+			return realDensity - calculatedDensity;
+		}
+
 		/// <summary>
 		/// Calculate corrected (real) water density from temperature
 		/// </summary>
-		/// <param name="t">Temperature in [degC]</param>
+		/// <param name="t">Temperature in [°C]</param>
 		/// <returns>Density in [kg/m3]</returns>
 		public static double WaterDensityFromTemp(double t)
 		{
-			double realDensity = Program.LocalSettings.RealDensity;
-			double atTemperature = Program.LocalSettings.AtTemperature;
-
-			double c_rho = realDensity / DistilledWaterDensityFromTemp(atTemperature);
-
-			return c_rho * DistilledWaterDensityFromTemp(t);
+            return DistilledWaterDensityFromTemp(t) + DensityCorrection(RealDensity(), AtTemperature());
 		}
 
+        /// <summary>
+        /// Calculate corrected (real) water density from temperature
+        /// </summary>
+        /// <param name="t">Temperature in [°C]</param>
+        /// <returns>Density in [kg/m3]</returns>
+        public static double WaterDensityFromTempPress(double temp, double pressure)
+        {
+            double x0 = 5.08821E-10;
+            double x1 = 1.2639418;
+            double x2 = 0.2660269;
+            double x3 = 0.3734838;
+            double x4 = 2.0205242;
+            double theta = temp / 100.0;
+            double B = x0 * (((x3 * theta + x2) * theta + x1) * theta + 1) / (1 + x4 * theta);
+
+            return WaterDensityFromTemp(temp) * (1 + B * Config.Units.ConvertTo(Config.Unit.Pa, pressure));
+        }
+
 
 		public static float AirDensityFromAmbientVales(float tempC, float pressureBar, float humiPct)
 		{
@@ -150,65 +217,95 @@ namespace TBF.BenchControl
 			{
 				if (measuredVolume <= float.Epsilon)
 				{
-					log.WarnFormat("ErrorFromVolumes({0},{1}) returns {2}", measuredVolume, trueVolume, 99.0);
-					return 99.0;
+					log.WarnFormat("ErrorFromVolumes({0},{1}) returns {2}", measuredVolume, trueVolume, -100.0);
+					return -100.0;
 				}
 
 				log.WarnFormat("ErrorFromVolumes({0},{1}) returns {2}", measuredVolume, trueVolume, 99.0);
 				return 99.0;
 			}
+
 			double error = 100.0 * (measuredVolume - trueVolume) / trueVolume;
 			log.InfoFormat("ErrorFromVolumes({0},{1}) returns {2}", measuredVolume, trueVolume, error);
 			return error;
 		}
 
-		/// <summary>
-		/// Calculates corrected value form a list of corrections by interpolation.
-		/// It is assumed that values in the list 'corrections' are sorted.
-		/// </summary>
-		/// <param name="rawMeasurement">Raw uncorrected value</param>
-		/// <param name="corrections">Sorted (value, correction) pairs</param>
-		/// <returns>Corrected value</returns>
-		public static double CorrectedValue(double rawValue, IList<Config.Entities.MeasurementCorrection> corrections)
-		{
-			if (corrections == null || corrections.Count == 0) return rawValue;
 
-			if (rawValue < corrections[0].Measurement)
-			{
-				return rawValue + corrections[0].Correction;
-			}
+        /// <summary>
+        /// Calculates corrected value from a list of corrections by interpolation.
+        /// It is assumed that values in the list 'corrections' are sorted.
+        /// </summary>
+        /// <param name="rawMeasurement">Raw uncorrected value</param>
+        /// <param name="corrections">Sorted (value, correction) pairs</param>
+        /// <returns>Corrected value</returns>
+        public static double CorrectedValue(double rawValue, IList<Config.Entities.MeasurementCorrection> corrections)
+        {
+            return rawValue + GetCorrection(rawValue, corrections);
+        }
 
-			int count = corrections.Count;
-			for (int i = 1; i < count; i++)
-			{
-				if (rawValue < corrections[i].Measurement)
-				{
-					double d1 = rawValue - corrections[i-1].Measurement;
-					double d2 = corrections[i].Measurement - rawValue;
+        /// <summary>
+        /// Get a correction from a list of corrections by interpolation.
+        /// It is assumed that values in the list 'corrections' are sorted.
+        /// </summary>
+        /// <param name="rawMeasurement">Raw uncorrected value</param>
+        /// <param name="corrections">Sorted (value, correction) pairs</param>
+        /// <returns>Corrected value</returns>
+        public static double GetCorrection(double rawValue, IList<Config.Entities.MeasurementCorrection> corrections)
+        {
+            if ((corrections == null) || (corrections.Count == 0)) return 0;    /// No correction
 
-					double corr;
-					if (d1 + d2 <= float.Epsilon)
-					{
-						corr = (corrections[i - 1].Correction + corrections[i].Correction) / 2.0;
-					}
-					else
-					{
-						corr = (corrections[i - 1].Correction * d2 + corrections[i].Correction * d1) / (d1 + d2);
-					}
-					return rawValue + corr;
-				}
-			}
+            if (rawValue < corrections[0].Measurement)
+            {
+                /// rawValue is below the lowest value in the correction table
+                return corrections[0].Correction;
+            }
 
-			return rawValue + corrections[count - 1].Correction;
-		}
+            int count = corrections.Count;
+            for (int i = 1; i < count; i++)
+            {
+                if (rawValue < corrections[i].Measurement)
+                {
+                    double d1 = rawValue - corrections[i - 1].Measurement;
+                    double d2 = corrections[i].Measurement - rawValue;
+
+                    if (d1 + d2 <= float.Epsilon)
+                    {
+                        /// Neigboring values in the corection table are close to each other -> calculate the average
+                        return (corrections[i - 1].Correction + corrections[i].Correction) / 2.0;
+                    }
+                    else
+                    {
+                        /// Interpolate the correction from neigboring values in the corection table
+                        return (corrections[i - 1].Correction * d2 + corrections[i].Correction * d1) / (d1 + d2);
+                    }
+                }
+            }
+
+            /// rawValue is above the highest value in the correction table
+            return corrections[count - 1].Correction;
+        }
+
+
+        /// <summary>
+        /// Converts a measurement error to a correction (used when preparing correction tables).
+        /// </summary>
+        /// <param name="measuredValue">Measured value (in arbitrary units)</param>
+        /// <param name="error">Measurement error in %</param>
+        /// <returns>Correction in the same units as the measured value</returns>
+        public static double CorrectionFromError(double measuredValue, double error)
+        {
+            double trueValue = measuredValue / (1 + error/100);
+            double correction = trueValue - measuredValue;
+            return correction;
+        }
 
 
         /// <summary>
         /// Calculates the heat coefficient for water
         /// </summary>
         /// <param name="pressure">Pressure [bar]</param>
-        /// <param name="T_in">Inlet temperature [C]</param>
-        /// <param name="T_out">Outlet temperature [C]</param>
+		/// <param name="T_in">Inlet temperature [°C]</param>
+		/// <param name="T_out">Outlet temperature [°C]</param>
         /// <param name="flowMeasuredAtInlet">true = flow measured @inlet, false = flow measured @outlet</param>
         /// <returns> Heat coefficient for water [J/(m3 K)]</returns>
         public static double HeatCoefficientWater(double pressure, double T_in, double T_out, bool flowMeasuredAtInlet)

Config/Mappings/ComponentMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -23,6 +23,9 @@ namespace Config.Mappings
 			HasMany(x => x.Corrections)
 				.OrderBy("Measurement")
 				.Cascade.All();
-		}
+            HasMany(x => x.Uncertainties)
+                .OrderBy("Measurement")
+                .Cascade.All();
+        }
     }
 }

Config/Mappings/CustomEventMap.cs

@@ -0,0 +1,30 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+    class CustomEventMap : ClassMap<CustomEvent>
+    {
+        public CustomEventMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.Date);
+            Map(x => x.Frequency);
+            Map(x => x.AllDay);
+            Map(x => x.TriggerOnExactDayOnly);
+            Map(x => x.Source);
+            Map(x => x.Title);
+            Map(x => x.AutoAction);
+            Map(x => x.Parameters);
+            Map(x => x.Rank);
+            Map(x => x.Hidden);
+            Map(x => x.ReadOnly);
+            Map(x => x.BackColor);
+            Map(x => x.TextColor);
+            Map(x => x.TooltipEnabled);
+        }
+    }
+}

Config/Mappings/GroupMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 
@@ -7,11 +7,18 @@ namespace Config.Mappings
 {
     class GroupMap : ClassMap<Entities.Group>
     {
+        /// <seealso>
+        ///  https://stackoverflow.com/questions/9108083/fluent-nhibernate-many-to-many-mapping-way/9125059
+        /// </seealso>
         public GroupMap()
         {
             Id(x => x.Id);
-            Map(x => x.Gid);
-            Map(x => x.Name);
+            Map(x => x.GID).Column("Name");
+            Map(x => x.AccessFlags);
+            HasManyToMany(x => x.Users)
+                .Cascade.SaveUpdate()
+                .Inverse()
+                .Table("UsersGroups");
         }
     }
 }

Config/Mappings/MeasurementCorrectionMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -11,6 +11,7 @@ namespace Config.Mappings
 		public MeasurementCorrectionMap()
 		{
 			Id(x => x.Id);
+            Map(x => x.RangeIx);
 			Map(x => x.Measurement);
 			Map(x => x.Correction);
 		}

Config/Mappings/MeterTestResultMap.cs

@@ -1,29 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class MeterTestResultMap : ClassMap<MeterTestResult>
-    {
-        public MeterTestResultMap()
-        {
-            Id(x => x.Id);
-            References(x => x.TestResult);
-			Map(x => x.Disabled);
-			Map(x => x.SerialNr);
-            Map(x => x.EndState);
-            Map(x => x.VolumeStart);
-            Map(x => x.VolumeEnd);
-            Map(x => x.VolumeMeter);
-            Map(x => x.VolumeRef);
-            Map(x => x.VolumeErrorPct);
-            Map(x => x.PulsesMeter);
-            Map(x => x.PulsesPerLiter);
-            Map(x => x.PulsesMaster);
-            Map(x => x.Time);
-        }
-    }
-}

Config/Mappings/PTestMap.cs

@@ -0,0 +1,60 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+    class PTestMap : ClassMap<PTest>
+    {
+        public PTestMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.ItemNr);
+			Map(x => x.Name);
+            Map(x => x.Part);
+            Map(x => x.CoefQfrom);
+			Map(x => x.CoefQto);
+            Map(x => x.ErrLimLo);
+            Map(x => x.ErrLimHi);
+            Map(x => x.TempLimLo);
+			Map(x => x.TempLimHi);
+            Map(x => x.PressLimLo);
+            Map(x => x.PressLimHi);
+            Map(x => x.Publish);
+            Map(x => x.Evaluate);
+            Map(x => x.E1);
+            Map(x => x.E2);
+            Map(x => x.E3);
+            Map(x => x.E4);
+            Map(x => x.E5);
+            Map(x => x.E6);
+            Map(x => x.E7);
+            Map(x => x.E8);
+            Map(x => x.E9);
+            Map(x => x.E10);
+            Map(x => x.E11);
+            Map(x => x.E12);
+            Map(x => x.E13);
+            Map(x => x.E14);
+            Map(x => x.E15);
+            Map(x => x.E16);
+            Map(x => x.E21);
+            Map(x => x.Delta_Q_pct);
+            Map(x => x.Delta_T);
+            Map(x => x.Delta_Tup_Tdn);
+            Map(x => x.TestTime_min);
+            Map(x => x.TestTime_max);
+            Map(x => x.AmbTemp_min);
+            Map(x => x.AmbTemp_max);
+            Map(x => x.Coef_E9);
+            Map(x => x.Coef_E10);
+            Map(x => x.Coef_E11);
+            Map(x => x.Coef_E12);
+            Map(x => x.Offset_E9);
+            Map(x => x.Offset_E12);
+			References(x => x.Profile);
+		}
+    }
+}

Config/Mappings/ProcedureMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -28,12 +28,20 @@ namespace Config.Mappings
 
 			Map(x => x.MetersKind);
 			Map(x => x.Watermeters);
-			Map(x => x.ProtocolTitle);
-			Map(x => x.DataEntry);
+            Map(x => x.Protected);
+            Map(x => x.MustBeComplete);
+			Map(x => x.ManualCtrlDisabled);
+
+            Map(x => x.DataEntry);
 			Map(x => x.ResultsPrinter);
 			Map(x => x.ResultsWriter);
+            Map(x => x.EventTriggers);
 			Map(x => x.TransitionStart);
 			Map(x => x.TransitionEnd);
+
+            Map(x => x.AltProcName);
+            Map(x => x.AltProcPeriod);
+
 			////Map(x => x.MetrologicalClass);
 			////HasOne(x => x.WMType);
 			HasMany(x => x.MoreParams)

Config/Mappings/ProfileMap.cs

@@ -0,0 +1,28 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+	class ProfileMap : ClassMap<Profile>
+    {
+        public ProfileMap()
+        {   
+            Id(x => x.Id);
+			Map(x => x.ItemNr);
+			Map(x => x.Name);
+            Map(x => x.Description);
+			Map(x => x.CreationUser);
+			Map(x => x.CreationTime);
+			Map(x => x.LastChgUser);
+			Map(x => x.LastChgTime);
+            Map(x => x.ProfileType);
+            Map(x => x.ErrorLimitType);
+            HasMany(x => x.Tests)
+				.OrderBy("ItemNr")
+				.Cascade.All();
+        }
+    }
+}

Config/Mappings/TestMap.cs

@@ -1,6 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-/// Author: Milan Hanajik
+/// Copyright (c) 2013-2017 Sensus Metering Systems
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -15,16 +14,23 @@ namespace Config.Mappings
             Map(x => x.ItemNr);
 			Map(x => x.Name);
 			Map(x => x.Part);
-			Map(x => x.Publish);
-			Map(x => x.Evaluate);
-			Map(x => x.Qfrom);
+            Map(x => x.Profile);
+            Map(x => x.Publish);
+			Map(x => x.DoEvaluate)
+				.Column("Evaluate");
+            Map(x => x.Qtg);
+            Map(x => x.Qfrom);
 			Map(x => x.Qto);
 			Map(x => x.Volume);
 			Map(x => x.TstTime);
 			Map(x => x.Repeats);
-            Map(x => x.Draining)
+            Map(x => x.DoDraining)
 				.Column("Emptying");
-            Map(x => x.Zeroing);
+            Map(x => x.DoDrainingAfter)
+				.Column("Zeroing");
+            Map(x => x.DoControlWaterTemp);
+            Map(x => x.TempLimLo);
+			Map(x => x.TempLimHi);
 			Map(x => x.PumpPower);
             Map(x => x.MassRepeats);
             Map(x => x.MassSpread);
@@ -41,7 +47,7 @@ namespace Config.Mappings
 			Map(x => x.Uncertainty);
 			Map(x => x.TolerRed)
                 .Column("TolerRed");	/// ???
-			Map(x => x.RedType);	    /// ???
+			Map(x => x.RedType);
 			Map(x => x.FeedingPath);
 			Map(x => x.BenchPath);
 			Map(x => x.OutputPath);
@@ -49,11 +55,14 @@ namespace Config.Mappings
 #if HEAT_METERS
             Map(x => x.HeatMetersPath);
 #endif
-            Map(x => x.RelTransBefore);
-			Map(x => x.RelTransBetween);
-			Map(x => x.RelTransAfter);
-			Map(x => x.TransitionAfter);
-			HasMany(x => x.MoreParams)
+            Map(x => x.RelTransBefore)
+                .Column("RelTransBefore");
+			Map(x => x.RelTransBetween)
+                .Column("RelTransBetween");
+			Map(x => x.TransitionAfter)
+                .Column("TransitionAfter");
+
+            HasMany(x => x.MoreParams)
 				.Cascade.All();
 			References(x => x.Procedure);
 		}

Config/Mappings/TestResultMap.cs

@@ -1,109 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class TestResultMap : ClassMap<TestResult>
-    {
-        public TestResultMap()
-        {
-            Id(x => x.Id);
-			Map(x => x.Name);
-			Map(x => x.BatchNr);
-			Map(x => x.PurchaseOrder);
-			Map(x => x.MetersKind);
-            HasMany(x => x.Meters)
-                .Cascade.All();
-			HasMany(x => x.CombinedMeters)
-				.Cascade.All();
-
-            Map(x => x.ProcedureName);
-			Map(x => x.ProtocolTitle);
-
-            Map(x => x.TestId);
-            Map(x => x.TestName);
-			Map(x => x.Part);
-			Map(x => x.Qfrom);
-			Map(x => x.Qto);
-			Map(x => x.Volume);
-			Map(x => x.TstTime);
-			Map(x => x.Repeats);
-			Map(x => x.Emptying);
-			Map(x => x.Zeroing);
-			Map(x => x.PumpPower);
-			Map(x => x.Time2MassMsrmt);
-            Map(x => x.Method);
-			Map(x => x.ErrLimLo);
-			Map(x => x.ErrLimHi);
-			Map(x => x.Uncertainty);
-
-			Map(x => x.FeedingPath)
-                .CustomType("StringClob")
-                .CustomSqlType("varchar(4000)");
-			Map(x => x.BenchPath)
-                .CustomType("StringClob")
-                .CustomSqlType("varchar(4000)");
-			Map(x => x.OutputPath)
-                .CustomType("StringClob")
-                .CustomSqlType("varchar(4000)");
-			Map(x => x.MetersPath)
-                .CustomType("StringClob")
-                .CustomSqlType("varchar(4000)");
-
-            Map(x => x.TimeStart);
-            Map(x => x.TimeEnd);
-		    Map(x => x.RepetitionNr);
-			Map(x => x.AmbientTempAve);
-            Map(x => x.AmbientPressAve);
-            Map(x => x.AmbientHumiAve);
-            Map(x => x.PressInAvrg);
-            Map(x => x.PressInStart);
-		    Map(x => x.PressInEnd);
-            Map(x => x.PressOutAvrg);
-            Map(x => x.PressOutStart);
-		    Map(x => x.PressOutEnd);
-            Map(x => x.TempInAvrg);
-		    Map(x => x.TempInStart);
-		    Map(x => x.TempInEnd);
-		    Map(x => x.TempOutAvrg);
-		    Map(x => x.TempOutStart);
-		    Map(x => x.TempOutEnd);
-		    Map(x => x.TempDivAvrg);
-		    Map(x => x.TempDivStart);
-		    Map(x => x.TempDivEnd);
-            Map(x => x.MassStartRaw);
-            Map(x => x.MassStart);
-            Map(x => x.MassEndRaw);
-            Map(x => x.MassEnd);
-            Map(x => x.MassDiff);
-            Map(x => x.DensityIn);
-            Map(x => x.DensityOut);
-            Map(x => x.DensityDiv);
-            Map(x => x.FlowMass);         /// from conventional true value
-            Map(x => x.FlowVolume);       /// from conventional true value
-            Map(x => x.VolumeCTV);        /// volume conventional true value
-            Map(x => x.VolumeMaster);     /// volume from the master flow meter
-            Map(x => x.Time);             /// measurement time in seconds
-            Map(x => x.ErrorMaster);
-            Map(x => x.PulsesMaster);
-            Map(x => x.ConstMaster);      /// Pulses per liter master flow meter
-			Map(x => x.QRise);
-			Map(x => x.QFall);
-            Map(x => x.TimeDivStart0);
-            Map(x => x.TimeDivStart1);
-            Map(x => x.TimeDivStart2);
-            Map(x => x.TimeDivStart3);
-            Map(x => x.TimeDivStart4);
-            Map(x => x.TimeDivStart5);
-            Map(x => x.TimeDivEnd0);
-            Map(x => x.TimeDivEnd1);
-            Map(x => x.TimeDivEnd2);
-            Map(x => x.TimeDivEnd3);
-            Map(x => x.TimeDivEnd4);
-            Map(x => x.TimeDivEnd5);
-        }
-    }
-}

Config/Mappings/UncertaintyMap.cs

@@ -0,0 +1,22 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+    class UncertaintyMap : ClassMap<Uncertainty>
+    {
+        public UncertaintyMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.Measurement);
+            Map(x => x.MainUncertainty);
+            Map(x => x.Resolution);
+            Map(x => x.DriftPerYr);
+            Map(x => x.Conditions);
+            Map(x => x.UncertaintyOfCorrection);
+        }
+    }
+}

Config/Mappings/UserMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2016-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 
@@ -12,11 +12,16 @@ namespace Config.Mappings
             Id(x => x.Id);
             Map(x => x.UserName).Column("Name");
 			Map(x => x.Number);
+            Map(x => x.Tag);
 			Map(x => x.Password);
+            Map(x => x.Password2);
+            Map(x => x.Password3);
+            Map(x => x.Password4);
             Map(x => x.FullName).Column("Description");
             Map(x => x.LastPwChange);
-            HasMany(x => x.Groups)
-                .Cascade.All();
+            HasManyToMany(x => x.Groups)
+                .Cascade.SaveUpdate()
+                .Table("UsersGroups");
         }
     }
 }

Config/Mappings/VirtualBenchSequenceMap.cs

@@ -1,22 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class VirtualBenchSequenceMap : ClassMap<VirtualBenchSequence>
-	{
-		public VirtualBenchSequenceMap()
-        {   
-            Id(x => x.Id);
-			Map(x => x.ItemNr);
-			Map(x => x.Name);
-			Map(x => x.Description);
-			HasMany(x => x.VirtualBenchSteps)
-				.OrderBy("ItemNr")
-				.Cascade.All();
-        }
-	}
-}

Config/Mappings/VirtualBenchStepMap.cs

@@ -1,20 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class VirtualBenchStepMap : ClassMap<VirtualBenchStep>
-	{
-		public VirtualBenchStepMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.ItemNr);
-            Map(x => x.Duration);
-
-			References(x => x.VirtualBenchSequence);
-		}
-	}
-}

Config/Mappings/WMTypeMap.cs

@@ -1,20 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-
-namespace Config.Mappings
-{
-	class WMTypeMap : ClassMap<Entities.WMType>
-    {
-        public WMTypeMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.CreateTime);
-            Map(x => x.CreateUserName);
-            Map(x => x.CreateDescription);
-            Map(x => x.Name);
-            Map(x => x.PulseRate);
-        }
-    }
-}

Config/Mappings/WatermeterMap.cs

@@ -1,19 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-
-namespace Config.Mappings
-{
-	class WatermeterMap : ClassMap<Entities.Watermeter>
-    {
-        public WatermeterMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.Serial);
-            // HasOne(x => x.WMType)
-            //    .Cascade.All();
-            References(x => x.WMType);
-        }
-    }
-}

Config/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Sensus")]
 [assembly: AssemblyProduct("Config")]
-[assembly: AssemblyCopyright("Copyright ©  2013 - 2016 Sensus Slovensko a.s.")]
+[assembly: AssemblyCopyright("Copyright ©  2013 - 2018 Sensus Slovensko a.s.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // 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("2.12.537.0")]
-[assembly: AssemblyFileVersion("2.12.537.0")]
+[assembly: AssemblyVersion("2.26.1447.0")]
+[assembly: AssemblyFileVersion("2.26.1447.0")]

Config/Resources/Strings.Designer.cs

@@ -60,24 +60,6 @@ namespace Config.Resources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Administrator.
-        /// </summary>
-        internal static string Administrator {
-            get {
-                return ResourceManager.GetString("Administrator", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Calibration Specialist.
-        /// </summary>
-        internal static string Calibration_Specialist {
-            get {
-                return ResourceManager.GetString("Calibration_Specialist", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Cannot open DB Cause 0.
         /// </summary>
@@ -92,8 +74,7 @@ namespace Config.Resources {
 		/// </summary>
 		internal static string Error
 		{
-			get
-			{
+			get {
 				return ResourceManager.GetString("Error", resourceCulture);
 			}
 		}
@@ -107,33 +88,6 @@ namespace Config.Resources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Head of Lab.
-        /// </summary>
-        internal static string Head_of_Lab {
-            get {
-                return ResourceManager.GetString("Head_of_Lab", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Maintenance Specialist.
-        /// </summary>
-        internal static string Maintenance_Specialist {
-            get {
-                return ResourceManager.GetString("Maintenance_Specialist", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Metrologist.
-        /// </summary>
-        internal static string Metrologist {
-            get {
-                return ResourceManager.GetString("Metrologist", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Passed.
         /// </summary>
@@ -142,22 +96,114 @@ namespace Config.Resources {
                 return ResourceManager.GetString("Passed", resourceCulture);
             }
         }
-        
+
         /// <summary>
-        ///   Looks up a localized string similar to Tester.
+        ///   Looks up a localized string similar to Once.
         /// </summary>
-        internal static string Tester {
+        internal static string Once
+        {
             get {
-                return ResourceManager.GetString("Tester", resourceCulture);
+                return ResourceManager.GetString("Once", resourceCulture);
             }
         }
-        
+
         /// <summary>
-        ///   Looks up a localized string similar to Testing Specialist.
+        ///   Looks up a localized string similar to Every year.
         /// </summary>
-        internal static string Testing_Specialist {
+        internal static string Every_year
+        {
             get {
-                return ResourceManager.GetString("Testing_Specialist", resourceCulture);
+                return ResourceManager.GetString("Every_year", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Month.
+        /// </summary>
+        internal static string Every_Month
+        {
+            get {
+                return ResourceManager.GetString("Every_Month", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every week.
+        /// </summary>
+        internal static string Every_week
+        {
+            get {
+                return ResourceManager.GetString("Every_week", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Daily.
+        /// </summary>
+        internal static string Daily
+        {
+            get {
+                return ResourceManager.GetString("Daily", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every shift.
+        /// </summary>
+        internal static string Every_shift
+        {
+            get {
+                return ResourceManager.GetString("Every_shift", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Monday, Wednesday and Friday.
+        /// </summary>
+        internal static string Every_Mon_Wed_and_Fri
+        {
+            get {
+                return ResourceManager.GetString("Every_Mon_Wed_and_Fri", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Tuesday and Thursday.
+        /// </summary>
+        internal static string Every_Tue_and_Thu
+        {
+            get {
+                return ResourceManager.GetString("Every_Tue_and_Thu", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Week Day (Mon - Fri).
+        /// </summary>
+        internal static string Every_Week_Day
+        {
+            get {
+                return ResourceManager.GetString("Every_Week_Day", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Custom.
+        /// </summary>
+        internal static string Custom
+        {
+            get {
+                return ResourceManager.GetString("Custom", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Administrator.
+        /// </summary>
+        internal static string Administrator
+        {
+            get {
+                return ResourceManager.GetString("Administrator", resourceCulture);
             }
         }
     }

Config/Resources/Strings.cs.resx

@@ -117,7 +117,40 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="Custom" xml:space="preserve">
+    <value>Volitelně</value>
+  </data>
+  <data name="Daily" xml:space="preserve">
+    <value>Každý den</value>
+  </data>
   <data name="Error" xml:space="preserve">
     <value>Chyba</value>
   </data>
+  <data name="Every_Month" xml:space="preserve">
+    <value>Každý měsíc</value>
+  </data>
+  <data name="Every_Mon_Wed_and_Fri" xml:space="preserve">
+    <value>Každý pondělí, středu a pátek</value>
+  </data>
+  <data name="Every_shift" xml:space="preserve">
+    <value>Každou směnu</value>
+  </data>
+  <data name="Every_Tue_and_Thu" xml:space="preserve">
+    <value>Každý úterí a čtvrtek</value>
+  </data>
+  <data name="Every_week" xml:space="preserve">
+    <value>Každý týden</value>
+  </data>
+  <data name="Every_Week_Day" xml:space="preserve">
+    <value>Každý pracovní den (pon. - pá.)</value>
+  </data>
+  <data name="Every_year" xml:space="preserve">
+    <value>Každý rok</value>
+  </data>
+  <data name="Once" xml:space="preserve">
+    <value>Jednou</value>
+  </data>
+  <data name="Administrator" xml:space="preserve">
+    <value>Správce</value>
+  </data>
 </root>

Config/Resources/Strings.de.resx

@@ -117,27 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Administrator" xml:space="preserve">
-    <value>Administrator</value>
-  </data>
-  <data name="Calibration_Specialist" xml:space="preserve">
-    <value>Kalibriertechniker</value>
-  </data>
-  <data name="Head_of_Lab" xml:space="preserve">
-    <value>Laborleiter</value>
-  </data>
-  <data name="Maintenance_Specialist" xml:space="preserve">
-    <value>Wartungstechniker</value>
-  </data>
-  <data name="Metrologist" xml:space="preserve">
-    <value>Messtechniker</value>
-  </data>
-  <data name="Tester" xml:space="preserve">
-    <value>Prüfer</value>
-  </data>
-  <data name="Testing_Specialist" xml:space="preserve">
-    <value>Prüftechniker</value>
-  </data>
   <data name="Failed" xml:space="preserve">
     <value>NiO</value>
   </data>

Config/Resources/Strings.fr.resx

@@ -117,22 +117,16 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Activity" xml:space="preserve">
-    <value>Činnosť</value>
+  <data name="Failed" xml:space="preserve">
+    <value>Échoué</value>
   </data>
-  <data name="CancelBtnText" xml:space="preserve">
-    <value>Zrušiť</value>
+  <data name="Passed" xml:space="preserve">
+    <value>Passé</value>
   </data>
-  <data name="Compound" xml:space="preserve">
-    <value>Združený</value>
+  <data name="Cannot_open_DB_Cause_0" xml:space="preserve">
+    <value>Impossible d'ouvrir la base de données Cause\\r\\n{0}</value>
   </data>
-  <data name="Compound_meters" xml:space="preserve">
-    <value>Združené vodomery</value>
-  </data>
-  <data name="Language" xml:space="preserve">
-    <value>Jazyk</value>
-  </data>
-  <data name="OkBtnText" xml:space="preserve">
-    <value>Áno</value>
+  <data name="Error" xml:space="preserve">
+    <value>Erreur</value>
   </data>
 </root>

Config/Resources/Strings.it.resx

@@ -0,0 +1,132 @@
+<?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="Failed" xml:space="preserve">
+    <value>NOK</value>
+  </data>
+  <data name="Passed" xml:space="preserve">
+    <value>ok</value>
+  </data>
+  <data name="Cannot_open_DB_Cause_0" xml:space="preserve">
+    <value>Impossibile aprire il database\\r\\nCause:\\r\\n{0}</value>
+  </data>
+  <data name="Error" xml:space="preserve">
+    <value>Errore</value>
+  </data>
+</root>

Config/Resources/Strings.pl.resx

@@ -117,27 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Administrator" xml:space="preserve">
-    <value>Administrator</value>
-  </data>
-  <data name="Calibration_Specialist" xml:space="preserve">
-    <value>Specjalista ds. kalibracji</value>
-  </data>
-  <data name="Head_of_Lab" xml:space="preserve">
-    <value>Kierownik Laboratorium</value>
-  </data>
-  <data name="Maintenance_Specialist" xml:space="preserve">
-    <value>Konserwator</value>
-  </data>
-  <data name="Metrologist" xml:space="preserve">
-    <value>Metrolog</value>
-  </data>
-  <data name="Tester" xml:space="preserve">
-    <value>Pracownik przeprowadzający testy</value>
-  </data>
-  <data name="Testing_Specialist" xml:space="preserve">
-    <value>Specjalista ds. testów</value>
-  </data>
   <data name="Failed" xml:space="preserve">
     <value>Niepowodzenie</value>
   </data>

Config/Resources/Strings.resx

@@ -117,27 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Administrator" xml:space="preserve">
-    <value>Administrator</value>
-  </data>
-  <data name="Calibration_Specialist" xml:space="preserve">
-    <value>Calibration Specialist</value>
-  </data>
-  <data name="Head_of_Lab" xml:space="preserve">
-    <value>Head of Lab</value>
-  </data>
-  <data name="Maintenance_Specialist" xml:space="preserve">
-    <value>Maintenance Specialist</value>
-  </data>
-  <data name="Metrologist" xml:space="preserve">
-    <value>Metrologist</value>
-  </data>
-  <data name="Tester" xml:space="preserve">
-    <value>Tester</value>
-  </data>
-  <data name="Testing_Specialist" xml:space="preserve">
-    <value>Testing Specialist</value>
-  </data>
   <data name="Failed" xml:space="preserve">
     <value>NOK</value>
   </data>
@@ -150,4 +129,37 @@
   <data name="Error" xml:space="preserve">
     <value>Error</value>
   </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Custom</value>
+  </data>
+  <data name="Daily" xml:space="preserve">
+    <value>Daily</value>
+  </data>
+  <data name="Every_Month" xml:space="preserve">
+    <value>Every Month</value>
+  </data>
+  <data name="Every_Mon_Wed_and_Fri" xml:space="preserve">
+    <value>Every Monday, Wednesday and Friday</value>
+  </data>
+  <data name="Every_shift" xml:space="preserve">
+    <value>Every shift</value>
+  </data>
+  <data name="Every_Tue_and_Thu" xml:space="preserve">
+    <value>Every Tuesday and Thursday</value>
+  </data>
+  <data name="Every_week" xml:space="preserve">
+    <value>Every week</value>
+  </data>
+  <data name="Every_Week_Day" xml:space="preserve">
+    <value>Every Week Day (Mon - Fri)</value>
+  </data>
+  <data name="Every_year" xml:space="preserve">
+    <value>Every year</value>
+  </data>
+  <data name="Once" xml:space="preserve">
+    <value>Once</value>
+  </data>
+  <data name="Administrator" xml:space="preserve">
+    <value>Administrator</value>
+  </data>
 </root>

Config/Resources/Strings.ru.resx

@@ -117,27 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Administrator" xml:space="preserve">
-    <value>Администратор</value>
-  </data>
-  <data name="Calibration_Specialist" xml:space="preserve">
-    <value>Специалист по калибровке</value>
-  </data>
-  <data name="Head_of_Lab" xml:space="preserve">
-    <value>Руководитель лаборатории</value>
-  </data>
-  <data name="Maintenance_Specialist" xml:space="preserve">
-    <value>Специалист по техобслуживанию</value>
-  </data>
-  <data name="Metrologist" xml:space="preserve">
-    <value>Метролог</value>
-  </data>
-  <data name="Tester" xml:space="preserve">
-    <value>Контролер</value>
-  </data>
-  <data name="Testing_Specialist" xml:space="preserve">
-    <value>Специалист по тестированию</value>
-  </data>
   <data name="Failed" xml:space="preserve">
     <value>NOK</value>
   </data>

Config/Resources/Strings.zh-CN.resx

@@ -1,128 +1,129 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
-	<!-- 
-		Microsoft ResX Schema
+  <!-- 
+    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.
 
-		Version 1.3
-
-		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">1.3</resheader>
-		<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-		<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-		<data name="Name1">this is my long string</data>
-		<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-		<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-			[base64 mime encoded serialized .NET Framework object]
-		</data>
-		<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-			[base64 mime encoded string representing a byte array form of the .NET Framework object]
-		</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.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: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" msdata:Ordinal="1" />
-							<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-							<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-						</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.3</value>
-	</resheader>
-	<resheader name="reader">
-		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-	</resheader>
-	<resheader name="writer">
-		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-	</resheader>
-	<data name="Administrator" xml:space="preserve">
-		<value>管理员</value>
-	</data>
-	<data name="Calibration_Specialist" xml:space="preserve">
-		<value>校准专员</value>
-	</data>
-	<data name="Failed" xml:space="preserve">
-		<value>NOK</value>
-	</data>
-	<data name="Head_of_Lab" xml:space="preserve">
-		<value>实验室负责人</value>
-	</data>
-	<data name="Maintenance_Specialist" xml:space="preserve">
-		<value>维护专员</value>
-	</data>
-	<data name="Metrologist" xml:space="preserve">
-		<value>计量者</value>
-	</data>
-	<data name="Passed" xml:space="preserve">
-		<value>好</value>
-	</data>
-	<data name="Tester" xml:space="preserve">
-		<value>测试仪</value>
-	</data>
-	<data name="Testing_Specialist" xml:space="preserve">
-		<value>测试专员</value>
-	</data>
+    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="Error" xml:space="preserve">
+    <value>错误 Error</value>
+  </data>
+  <data name="Failed" xml:space="preserve">
+    <value>NOK</value>
+  </data>
+  <data name="Passed" xml:space="preserve">
+    <value>好</value>
+  </data>
 </root>

Config/Units.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016 Sensus Metering Systems
+/// Copyright (c) 2016-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Reflection;
@@ -11,7 +11,14 @@ namespace Config
     {
 		[Description("---")]		None,
 
+        [Description("imp.")]       pulse,
+#if LANG_PL
+        [Description("stopień")]    degree,
+#else
+        [Description("degree")]     degree,
+#endif
         [Description("l")]          l,          /// * 1 liter
+        [Description("dm3")]        dm3,        ///   1 dm3 = 1 liter
         [Description("m3")]         m3,         ///   1000 l
         [Description("gal(UK)")]    gal_UK,     ///   1 gal(UK) = 4.54609 l
         [Description("gal(US)")]    gal_US,     ///   1 gal(US) = 3.78541178 l
@@ -29,7 +36,7 @@ namespace Config
         [Description("hr")]         hour,       ///   1 hour = 60 min = 3600 s
         [Description("ms")]         ms,         ///   1 ms = 0.001 s
 
-        [Description("°C")]         C,          /// * degree Celsius
+		[Description("°C")]         C,          /// * degree Celsius (°C)
         [Description("°F")]         F,          ///   degree Fahrenheit
         [Description("K")]          K,          ///   degree Kelvin
 
@@ -61,9 +68,28 @@ namespace Config
         [Description("kWh")]        kWh,		///   1 kWh = 3600000 J
         [Description("MWh")]        MWh,		///   1 MWh = 3600000000 J
 
+#if LANG_PL
+        [Description("imp/l")]       ppl,		/// * 1 pulse/l
+        [Description("imp/dm3")]     ppdm3,		/// * 1 pulse/dm3
+        [Description("stopień/l")]   degpl,		/// * 1 degree/l
+        [Description("stopień/dm3")] degpdm3,	/// * 1 degree/dm3
+        [Description("l/imp")]       lpp,		/// * 1 l/pulse
+        [Description("dm3/imp")]     dm3pp,		/// * 1 dm3/pulse
+        [Description("l/stopień")]   lpdeg,		/// * 1 l/degree
+        [Description("dm3/stopień")] dm3pdeg,	/// * 1 dm3/degree
+#else
         [Description("pulse/l")]    ppl,		/// * 1 pulse/l
-                                                /// 
+        [Description("pulse/dm3")]  ppdm3,		/// * 1 pulse/dm3
+        [Description("degree/l")]   degpl,		/// * 1 degree/l
+        [Description("degree/dm3")] degpdm3,	/// * 1 degree/dm3
+        [Description("l/pulse")]    lpp,		/// * 1 l/pulse
+        [Description("dm3/pulse")]  dm3pp,		/// * 1 dm3/pulse
+        [Description("l/degree")]   lpdeg,		/// * 1 l/degree
+        [Description("dm3/degree")] dm3pdeg,	/// * 1 dm3/degree
+#endif
+        /// 
         [Description("pulse/kWh")]  ppkWh,		/// * 1 pulse/kWh
+        [Description("kWh/pulse")]  kWhpp,		/// * 1 kWh/pulse
                                                 
         Count
     }
@@ -83,6 +109,7 @@ namespace Config
 		[Description("Länge")]				Length,
 		[Description("Dichte")]				Density,
 		[Description("Energie")]			Energy,
+		[Description("Impulse")]			Pulses,
         [Description("Impulse/l")]			PulsePerLtr,
         [Description("Impulse/kWh")]		PulsePerKWh,
 
@@ -92,7 +119,7 @@ namespace Config
         [Description("Boolean")]			Boolean,
         [Description("Datum und Uhrzeit")]  DateTime,
 #elif LANG_PL
-		[Description("Objętość")]			Volume,
+        [Description("Objętość")]			Volume,
 		[Description("Przepływ")]           Flow,
 		[Description("Masa")]				Mass,
         [Description("Czas")]				Time,
@@ -103,6 +130,7 @@ namespace Config
 		[Description("Długość")]			Length,
 		[Description("Gęstość")]			Density,
 		[Description("Energia")]			Energy,
+        [Description("Impulsy")]            Pulses,
         [Description("Impulsy/litr")]       PulsePerLtr,
         [Description("Impulsy/kWh")]		PulsePerKWh,
 
@@ -123,6 +151,7 @@ namespace Config
 		[Description("Délka")]				Length,
 		[Description("Hustota")]			Density,
 		[Description("Energie")]			Energy,
+		[Description("Pulzy")]				Pulses,
         [Description("Pulzy/litr")]			PulsePerLtr,
         [Description("Pulzy/kWh")]			PulsePerKWh,
 
@@ -131,8 +160,29 @@ namespace Config
         [Description("Text")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Datum a čas")]		DateTime,
-#else
+#elif LANG_IT
 		[Description("Volume")]				Volume,
+		[Description("Flusso")]				Flow,
+		[Description("Massa")]              Mass,
+        [Description("Tempo")]				Time,
+        [Description("Temperatura")]	    Temperature,
+		[Description("Pressione")]			Pressure,
+        [Description("Umidità")]			Humidity,
+        [Description("Errore")]				Error,
+		[Description("Lungezza")]			Length,
+		[Description("Densità")]			Density,
+		[Description("Energia")]			Energy,
+		[Description("Impulso")]			Pulses,
+        [Description("Impulso/litro")]		PulsePerLtr,
+        [Description("Impulso/kWh")]		PulsePerKWh,
+
+        /// Quantities without units and conversions
+        [Description("Numero")]				Number,
+        [Description("Stringa")]			String,
+        [Description("Boolean")]			Boolean,
+        [Description("Data e ora")]		    DateTime,
+#else
+        [Description("Volume")]				Volume,
 		[Description("Flow")]				Flow,
 		[Description("Mass")]				Mass,
         [Description("Time")]				Time,
@@ -143,6 +193,7 @@ namespace Config
 		[Description("Length")]				Length,
 		[Description("Density")]			Density,
 		[Description("Energy")]				Energy,
+		[Description("Pulses")]				Pulses,
         [Description("Pulses/liter")]		PulsePerLtr,
         [Description("Pulses/kWh")]			PulsePerKWh,
 
@@ -151,8 +202,9 @@ namespace Config
         [Description("String")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Date and time")]		DateTime,
+        [Description("Enum")]               Enum,
 #endif
-		Count,
+        Count,
 	}
 
     public static class Units
@@ -177,7 +229,12 @@ namespace Config
 		{
             switch (units)
             {
+                case Unit.pulse:
+                case Unit.degree:
+                    return Config.Quantity.Pulses;
+
                 case Unit.l:
+                case Unit.dm3:
                 case Unit.m3:
                 case Unit.gal_UK:
                 case Unit.gal_US:
@@ -239,9 +296,17 @@ namespace Config
                     return Config.Quantity.Energy;
 
                 case Unit.ppl:
+                case Unit.ppdm3:
+                case Unit.degpl:
+                case Unit.degpdm3:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:
                     return Config.Quantity.PulsePerLtr;
 
                 case Unit.ppkWh:
+                case Unit.kWhpp:
                     return Config.Quantity.PulsePerKWh;
 
                 default:
@@ -260,6 +325,7 @@ namespace Config
 		public static bool IsLength(Unit units) { return IsQuantity(units, Config.Quantity.Length); }
 		public static bool IsDensity(Unit units) { return IsQuantity(units, Config.Quantity.Density); }
 		public static bool IsEnergy(Unit units) { return IsQuantity(units, Config.Quantity.Energy); }
+        public static bool IsPulses(Unit units) { return IsQuantity(units, Config.Quantity.Pulses); }
         public static bool IsPulsePerLtr(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerLtr); }
         public static bool IsPulsePerKWh(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerKWh); }
 
@@ -269,6 +335,7 @@ namespace Config
             switch (units)
             {
                 /// Volume: internal representation in l
+                case Unit.dm3:
                 case Unit.l:        return v;               /// 1 liter
                 case Unit.m3:       return 0.001 * v;       /// 1 m3 = 1000 l
                 case Unit.gal_UK:   return 0.21996925 * v;  /// 1 gal(UK) = 4.54609 l
@@ -290,8 +357,8 @@ namespace Config
                 case Unit.hour:     return v / 3600;
                 case Unit.ms:       return 1000 * v;
 
-                /// Temperature: internal representation in degree C 
-                case Unit.C:        return v;               /// degree Celsius
+				/// Temperature: internal representation in °C
+				case Unit.C:        return v;               /// degree Celsius (°C)
                 case Unit.F:        return 1.8 * v + 32;    /// degree Fahrenheit
                 case Unit.K:        return v + 273.15;      /// degree Kelvin
 
@@ -326,7 +393,13 @@ namespace Config
 				case Unit.kWh:      return v / 3600000.0;   /// 1 kWh = 3600000 J
                 case Unit.MWh:      return v / 3600000000.0;/// 1 MWh = 3600000000 J
 
-                default: return v;
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return ((v <= float.Epsilon) ? 0 : 1 / v);
+
+                default:            return v;
             }
         }
 
@@ -335,6 +408,7 @@ namespace Config
             switch (units)
             {
                 /// Volume: internal representation in l
+                case Unit.dm3:
                 case Unit.l:        return v;               /// 1 liter
                 case Unit.m3:       return 1000 * v;        /// 1000 l
                 case Unit.gal_UK:   return 4.54609 * v;     /// 1 gal(UK) = 4.54609 l
@@ -356,8 +430,8 @@ namespace Config
                 case Unit.hour:     return 3600 * v;
                 case Unit.ms:       return v / 1000;
 
-                /// Temperature: internal representation in degree C 
-                case Unit.C:        return v;               /// degree Celsius
+				/// Temperature: internal representation in °C
+				case Unit.C:        return v;               /// degree Celsius (°C)
                 case Unit.F:        return 5 * (v-32) / 9;  /// degree Fahrenheit
                 case Unit.K:        return v - 273.15;      /// degree Kelvin
 
@@ -392,7 +466,13 @@ namespace Config
 				case Unit.kWh:		return 3600000 * v;     /// 1 kWh = 3600000 J
                 case Unit.MWh:      return 3600000000 * v;  /// 1 kWh = 3600000000 J
 
-                default: return v;
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return ((v == 0) ? 0 : 1 / v);
+
+                default:            return v;
             }
         }
 	}

Config/Utils.cs

@@ -0,0 +1,256 @@
+///
+/// Copyright (c) 2017-2018 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Config
+{
+    public static class Utils
+    {
+        public static string SignificantDigitsToFmt(double value, int sigDigits)
+        {
+            if (sigDigits == 6)
+            {
+                if (value >= 99999.5 || value < -99999.5) return "F0";
+                else if (value >= 9999.95 || value < -9999.95) return "F1";
+                else if (value >= 999.995 || value < -999.995) return "F2";
+                else if (value >= 99.9995 || value < -99.9995) return "F3";
+                else if (value >= 9.99995 || value < -9.99995) return "F4";
+                else if (value >= 0.999995 || value < -0.999995) return "F5";
+                else if (value >= 0.0999995 || value < -0.0999995) return "F6";
+                else if (value >= 0.00999995 || value < -0.00999995) return "F7";
+                else if (value >= 0.000999995 || value < -0.000999995) return "F8";
+                else if (value >= 0.0000999995 || value < -0.0000999995) return "F9";
+                else return "F10";
+            }
+            else if (sigDigits == 5)
+            {
+                if (value >= 9999.5 || value < -9999.5) return "F0";
+                else if (value >= 999.95 || value < -999.95) return "F1";
+                else if (value >= 99.995 || value < -99.995) return "F2";
+                else if (value >= 9.9995 || value < -9.9995) return "F3";
+                else if (value >= 0.99995 || value < -0.99995) return "F4";
+                else if (value >= 0.099995 || value < -0.099995) return "F5";
+                else if (value >= 0.0099995 || value < -0.0099995) return "F6";
+                else if (value >= 0.00099995 || value < -0.00099995) return "F7";
+                else if (value >= 0.000099995 || value < -0.000099995) return "F8";
+                else return "F9";
+            }
+            else if (sigDigits == 4)
+            {
+                if (value >= 999.5 || value < -999.5) return "F0";
+                else if (value >= 99.95 || value < -99.95) return "F1";
+                else if (value >= 9.995 || value < -9.995) return "F2";
+                else if (value >= 0.9995 || value < -0.9995) return "F3";
+                else if (value >= 0.09995 || value < -0.09995) return "F4";
+                else if (value >= 0.009995 || value < -0.009995) return "F5";
+                else if (value >= 0.0009995 || value < -0.0009995) return "F6";
+                else if (value >= 0.00009995 || value < -0.00009995) return "F7";
+                else return "F8";
+            }
+            else if (sigDigits == 3)
+            {
+                if (value >= 99.5 || value < -99.5) return "F0";
+                else if (value >= 9.95 || value < -9.95) return "F1";
+                else if (value >= 0.995 || value < -0.995) return "F2";
+                else if (value >= 0.0995 || value < -0.0995) return "F3";
+                else if (value >= 0.00995 || value < -0.00995) return "F4";
+                else if (value >= 0.000995 || value < -0.000995) return "F5";
+                else if (value >= 0.0000995 || value < -0.0000995) return "F6";
+                else return "F7";
+            }
+            else if (sigDigits == 2)
+            {
+                if (value >= 9.5 || value < -9.5) return "F0";
+                else if (value >= 0.95 || value < -0.95) return "F1";
+                else if (value >= 0.095 || value < -0.095) return "F2";
+                else if (value >= 0.0095 || value < -0.0095) return "F3";
+                else if (value >= 0.00095 || value < -0.00095) return "F4";
+                else if (value >= 0.000095 || value < -0.000095) return "F5";
+                else return "F6";
+            }
+            else /// if (sigDigits == 1)
+            {
+                if (value >= 0.95 || value < -0.95) return "F0";
+                else if (value >= 0.095 || value < -0.095) return "F1";
+                else if (value >= 0.0095 || value < -0.0095) return "F2";
+                else if (value >= 0.00095 || value < -0.00095) return "F3";
+                else if (value >= 0.000095 || value < -0.000095) return "F4";
+                else return "F5";
+            }
+        }
+
+
+        /// <summary>
+        /// Extract and return a DB server from a MySQL connection string.
+        /// </summary>
+        public static string GetDBServer(string connectionString)
+        {
+            return GetFromConnectionString(connectionString, new string[] { "SERVER=" });
+        }
+
+        /// <summary>
+        /// Extract and return a DB name from a MySQL connection string.
+        /// </summary>
+        public static string GetDBName(string connectionString)
+        {
+            return GetFromConnectionString(connectionString, new string[] { "DATABASE=" });
+        }
+
+        /// <summary>
+        /// Extract and return a username from a MySQL connection string
+        /// </summary>
+        public static string GetDBUser(string connectionString)
+        {
+            return GetFromConnectionString(connectionString, new string[] { "USER=", "UID=" });
+        }
+
+        /// <summary>
+        /// Extract and return a password from a MySQL connection string
+        /// </summary>
+        public static string GetDBPassword(string connectionString)
+        {
+            return GetFromConnectionString(connectionString, new string[] { "PASSWORD=", "PWD=" });
+        }
+
+        /// <summary>
+        /// Extract and return an element of a MySQL connection string
+        /// (a host, a database, a user name or a password).
+        /// Return an empty string on any error.
+        /// </summary>
+        public static string GetFromConnectionString(string connectionString, string[] patterns)
+        {
+            foreach (var pattern in patterns)
+            {
+                int startIx = connectionString.IndexOf(pattern);
+                if (startIx >= 0)
+                {
+                    /// pattern found, extract the subsequent element
+                    startIx += pattern.Length;
+                    int endIx = connectionString.IndexOf(';', startIx);
+                    return (endIx > 0) ? connectionString.Substring(startIx, endIx - startIx) : string.Empty;
+                }
+            }
+
+            /// pattern NOT found
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Get either Q1 or Qmin flow for a given Qn and metrological class
+        /// </summary>
+        /// <param name="Qn">Nominal flow in m3/h</param>
+        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
+        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
+        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
+        /// <returns>Q1 or Qmin flow in m3/h</returns>
+        public static double GetQ1Qmin(double Qn, string metroClass, Entities.Medium medium = Entities.Medium.ColdWater, double Qdflt = 0)
+        {
+            if (string.IsNullOrEmpty(metroClass)) return Qdflt;
+
+            int metroClassRatio;
+            if ((metroClass[0] == 'R') && int.TryParse(metroClass.Substring(1), out metroClassRatio) && (metroClassRatio > 0))
+            {
+                return Qn / (double)metroClassRatio;
+            }
+            else
+            {
+                if (medium == Entities.Medium.HotWater)
+                {
+                    switch (metroClass)
+                    {
+                        case "A": return (Qn < 15) ? (0.04 * Qn) : (0.08 * Qn);
+                        case "B": return (Qn < 15) ? (0.02 * Qn) : (0.04 * Qn);
+                        case "C": return (Qn < 15) ? (0.01 * Qn) : (0.02 * Qn);
+                        case "D": return (Qn < 15) ? (0.01 * Qn) : Qdflt;
+                        default: break;
+                    }
+                }
+                else
+                {
+                    switch (metroClass)
+                    {
+                        case "A": return (Qn < 15) ? (0.04 * Qn) : (0.08 * Qn);
+                        case "B": return (Qn < 15) ? (0.02 * Qn) : (0.03 * Qn);
+                        case "C": return (Qn < 15) ? (0.01 * Qn) : (0.006 * Qn);
+                        default: break;
+                    }
+                }
+            }
+
+            return Qdflt;
+        }
+
+        /// <summary>
+        /// Get either Q2 or Qt flow for a given Qn and metrological class
+        /// </summary>
+        /// <param name="Qn">Nominal flow in m3/h</param>
+        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
+        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
+        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
+        /// <returns>Q2 or Qt flow in m3/h</returns>
+        public static double GetQ2Qt(double Qn, string metroClass, Entities.Medium medium = Entities.Medium.ColdWater, double Qdflt = 0)
+        {
+            if (string.IsNullOrEmpty(metroClass)) return Qdflt;
+
+            int metroClassRatio;
+            if ((metroClass[0] == 'R') && int.TryParse(metroClass.Substring(1), out metroClassRatio) && (metroClassRatio > 0))
+            {
+                return 1.6 * Qn / (double)metroClassRatio;
+            }
+
+            if (medium == Entities.Medium.HotWater)
+            {
+                switch (metroClass)
+                {
+                    case "A": return (Qn < 15) ? (0.1 * Qn) : (0.2 * Qn);
+                    case "B": return (Qn < 15) ? (0.08 * Qn) : (0.15 * Qn);
+                    case "C": return (Qn < 15) ? (0.06 * Qn) : (0.1 * Qn);
+                    case "D": return (Qn < 15) ? (0.015 * Qn) : Qdflt;
+                    default: break;
+                }
+            }
+            else
+            {
+                switch (metroClass)
+                {
+                    case "A": return (Qn < 15) ? (0.1 * Qn) : (0.3 * Qn);
+                    case "B": return (Qn < 15) ? (0.08 * Qn) : (0.2 * Qn);
+                    case "C": return (Qn < 15) ? (0.015 * Qn) : (0.015 * Qn);
+                    default: break;
+                }
+            }
+
+            return Qdflt;
+        }
+
+        /// <summary>
+        /// Get either Q4 or Qmax flow for a given Qn and metrological class
+        /// </summary>
+        /// <param name="Qn">Nominal flow in m3/h</param>
+        /// <param name="metroClass">Metrological class ("A" ,"B", "C" or "R#")</param>
+        /// <param name="medium">NotSpecified, ColdWater or HotWater</param>
+        /// <param name="Qdflt">Default flow when metrologic does not match pattern</param>
+        /// <returns>Q4 or Qmax flow in m3/h</returns>
+        public static double GetQ4Qmax(double Qn, string metroClass, Entities.Medium medium = Entities.Medium.ColdWater, double Qdflt = 0)
+        {
+            if (string.IsNullOrEmpty(metroClass)) return Qdflt;
+
+            switch (metroClass[0])
+            {
+                case 'A':
+                case 'B':
+                case 'C':
+                case 'D':
+                    return 2 * Qn;
+                case 'R':
+                    return 1.25 * Qn;
+                default:
+                    return Qdflt;
+            }
+        }
+    }
+}

Decrypt/Decrypt.csproj

@@ -0,0 +1,66 @@
+<?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)' == '' ">x86</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D476ABBE-A455-4476-8A8D-3F6151217B51}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Decrypt</RootNamespace>
+    <AssemblyName>Decrypt</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>Decrypt.Program</StartupObject>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <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="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.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>

Decrypt/Decrypt.csproj.user

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <StartArguments>config.xml</StartArguments>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <StartArguments>config.xml</StartArguments>
+  </PropertyGroup>
+</Project>

Decrypt/Program.cs

@@ -0,0 +1,96 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Decrypt
+{
+    /// <summary>
+    /// See also:
+    /// https://www.fluxbytes.com/csharp/encrypt-and-decrypt-files-in-c/
+    /// </summary>
+    class Program
+    {
+        static byte[] key = new byte[] { 83, 254, 105, 64, 184, 201, 195, 127, 52, 99, 77, 45, 252, 132, 163, 156 };
+        static byte[] IV = new byte[] { 189, 23, 137, 56, 204, 241, 242, 118, 28, 89, 9, 198, 224, 111, 186, 125 };
+
+        static void Main(string[] args)
+        {
+            if ((args.Length < 1) || !File.Exists(args[0]))
+            {
+                Console.WriteLine("Usage:  Decode <file>");
+                Console.ReadKey();
+                return;
+            }
+
+            string fileName = args[0];
+            string intermediateFile = fileName + ".plain";  /// Intermediate file, output of cryptography decoding
+            string backupFile = fileName + ".bak";
+
+            try
+            {
+                using (StreamReader reader = new StreamReader(fileName))
+                {
+                    if (reader.ReadLine().StartsWith("<?xml version="))
+                    {
+                        Console.WriteLine(string.Format("File {0} is not encrypted.", fileName));
+                        Console.ReadKey();
+                        return;
+                    }
+                }
+
+                bool successful = false;
+                using (RijndaelManaged aes = new RijndaelManaged { Padding = PaddingMode.Zeros })
+                {
+                    using (FileStream fsCrypt = new FileStream(fileName, FileMode.Open))
+                    {
+                        using (FileStream fsOut = new FileStream(intermediateFile, FileMode.Create))
+                        {
+                            using (ICryptoTransform decryptor = aes.CreateDecryptor(key, IV))
+                            {
+                                using (CryptoStream cs = new CryptoStream(fsCrypt, decryptor, CryptoStreamMode.Read))
+                                {
+                                    int data;
+                                    while ((data = cs.ReadByte()) != -1)
+                                    {
+                                        if (data != 0) fsOut.WriteByte((byte)data);
+                                    }
+                                    successful = true;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (successful)
+                {
+                    /// File decryption successfuly completed => rotate files
+                    if (File.Exists(backupFile)) File.Delete(backupFile);
+                    File.Move(fileName, backupFile);
+                    File.Move(intermediateFile, fileName);
+                    return;
+                }
+                else
+                {
+                    Failed(fileName, intermediateFile, "");
+                    return;
+                }
+            }
+            catch (Exception e)
+            {
+                Failed(fileName, intermediateFile, e.Message);
+                return;
+            }
+        }
+
+        static void Failed(string fileName, string toBeDeleted, string message)
+        {
+            if (File.Exists(toBeDeleted))
+            {
+                File.Delete(toBeDeleted);
+            }
+            Console.WriteLine(string.Format("Decryption of file {0} failed: {1}", fileName, message));
+            Console.ReadKey();
+        }
+    }
+}

Decrypt/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("Decrypt")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Decrypt")]
+[assembly: AssemblyCopyright("Copyright © 2019")]
+[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("c17ec788-0e12-4f9c-aadf-ea4e83a9f373")]
+
+// 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.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]

Decrypt/app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/></startup></configuration>

DeviceTest/DeviceTest.csproj

@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>DeviceTest</RootNamespace>
     <AssemblyName>DeviceTest</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <TargetFrameworkProfile>
     </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
@@ -24,6 +24,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <PlatformTarget>x86</PlatformTarget>
@@ -33,6 +34,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup>
     <StartupObject>DeviceTest.Program</StartupObject>
@@ -92,7 +94,7 @@
       <Project>{743DF7DB-C7B6-42EB-986D-0F485E5588E4}</Project>
       <Name>Config</Name>
     </ProjectReference>
-    <ProjectReference Include="..\TestBenchFramework\TBF.csproj">
+    <ProjectReference Include="..\TBF\TBF.csproj">
       <Project>{8648FD92-CDA1-4C3A-B5F9-FE547CE1FA48}</Project>
       <Name>TBF</Name>
     </ProjectReference>

DeviceTest/DeviceTestDlg.cs

@@ -7,7 +7,6 @@ using System.Threading;
 using System.Windows.Forms;
 using TBF.BenchControl;
 using TBF.BenchControl.Generic;
-using TBF.BenchControl.GenericDevices;
 using System.Xml.Serialization;
 
 
@@ -27,11 +26,11 @@ namespace DeviceTest
 		IComponentCfg component2Cfg;
 		IComponentCfg component3Cfg;
 
-		static IList<TBF.BenchControl.Generic.IDevice> tbfDevices;
-		static IList<TBF.BenchControl.Generic.IComponent> tbfComponents;
-		static TBF.BenchControl.Generic.IComponent tbfComponent1forOp;
-		static TBF.BenchControl.Generic.IComponent tbfComponent2forOp;
-		static TBF.BenchControl.Generic.IComponent tbfComponent3forOp;
+		static IList<IDevice> tbfDevices;
+		static IList<IComponent> tbfComponents;
+		static IComponent tbfComponent1forOp;
+		static IComponent tbfComponent2forOp;
+		static IComponent tbfComponent3forOp;
 
 		static Thread workerThread;
 		static bool workerThreadRunning;
@@ -56,7 +55,10 @@ namespace DeviceTest
 
 
 		static TBF.Boxes.FloatBox floatBox;
-		static Event evnt;
+        static TBF.Boxes.DoubleBox dblBox1;
+        static TBF.Boxes.DoubleBox dblBox2;
+        static TBF.Boxes.DoubleBox dblBox3;
+        static Event evnt;
 
 
 		static DeviceTestDlg()
@@ -68,10 +70,10 @@ namespace DeviceTest
         public DeviceTestDlg()
         {
             InitializeComponent();
-            compClasses = new List<string>();
 			radioButton0.Checked = true;
 			stopButton.Enabled = false;
-			
+
+			compClasses = new List<string>();
 			foreach (var componentFactory in TbfComponents.Factories)
             {
                 compClasses.Add(componentFactory.ClassName);
@@ -273,7 +275,14 @@ namespace DeviceTest
 				radioButton3.Text = "SelectTank 3";
 				radioButton4.Text = "SelectTank -";
 			}
-			else radioButton1.Text = "spare";
+            else if (className == "Modbus.QuidoRS")
+            {
+                radioButton1.Text = "Close relay 1";
+                radioButton2.Text = "Close relay 2";
+                radioButton3.Text = "Close relay 3";
+                radioButton4.Text = "Open all relays";
+            }
+            else radioButton1.Text = "spare";
 		}
 		/// 
 		void UpdateOperations2(string className)
@@ -293,7 +302,14 @@ namespace DeviceTest
 				radioButton23.Text = "SelectTank 3";
 				radioButton24.Text = "SelectTank -";
 			}
-			else radioButton21.Text = "spare";
+            else if (className == "Modbus.QuidoRS")
+            {
+                radioButton21.Text = "Close relay 1";
+                radioButton22.Text = "Close relay 2";
+                radioButton23.Text = "Close relay 3";
+                radioButton24.Text = "Open all relays";
+            }
+            else radioButton21.Text = "spare";
 		}
 		/// 
 		void UpdateOperations3(string className)
@@ -313,7 +329,14 @@ namespace DeviceTest
 				radioButton33.Text = "SelectTank 3";
 				radioButton34.Text = "SelectTank -";
 			}
-			else radioButton31.Text = "spare";
+            else if (className == "Modbus.QuidoRS")
+            {
+                radioButton31.Text = "Close relay 1";
+                radioButton32.Text = "Close relay 2";
+                radioButton33.Text = "Close relay 3";
+                radioButton34.Text = "Open all relays";
+            }
+            else radioButton31.Text = "spare";
 		}
 
 
@@ -402,7 +425,7 @@ namespace DeviceTest
 			cfgControl.Config = parentCfg;
 			cfgControl.Config.ItemNr = 0;
 
-			TBF.ComponentParametersDlg cfgForm = new TBF.ComponentParametersDlg();
+			ComponentParametersDlg cfgForm = new ComponentParametersDlg();
 			cfgForm.TbfComponents = new List<Config.Entities.Component>();
 
 			cfgForm.ComponentCfgCtrl = cfgControl;
@@ -431,7 +454,7 @@ namespace DeviceTest
 			cfgControl.Config = component1Cfg;
 			cfgControl.Config.ItemNr = 1;
 
-			TBF.ComponentParametersDlg cfgForm = new TBF.ComponentParametersDlg();
+			ComponentParametersDlg cfgForm = new ComponentParametersDlg();
 			///
 			IList<Config.Entities.Component> compEntities = new List<Config.Entities.Component>();
 			if (parentFactory != null && parentCfg != null) compEntities.Add(parentCfg.CreateDbEntity());
@@ -465,7 +488,7 @@ namespace DeviceTest
 			cfgControl.Config = component2Cfg;
 			cfgControl.Config.ItemNr = 1;
 
-			TBF.ComponentParametersDlg cfgForm = new TBF.ComponentParametersDlg();
+			ComponentParametersDlg cfgForm = new ComponentParametersDlg();
 			///
 			IList<Config.Entities.Component> compEntities = new List<Config.Entities.Component>();
 			if (parentFactory != null && parentCfg != null) compEntities.Add(parentCfg.CreateDbEntity());
@@ -500,7 +523,7 @@ namespace DeviceTest
 			cfgControl.Config = component3Cfg;
 			cfgControl.Config.ItemNr = 1;
 
-			TBF.ComponentParametersDlg cfgForm = new TBF.ComponentParametersDlg();
+			ComponentParametersDlg cfgForm = new ComponentParametersDlg();
 			///
 			IList<Config.Entities.Component> compEntities = new List<Config.Entities.Component>();
 			if (parentFactory != null && parentCfg != null) compEntities.Add(parentCfg.CreateDbEntity());
@@ -657,13 +680,25 @@ namespace DeviceTest
 				operation1 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(10);
 				operation2 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(20);
 			}
-			else if (tbfComponent1forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            else if (tbfComponent1forOp is TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter)
+            {
+                operation1 = (tbfComponent1forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadLevelOp(ref dblBox1);
+                operation2 = (tbfComponent1forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadTempOp(ref dblBox3);
+            }
+            else if (tbfComponent1forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
 			{
 				//operation1 = (tbfComponent1forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(1);
 				//operation2 = (tbfComponent1forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(2);
 				//operation3 = (tbfComponent1forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(3);
 				//operation4 = (tbfComponent1forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(0);
 			}
+            else if (tbfComponent3forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            {
+                operation1 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(1);
+                operation2 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(2);
+                operation3 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(4);
+                operation4 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(0);
+            }
 
 
 			if (tbfComponent2forOp is TBF.BenchControl.Modbus.PressureMeter.Meret.PressureMeter)
@@ -681,16 +716,28 @@ namespace DeviceTest
 			}
 			else if (tbfComponent2forOp is TBF.BenchControl.Modbus.Easytherm.Easytherm)
 			{
-				operation21 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(10);
-				operation22 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(20);
+				operation21 = (tbfComponent2forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(10);
+				operation22 = (tbfComponent2forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(20);
 			}
-			else if (tbfComponent2forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            else if (tbfComponent2forOp is TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter)
+            {
+                operation21 = (tbfComponent2forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadLevelOp(ref dblBox1);
+                operation22 = (tbfComponent2forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadTempOp(ref dblBox3);
+            }
+            else if (tbfComponent2forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
 			{
 				//operation21 = (tbfComponent2forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(1);
                 //operation22 = (tbfComponent2forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(2);
                 //operation23 = (tbfComponent2forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(3);
                 //operation24 = (tbfComponent2forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(0);
 			}
+            else if (tbfComponent3forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            {
+                operation21 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(1);
+                operation22 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(2);
+                operation23 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(4);
+                operation24 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(0);
+            }
 
 
 			if (tbfComponent3forOp is TBF.BenchControl.Modbus.PressureMeter.Meret.PressureMeter)
@@ -708,23 +755,38 @@ namespace DeviceTest
 			}
 			else if (tbfComponent3forOp is TBF.BenchControl.Modbus.Easytherm.Easytherm)
 			{
-				operation31 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(10);
-				operation32 = (tbfComponent1forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(20);
+				operation31 = (tbfComponent3forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(10);
+				operation32 = (tbfComponent3forOp as TBF.BenchControl.Modbus.Easytherm.Easytherm).SetTemperatureOp(20);
 			}
-			else if (tbfComponent3forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            else if (tbfComponent3forOp is TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter)
+            {
+                operation31 = (tbfComponent3forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadLevelOp(ref dblBox1);
+                operation32 = (tbfComponent3forOp as TBF.BenchControl.Modbus.UltrasoundLevelMeter.LevelMeter).ReadTempOp(ref dblBox3);
+            }
+            else if (tbfComponent3forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
 			{
 				//operation31 = (tbfComponent3forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(1);
 				//operation32 = (tbfComponent3forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(2);
 				//operation33 = (tbfComponent3forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(3);
 				//operation34 = (tbfComponent3forOp as TBF.BenchControl.Modbus.TankSelector.TankSelector).SelectTankOp(0);
 			}
+            else if (tbfComponent3forOp is TBF.BenchControl.Modbus.TankSelector.TankSelector)
+            {
+                operation31 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(1);
+                operation32 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(2);
+                operation33 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(4);
+                operation34 = (tbfComponent3forOp as TBF.BenchControl.Modbus.QuidoRS.QuidoRS).SetOutputsOp(0);
+            }
 
 
-			while (workerThreadRunning)
+            int time = 0;
+            while (workerThreadRunning)
 			{
 				Thread.Sleep(1000);
 
-				if (workerThreadRunning)
+                StateMachine.Time = ++time;
+
+                if (workerThreadRunning)
 				{
 					foreach (var d in tbfDevices) d.RunDeviceBefore();
 

DeviceTest/Program.cs

@@ -72,10 +72,10 @@ namespace DeviceTest
 			}
 
 			/// Configure and start logging
-			log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo(LocAppDataDir + log4netConfigFName));
+			log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo(Path.Combine(LocAppDataDir, log4netConfigFName)));
 			log = LogManager.GetLogger(typeof(Program));
 			log.Fatal("--------------------------------------------------------------------------------");
-			log.Fatal(string.Format("TBF ver.{0}", Version));
+			log.FatalFormat("DeviceTest ver.{0}", Version);
 
 			Application.EnableVisualStyles();
 			Application.SetCompatibleTextRenderingDefault(false);

DeviceTest/Properties/Settings.Designer.cs

@@ -12,7 +12,7 @@ namespace DeviceTest.Properties {
     
     
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
         
         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));

DeviceTest/app.config

@@ -1,3 +1,3 @@
 <?xml version="1.0"?>
 <configuration>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/></startup></configuration>

Dirichlet.Numerics/Dirichlet.Numerics.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?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>
@@ -10,9 +10,10 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Dirichlet.Numerics</RootNamespace>
     <AssemblyName>Dirichlet.Numerics</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -22,6 +23,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -30,6 +32,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -48,4 +51,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

Encrypt/Encrypt.csproj

@@ -0,0 +1,66 @@
+<?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)' == '' ">x86</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{DA9B09F3-A99D-4883-A954-537560453674}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Encrypt</RootNamespace>
+    <AssemblyName>Encrypt</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>Encrypt.Program</StartupObject>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <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="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.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>

Encrypt/Program.cs

@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Encrypt
+{
+    /// <summary>
+    /// See also:
+    /// https://www.fluxbytes.com/csharp/encrypt-and-decrypt-files-in-c/
+    /// </summary>
+    class Program
+    {
+        static byte[] key = new byte[] { 83, 254, 105, 64, 184, 201, 195, 127, 52, 99, 77, 45, 252, 132, 163, 156 };
+        static byte[] IV = new byte[] { 189, 23, 137, 56, 204, 241, 242, 118, 28, 89, 9, 198, 224, 111, 186, 125 };
+
+        static void Main(string[] args)
+        {
+            if ((args.Length < 1) || !File.Exists(args[0]))
+            {
+                Console.WriteLine("Usage:  Encode <file>");
+                Console.ReadKey();
+                return;
+            }
+
+            string fileName = args[0];
+            string intermediateFile = fileName + ".encrypted";   /// Intermediate file, output of cryptography encoding
+            string backupFile = fileName + ".bak";
+
+            try
+            {
+                using (StreamReader reader = new StreamReader(fileName))
+                {
+                    if (!reader.ReadLine().StartsWith("<?xml version="))
+                    {
+                        Console.WriteLine(string.Format("File {0} is already encrypted.", fileName));
+                        Console.ReadKey();
+                        return;
+                    }
+                }
+
+                bool successful = false;
+                using (RijndaelManaged aes = new RijndaelManaged { Padding = PaddingMode.Zeros })
+                {
+                    using (FileStream fsCrypt = new FileStream(intermediateFile, FileMode.Create))
+                    {
+                        using (ICryptoTransform encryptor = aes.CreateEncryptor(key, IV))
+                        {
+                            using (CryptoStream cs = new CryptoStream(fsCrypt, encryptor, CryptoStreamMode.Write))
+                            {
+                                using (FileStream fsIn = new FileStream(fileName, FileMode.Open))
+                                {
+                                    int data;
+                                    while ((data = fsIn.ReadByte()) != -1) cs.WriteByte((byte)data);
+                                    successful = true;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (successful)
+                {
+                    /// File encryption successfuly completed => rotate files
+                    if (File.Exists(backupFile)) File.Delete(backupFile);
+                    File.Move(fileName, backupFile);
+                    File.Move(intermediateFile, fileName);
+                    return;
+                }
+                else
+                {
+                    Failed(fileName, intermediateFile);
+                    return;
+                }
+            }
+            catch (Exception)
+            {
+                Failed(fileName, intermediateFile);
+                return;
+            }
+        }
+
+        static void Failed(string fileName, string toBeDeleted)
+        {
+            if (File.Exists(toBeDeleted))
+            {
+                File.Delete(toBeDeleted);
+            }
+            Console.WriteLine(string.Format("Encryption of file {0} failed.", fileName));
+            Console.ReadKey();
+        }
+    }
+}

Encrypt/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("Encrypt")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Encrypt")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[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("0f602531-6f1f-416e-af4d-9242855715a8")]
+
+// 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.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Encrypt/app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/></startup></configuration>

EventViewer/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>

EventViewer/EventViewer.csproj

@@ -0,0 +1,148 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{CF5BE6CD-A224-4B58-950D-14040E7A3C6A}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>EventViewer</RootNamespace>
+    <AssemblyName>EventViewer</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <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' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <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">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\FluentNHibernate.2.0.3.0\lib\net40\FluentNHibernate.dll</HintPath>
+    </Reference>
+    <Reference Include="Iesi.Collections, Version=4.0.0.0, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Iesi.Collections.4.0.0.4000\lib\net40\Iesi.Collections.dll</HintPath>
+    </Reference>
+    <Reference Include="MySql.Data">
+      <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">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\NHibernate.4.0.4.4000\lib\net40\NHibernate.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Security" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Deployment" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="EventViewerWnd.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="EventViewerWnd.Designer.cs">
+      <DependentUpon>EventViewerWnd.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\EventDetailsDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\EventDetailsDlg.Designer.cs">
+      <DependentUpon>EventDetailsDlg.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="LocalSettings.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Resources\Strings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
+    <EmbeddedResource Include="EventViewerWnd.resx">
+      <DependentUpon>EventViewerWnd.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\EventDetailsDlg.resx">
+      <DependentUpon>EventDetailsDlg.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>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <EmbeddedResource Include="Resources\Strings.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\Strings.sk.resx" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{c8939821-ba5c-4988-a3d0-bf53b74865c7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Events\Events.csproj">
+      <Project>{5d9b49e3-cdf9-4a27-80b4-58141d0eb0e0}</Project>
+      <Name>Events</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Users\Users.csproj">
+      <Project>{6e5cb0e9-e1b6-4e5d-ac6e-b1049e180f2b}</Project>
+      <Name>Users</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <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>

EventViewer/EventViewerWnd.Designer.cs

@@ -0,0 +1,186 @@
+namespace EventViewer
+{
+    partial class EventViewerWnd
+    {
+        /// <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.splitContainer1 = new System.Windows.Forms.SplitContainer();
+            this.userLoginButton = new System.Windows.Forms.Button();
+            this.eventsSelectionGroupBox = new System.Windows.Forms.GroupBox();
+            this.recentEventsRadioButton = new System.Windows.Forms.RadioButton();
+            this.unreadEventsRadioButton = new System.Windows.Forms.RadioButton();
+            this.allEventsRadioButton = new System.Windows.Forms.RadioButton();
+            this.settingsButton = new System.Windows.Forms.Button();
+            this.eventsListView = new Common.UIControls.ListViewEx();
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+            this.splitContainer1.Panel1.SuspendLayout();
+            this.splitContainer1.Panel2.SuspendLayout();
+            this.splitContainer1.SuspendLayout();
+            this.eventsSelectionGroupBox.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // splitContainer1
+            // 
+            this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel1;
+            this.splitContainer1.IsSplitterFixed = true;
+            this.splitContainer1.Location = new System.Drawing.Point(0, 0);
+            this.splitContainer1.Name = "splitContainer1";
+            this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal;
+            // 
+            // splitContainer1.Panel1
+            // 
+            this.splitContainer1.Panel1.Controls.Add(this.userLoginButton);
+            this.splitContainer1.Panel1.Controls.Add(this.eventsSelectionGroupBox);
+            this.splitContainer1.Panel1.Controls.Add(this.settingsButton);
+            // 
+            // splitContainer1.Panel2
+            // 
+            this.splitContainer1.Panel2.Controls.Add(this.eventsListView);
+            this.splitContainer1.Size = new System.Drawing.Size(863, 592);
+            this.splitContainer1.SplitterDistance = 100;
+            this.splitContainer1.TabIndex = 0;
+            // 
+            // userLoginButton
+            // 
+            this.userLoginButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+            this.userLoginButton.Location = new System.Drawing.Point(636, 17);
+            this.userLoginButton.Name = "userLoginButton";
+            this.userLoginButton.Size = new System.Drawing.Size(100, 37);
+            this.userLoginButton.TabIndex = 4;
+            this.userLoginButton.Text = "User login";
+            this.userLoginButton.UseVisualStyleBackColor = true;
+            this.userLoginButton.Click += new System.EventHandler(this.userLoginButton_Click);
+            // 
+            // eventsSelectionGroupBox
+            // 
+            this.eventsSelectionGroupBox.Controls.Add(this.recentEventsRadioButton);
+            this.eventsSelectionGroupBox.Controls.Add(this.unreadEventsRadioButton);
+            this.eventsSelectionGroupBox.Controls.Add(this.allEventsRadioButton);
+            this.eventsSelectionGroupBox.Location = new System.Drawing.Point(22, 5);
+            this.eventsSelectionGroupBox.Name = "eventsSelectionGroupBox";
+            this.eventsSelectionGroupBox.Size = new System.Drawing.Size(269, 92);
+            this.eventsSelectionGroupBox.TabIndex = 3;
+            this.eventsSelectionGroupBox.TabStop = false;
+            this.eventsSelectionGroupBox.Text = "Select events";
+            // 
+            // recentEventsRadioButton
+            // 
+            this.recentEventsRadioButton.AutoSize = true;
+            this.recentEventsRadioButton.Location = new System.Drawing.Point(24, 42);
+            this.recentEventsRadioButton.Name = "recentEventsRadioButton";
+            this.recentEventsRadioButton.Size = new System.Drawing.Size(95, 17);
+            this.recentEventsRadioButton.TabIndex = 1;
+            this.recentEventsRadioButton.TabStop = true;
+            this.recentEventsRadioButton.Text = "Recent events";
+            this.recentEventsRadioButton.UseVisualStyleBackColor = true;
+            this.recentEventsRadioButton.CheckedChanged += new System.EventHandler(this.recentEventsRadioButton_CheckedChanged);
+            // 
+            // unreadEventsRadioButton
+            // 
+            this.unreadEventsRadioButton.AutoSize = true;
+            this.unreadEventsRadioButton.Location = new System.Drawing.Point(24, 20);
+            this.unreadEventsRadioButton.Name = "unreadEventsRadioButton";
+            this.unreadEventsRadioButton.Size = new System.Drawing.Size(120, 17);
+            this.unreadEventsRadioButton.TabIndex = 0;
+            this.unreadEventsRadioButton.TabStop = true;
+            this.unreadEventsRadioButton.Text = "Unconfirmed events";
+            this.unreadEventsRadioButton.UseVisualStyleBackColor = true;
+            this.unreadEventsRadioButton.CheckedChanged += new System.EventHandler(this.unreadEventsRadioButton_CheckedChanged);
+            // 
+            // allEventsRadioButton
+            // 
+            this.allEventsRadioButton.AutoSize = true;
+            this.allEventsRadioButton.Location = new System.Drawing.Point(24, 64);
+            this.allEventsRadioButton.Name = "allEventsRadioButton";
+            this.allEventsRadioButton.Size = new System.Drawing.Size(71, 17);
+            this.allEventsRadioButton.TabIndex = 2;
+            this.allEventsRadioButton.TabStop = true;
+            this.allEventsRadioButton.Text = "All events";
+            this.allEventsRadioButton.UseVisualStyleBackColor = true;
+            this.allEventsRadioButton.CheckedChanged += new System.EventHandler(this.allEventsRadioButton_CheckedChanged);
+            // 
+            // settingsButton
+            // 
+            this.settingsButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+            this.settingsButton.Location = new System.Drawing.Point(748, 17);
+            this.settingsButton.Name = "settingsButton";
+            this.settingsButton.Size = new System.Drawing.Size(100, 37);
+            this.settingsButton.TabIndex = 0;
+            this.settingsButton.Text = "Settings";
+            this.settingsButton.UseVisualStyleBackColor = true;
+            this.settingsButton.Click += new System.EventHandler(this.settingsButton_Click);
+            // 
+            // eventsListView
+            // 
+            this.eventsListView.AllowColumnReorder = true;
+            this.eventsListView.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.eventsListView.DoubleClickActivation = false;
+            this.eventsListView.FullRowSelect = true;
+            this.eventsListView.GridLines = true;
+            this.eventsListView.Location = new System.Drawing.Point(0, 0);
+            this.eventsListView.Name = "eventsListView";
+            this.eventsListView.Size = new System.Drawing.Size(863, 488);
+            this.eventsListView.TabIndex = 0;
+            this.eventsListView.UseCompatibleStateImageBehavior = false;
+            this.eventsListView.View = System.Windows.Forms.View.Details;
+            this.eventsListView.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.eventsListView_ColumnClick);
+            this.eventsListView.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.eventsListView_MouseDoubleClick);
+            // 
+            // EventViewerWnd
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(863, 592);
+            this.Controls.Add(this.splitContainer1);
+            this.Name = "EventViewerWnd";
+            this.Text = "Event viewer";
+            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.EventViewerWnd_FormClosing);
+            this.Load += new System.EventHandler(this.EventViewerWnd_Load);
+            this.splitContainer1.Panel1.ResumeLayout(false);
+            this.splitContainer1.Panel2.ResumeLayout(false);
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
+            this.splitContainer1.ResumeLayout(false);
+            this.eventsSelectionGroupBox.ResumeLayout(false);
+            this.eventsSelectionGroupBox.PerformLayout();
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.SplitContainer splitContainer1;
+        private System.Windows.Forms.Button settingsButton;
+        private Common.UIControls.ListViewEx eventsListView;
+        private System.Windows.Forms.GroupBox eventsSelectionGroupBox;
+        private System.Windows.Forms.RadioButton unreadEventsRadioButton;
+        private System.Windows.Forms.RadioButton allEventsRadioButton;
+        private System.Windows.Forms.Button userLoginButton;
+        private System.Windows.Forms.RadioButton recentEventsRadioButton;
+    }
+}
+

EventViewer/EventViewerWnd.cs

@@ -0,0 +1,364 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using NHibernate;
+using Common.UIControls;
+using Events;
+using Events.Entities;
+using EventViewer.Resources;
+using System.Drawing;
+
+namespace EventViewer
+{
+    public partial class EventViewerWnd : Form
+    {
+        public const int Dpi100pct = 96;
+        int currentDpi;
+
+        enum Column
+        {
+            DateTime,
+            Bench,
+            Source,
+            Class,
+            Severity,
+            Message,
+            Count
+        }
+
+        ISession session;
+        IList<Subscriber> subscribers;
+        IList<Event> events;
+        SortOrder sortOrder = SortOrder.Ascending;
+        int sortColumn = -1;                        /// 0-based index of column to be used for sorting
+
+        EViewerOption eViewerOption;
+        string loginUserName;
+        string currentUser
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(loginUserName))
+                {
+                    return loginUserName;
+                }
+                else if (Program.LocalSettings != null && Program.LocalSettings.NonAnonymousAccess && !string.IsNullOrEmpty(Program.LocalSettings.UserName))
+                {
+                    return Program.LocalSettings.UserName;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// The following 3 private variables determine whether list of events is redrawn
+        EViewerOption lastEViewerOption;
+        string lastUser;
+        int lastRecentTimePeriodInDays;
+
+
+        public EventViewerWnd()
+        {
+            InitializeComponent();
+            loginUserName = null;
+            eViewerOption = string.IsNullOrEmpty(currentUser) ? EViewerOption.RecentEvents : EViewerOption.UnreadEvents;
+            lastEViewerOption = EViewerOption.Undefined;
+            lastRecentTimePeriodInDays = 0;
+            Localize();
+            currentDpi = (int)this.CreateGraphics().DpiX;
+            LocalSettings ls = Program.LocalSettings;
+            eventsListView.Columns.Add(Strings.Date_time, (ls.ColWid1 > 0) ? ls.ColWid1 :  80 * currentDpi / Dpi100pct);
+            eventsListView.Columns.Add(Strings.Bench,     (ls.ColWid2 > 0) ? ls.ColWid2 :  50 * currentDpi / Dpi100pct);
+            eventsListView.Columns.Add(Strings.Source,    (ls.ColWid3 > 0) ? ls.ColWid3 : 100 * currentDpi / Dpi100pct);
+            eventsListView.Columns.Add(Strings.Class,     (ls.ColWid4 > 0) ? ls.ColWid4 :  60 * currentDpi / Dpi100pct);
+            eventsListView.Columns.Add(Strings.Severity,  (ls.ColWid5 > 0) ? ls.ColWid5 :  70 * currentDpi / Dpi100pct);
+            eventsListView.Columns.Add(Strings.Message,   (ls.ColWid6 > 0) ? ls.ColWid6 : 500 * currentDpi / Dpi100pct);
+            LoadUISettings();
+        }
+
+        void Localize()
+        {
+            RedrawTitle();
+            eventsSelectionGroupBox.Text = Strings.Event_selection;
+            unreadEventsRadioButton.Text = Strings.Unread_events;
+            recentEventsRadioButton.Text = Strings.Recent_events;
+            allEventsRadioButton.Text = Strings.All_events;
+            settingsButton.Text = Strings.Settings;
+            userLoginButton.Text = Strings.User_login;
+        }
+
+        void RedrawTitle()
+        {
+            Text = string.Format("{0} {1} {2}", Strings.Event_viewer, Program.Version, !string.IsNullOrEmpty(currentUser) ? string.Format("({0})", currentUser) : string.Empty);
+        }
+
+        private void EventViewerWnd_Load(object sender, EventArgs e)
+        {
+            try
+            {
+                DB.DbType = DBType.MySql;
+                DB.ConnectionString = Program.LocalSettings.ConnectionString;
+                session = DB.CreateSession();
+                subscribers = session.QueryOver<Subscriber>().List();
+                unreadEventsRadioButton.Checked = true;
+            }
+            catch (Exception exc)
+            {
+                MessageBox.Show(string.Format("{0}{1}{2}", Strings.Cannot_connect_to_the_database, Environment.NewLine, exc.Message),
+                                Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+            }
+        }
+
+        private void unreadEventsRadioButton_CheckedChanged(object sender, EventArgs e)
+        {
+            if (unreadEventsRadioButton.Checked) eViewerOption = EViewerOption.UnreadEvents;
+            Redraw();
+        }
+
+        private void recentEventsRadioButton_CheckedChanged(object sender, EventArgs e)
+        {
+            if (recentEventsRadioButton.Checked) eViewerOption = EViewerOption.RecentEvents;
+            Redraw();
+        }
+
+        private void allEventsRadioButton_CheckedChanged(object sender, EventArgs e)
+        {
+            if (allEventsRadioButton.Checked) eViewerOption = EViewerOption.AllEvents;
+            Redraw();
+        }
+
+        /// <summary>
+        /// Redraw events
+        /// </summary>
+        /// <param name="allEvents">true = Display all events (also confirmed read)</param>
+        void Redraw(bool redrawAlways = false)
+        {
+            int days = Program.LocalSettings.RecentTimeDays;
+
+            if (!redrawAlways &&
+                lastEViewerOption == eViewerOption &&
+                lastUser == currentUser &&
+                lastRecentTimePeriodInDays == days)
+            {
+                return;     /// Do not redraw the list of events
+            }
+
+            try
+            {
+                if (eViewerOption == EViewerOption.AllEvents)
+                {
+                    /// Read all events
+                    events = session.QueryOver<Event>().List();
+                }
+                else if (eViewerOption == EViewerOption.RecentEvents)
+                {
+                    /// Read events from tha last 'recentTimePeriodInDays' days
+                    events = session.QueryOver<Event>()
+                                    .Where(e => (e.TimeStamp >= DateTime.Now - new TimeSpan(days, 0, 0, 0)))
+                                    .List();
+                }
+                else if (!string.IsNullOrEmpty(loginUserName))
+                {
+                    /// Read unread events of the specified user
+                    events = session.QueryOver<Event>()
+                                    .JoinQueryOver<Subscriber>(e => e.Subscribers)
+                                    .Where(s => (s.Name == string.Format("User_{0}", loginUserName)))
+                                    .List<Event>();
+                }
+                else
+                {
+                    /// Read unread events of all users
+                    events = session.QueryOver<Event>()
+                                    .JoinQueryOver<Subscriber>(e => e.Subscribers)
+                                    .List<Event>();
+
+                    for (int i = 0; i < events.Count; i++)
+                    {
+                        for (int j = events.Count - 1; j > i; j--)
+                        {
+                            if (events[i].Id == events[j].Id) events.RemoveAt(j);
+                        }
+                    }
+                }
+
+                eventsListView.Items.Clear();
+                foreach (var e in events) AddOne(e);
+
+                lastEViewerOption = eViewerOption;
+                lastUser = currentUser;
+                lastRecentTimePeriodInDays = days;
+            }
+            catch (Exception exc)
+            {
+                MessageBox.Show(string.Format("{0}{1}{2}", Strings.Cannot_connect_to_the_database, Environment.NewLine, exc.Message),
+                                Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+            }
+        }
+
+        void AddOne(Event evnt)
+        {
+            ListViewItem lvi = new ListViewItem(evnt.TimeStamp.ToString("dd.MM.yyyy HH:mm"));
+            lvi.Tag = evnt;
+            lvi.SubItems.Add(evnt.Bench);
+            lvi.SubItems.Add(evnt.Source);
+            lvi.SubItems.Add(evnt.EventClass.ToString());
+            {
+                lvi.UseItemStyleForSubItems = false;
+                lvi.SubItems.Add(evnt.Severity.ToString());
+                lvi.SubItems[lvi.SubItems.Count - 1].BackColor = Utils.GetSeverityColor(evnt.Severity);
+                lvi.SubItems[lvi.SubItems.Count - 1].ForeColor = Utils.GetSeverityColor(evnt.Severity, true);
+            }
+            lvi.SubItems.Add(evnt.Message);
+            eventsListView.Items.Add(lvi);
+        }
+
+        private void eventsListView_ColumnClick(object sender, ColumnClickEventArgs e)
+        {
+            if (e.Column == sortColumn)
+            {
+                sortOrder = (sortOrder == SortOrder.Ascending) ? SortOrder.Descending : SortOrder.Ascending;
+            }
+            else
+            {
+                /// Clicked on another column header => set sortOrder to SortOrder.Ascending
+                sortColumn = e.Column;
+                sortOrder = SortOrder.Ascending;
+            }
+
+            switch ((Column)sortColumn)
+            {
+                default:
+                case Column.DateTime:
+                    eventsListView.ListViewItemSorter = new LviDateTimeColumnComparer(sortColumn, sortOrder);
+                    break;
+                case Column.Bench:
+                case Column.Source:
+                case Column.Class:
+                case Column.Severity:
+                case Column.Message:
+                    eventsListView.ListViewItemSorter = new LviTextColumnComparer(sortColumn, sortOrder);
+                    break;
+            }
+
+            eventsListView.SetSortIcon(sortColumn, sortOrder);
+            eventsListView.Sort();
+        }
+
+        private void eventsListView_MouseDoubleClick(object sender, MouseEventArgs e)
+        {
+            if (eventsListView.SelectedIndices.Count != 1) return;
+            Event evnt = eventsListView.SelectedItems[0].Tag as Events.Entities.Event;
+            if (evnt == null) return;
+            bool enableConfirmReadButton = (session != null) && (eViewerOption == EViewerOption.UnreadEvents) && !string.IsNullOrEmpty(currentUser);
+
+            if ((new Forms.EventDetailsDlg(evnt, enableConfirmReadButton)).ShowDialog() == DialogResult.OK)
+            {
+                /// Reading selected event was confirmed => delete subscriber from this event.Subscribers
+                foreach (var s in subscribers)
+                {
+                    if (s.Name == string.Format("User_{0}", currentUser))
+                    {
+                        session.CreateSQLQuery(string.Format("DELETE FROM `eventsubscriber` WHERE Event_id = {0} AND Subscriber_id = {1};", evnt.Id, s.Id))
+                               .ExecuteUpdate();
+                        session.Flush();
+                        Redraw(true);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private void settingsButton_Click(object sender, EventArgs e)
+        {
+            //Users.Entities.GID[] groupsWithAccess = new Users.Entities.GID[] { Users.Entities.GID.Administrators };
+            Users.Forms.LoginDlg dlg = new Users.Forms.LoginDlg(true);
+            if (dlg.ShowDialog() == DialogResult.OK)
+            {
+                if ((new Forms.SettingsDlg()).ShowDialog() == DialogResult.OK)
+                {
+                    Close();
+                }
+            }
+        }
+
+        private void userLoginButton_Click(object sender, EventArgs e)
+        {
+            try
+            {
+                Users.GlobalData.RemoteUsersDB = new Users.DBSettings(Users.Entities.DBType.MySql, Program.LocalSettings.UsersDBConnString);
+                Users.Forms.LoginDlg dlg = new Users.Forms.LoginDlg();
+                if (dlg.ShowDialog() == DialogResult.OK)
+                {
+                    loginUserName = dlg.UserName;
+                    RedrawTitle();
+                    Redraw();
+                }
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        private void EventViewerWnd_FormClosing(object sender, FormClosingEventArgs e)
+        {
+            SaveUISettings();
+        }
+
+        private void LoadUISettings()
+        {
+            LocalSettings ls = Program.LocalSettings;
+            if (ls != null)
+            {
+                WindowState = (ls.WndMaximized ? FormWindowState.Maximized : FormWindowState.Normal);
+                Width = (ls.WndWidth > 0) ? ls.WndWidth : 800;
+                Height = (ls.WndHeight > 0) ? ls.WndHeight : 420;
+                Left = (ls.WndLeft != 0) ? ls.WndLeft : 150;
+                Top = (ls.WndTop != 0) ? ls.WndTop : 150;
+            }
+        }
+
+        private void SaveUISettings()
+        {
+            /// Obtain ProcedureDlg dimensions, etc.
+            bool isMaximized = (WindowState == FormWindowState.Maximized);
+            int left = (WindowState == FormWindowState.Normal) ? Location.X : RestoreBounds.Left;
+            int top = (WindowState == FormWindowState.Normal) ? Location.Y : RestoreBounds.Top;
+            int width = (WindowState == FormWindowState.Normal) ? Size.Width : RestoreBounds.Width;
+            int height = (WindowState == FormWindowState.Normal) ? Size.Height : RestoreBounds.Height;
+
+            LocalSettings ls = Program.LocalSettings;
+
+            if (ls != null && (ls.WndMaximized != isMaximized ||
+                               ls.WndLeft != left ||
+                               ls.WndTop != top ||
+                               ls.WndWidth != width ||
+                               ls.WndHeight != height ||
+                               ls.ColWid1 != eventsListView.Columns[0].Width ||
+                               ls.ColWid2 != eventsListView.Columns[1].Width ||
+                               ls.ColWid3 != eventsListView.Columns[2].Width ||
+                               ls.ColWid4 != eventsListView.Columns[3].Width ||
+                               ls.ColWid5 != eventsListView.Columns[4].Width ||
+                               ls.ColWid6 != eventsListView.Columns[5].Width))
+            {
+                /// At least one ProcedureDlg dimension differs => Update local settings and save them
+                ls.WndMaximized = isMaximized;
+                ls.WndLeft = left;
+                ls.WndTop = top;
+                ls.WndWidth = width;
+                ls.WndHeight = height;
+                ls.ColWid1 = eventsListView.Columns[0].Width;
+                ls.ColWid2 = eventsListView.Columns[1].Width;
+                ls.ColWid3 = eventsListView.Columns[2].Width;
+                ls.ColWid4 = eventsListView.Columns[3].Width;
+                ls.ColWid5 = eventsListView.Columns[4].Width;
+                ls.ColWid6 = eventsListView.Columns[5].Width;
+                ls.Save();
+            }
+        }
+    }
+}

EventViewer/Forms/EventDetailsDlg.Designer.cs

@@ -0,0 +1,232 @@
+namespace EventViewer.Forms
+{
+    partial class EventDetailsDlg
+    {
+        /// <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.label2 = new System.Windows.Forms.Label();
+            this.label3 = new System.Windows.Forms.Label();
+            this.label4 = new System.Windows.Forms.Label();
+            this.label5 = new System.Windows.Forms.Label();
+            this.label6 = new System.Windows.Forms.Label();
+            this.label7 = new System.Windows.Forms.Label();
+            this.textBox1 = new System.Windows.Forms.TextBox();
+            this.textBox2 = new System.Windows.Forms.TextBox();
+            this.textBox3 = new System.Windows.Forms.TextBox();
+            this.textBox4 = new System.Windows.Forms.TextBox();
+            this.textBox5 = new System.Windows.Forms.TextBox();
+            this.textBox6 = new System.Windows.Forms.TextBox();
+            this.textBox7 = new System.Windows.Forms.TextBox();
+            this.closeButton = new System.Windows.Forms.Button();
+            this.confirmReadButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(13, 17);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(35, 13);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "label1";
+            // 
+            // label2
+            // 
+            this.label2.AutoSize = true;
+            this.label2.Location = new System.Drawing.Point(13, 44);
+            this.label2.Name = "label2";
+            this.label2.Size = new System.Drawing.Size(35, 13);
+            this.label2.TabIndex = 1;
+            this.label2.Text = "label2";
+            // 
+            // label3
+            // 
+            this.label3.AutoSize = true;
+            this.label3.Location = new System.Drawing.Point(13, 71);
+            this.label3.Name = "label3";
+            this.label3.Size = new System.Drawing.Size(35, 13);
+            this.label3.TabIndex = 2;
+            this.label3.Text = "label3";
+            // 
+            // label4
+            // 
+            this.label4.AutoSize = true;
+            this.label4.Location = new System.Drawing.Point(13, 98);
+            this.label4.Name = "label4";
+            this.label4.Size = new System.Drawing.Size(35, 13);
+            this.label4.TabIndex = 3;
+            this.label4.Text = "label4";
+            // 
+            // label5
+            // 
+            this.label5.AutoSize = true;
+            this.label5.Location = new System.Drawing.Point(13, 125);
+            this.label5.Name = "label5";
+            this.label5.Size = new System.Drawing.Size(35, 13);
+            this.label5.TabIndex = 4;
+            this.label5.Text = "label5";
+            // 
+            // label6
+            // 
+            this.label6.AutoSize = true;
+            this.label6.Location = new System.Drawing.Point(13, 152);
+            this.label6.Name = "label6";
+            this.label6.Size = new System.Drawing.Size(35, 13);
+            this.label6.TabIndex = 5;
+            this.label6.Text = "label6";
+            // 
+            // label7
+            // 
+            this.label7.AutoSize = true;
+            this.label7.Location = new System.Drawing.Point(13, 199);
+            this.label7.Name = "label7";
+            this.label7.Size = new System.Drawing.Size(35, 13);
+            this.label7.TabIndex = 6;
+            this.label7.Text = "label7";
+            // 
+            // textBox1
+            // 
+            this.textBox1.Location = new System.Drawing.Point(96, 14);
+            this.textBox1.Name = "textBox1";
+            this.textBox1.Size = new System.Drawing.Size(138, 20);
+            this.textBox1.TabIndex = 7;
+            // 
+            // textBox2
+            // 
+            this.textBox2.Location = new System.Drawing.Point(96, 41);
+            this.textBox2.Name = "textBox2";
+            this.textBox2.Size = new System.Drawing.Size(138, 20);
+            this.textBox2.TabIndex = 8;
+            // 
+            // textBox3
+            // 
+            this.textBox3.Location = new System.Drawing.Point(96, 68);
+            this.textBox3.Name = "textBox3";
+            this.textBox3.Size = new System.Drawing.Size(138, 20);
+            this.textBox3.TabIndex = 9;
+            // 
+            // textBox4
+            // 
+            this.textBox4.Location = new System.Drawing.Point(96, 95);
+            this.textBox4.Name = "textBox4";
+            this.textBox4.Size = new System.Drawing.Size(138, 20);
+            this.textBox4.TabIndex = 10;
+            // 
+            // textBox5
+            // 
+            this.textBox5.Location = new System.Drawing.Point(96, 122);
+            this.textBox5.Name = "textBox5";
+            this.textBox5.Size = new System.Drawing.Size(138, 20);
+            this.textBox5.TabIndex = 11;
+            // 
+            // textBox6
+            // 
+            this.textBox6.Location = new System.Drawing.Point(96, 149);
+            this.textBox6.Multiline = true;
+            this.textBox6.Name = "textBox6";
+            this.textBox6.Size = new System.Drawing.Size(538, 40);
+            this.textBox6.TabIndex = 12;
+            // 
+            // textBox7
+            // 
+            this.textBox7.Location = new System.Drawing.Point(96, 196);
+            this.textBox7.Multiline = true;
+            this.textBox7.Name = "textBox7";
+            this.textBox7.Size = new System.Drawing.Size(538, 60);
+            this.textBox7.TabIndex = 13;
+            // 
+            // closeButton
+            // 
+            this.closeButton.Location = new System.Drawing.Point(531, 14);
+            this.closeButton.Name = "closeButton";
+            this.closeButton.Size = new System.Drawing.Size(103, 35);
+            this.closeButton.TabIndex = 14;
+            this.closeButton.Text = "Close";
+            this.closeButton.UseVisualStyleBackColor = true;
+            this.closeButton.Click += new System.EventHandler(this.closeButton_Click);
+            // 
+            // confirmReadButton
+            // 
+            this.confirmReadButton.Location = new System.Drawing.Point(531, 55);
+            this.confirmReadButton.Name = "confirmReadButton";
+            this.confirmReadButton.Size = new System.Drawing.Size(103, 35);
+            this.confirmReadButton.TabIndex = 15;
+            this.confirmReadButton.Text = "Confirm read";
+            this.confirmReadButton.UseVisualStyleBackColor = true;
+            this.confirmReadButton.Click += new System.EventHandler(this.confirmReadButton_Click);
+            // 
+            // EventDetailsDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(651, 267);
+            this.Controls.Add(this.confirmReadButton);
+            this.Controls.Add(this.closeButton);
+            this.Controls.Add(this.textBox7);
+            this.Controls.Add(this.textBox6);
+            this.Controls.Add(this.textBox5);
+            this.Controls.Add(this.textBox4);
+            this.Controls.Add(this.textBox3);
+            this.Controls.Add(this.textBox2);
+            this.Controls.Add(this.textBox1);
+            this.Controls.Add(this.label7);
+            this.Controls.Add(this.label6);
+            this.Controls.Add(this.label5);
+            this.Controls.Add(this.label4);
+            this.Controls.Add(this.label3);
+            this.Controls.Add(this.label2);
+            this.Controls.Add(this.label1);
+            this.Name = "EventDetailsDlg";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "Event details";
+            this.Load += new System.EventHandler(this.EventDetailsDlg_Load);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.Label label2;
+        private System.Windows.Forms.Label label3;
+        private System.Windows.Forms.Label label4;
+        private System.Windows.Forms.Label label5;
+        private System.Windows.Forms.Label label6;
+        private System.Windows.Forms.Label label7;
+        private System.Windows.Forms.TextBox textBox1;
+        private System.Windows.Forms.TextBox textBox2;
+        private System.Windows.Forms.TextBox textBox3;
+        private System.Windows.Forms.TextBox textBox4;
+        private System.Windows.Forms.TextBox textBox5;
+        private System.Windows.Forms.TextBox textBox6;
+        private System.Windows.Forms.TextBox textBox7;
+        private System.Windows.Forms.Button closeButton;
+        private System.Windows.Forms.Button confirmReadButton;
+    }
+}