Add CJMS11 enhancements, logging, and resolution support

- Extended CJMS11 camera handling with new functionalities, including image grabbing, resolution configuration, and improved ROI support.
- Added new `ToString` method implementations for enhanced debugging and logging in key classes like `JmsMessage`, `JmsPacket`, and `RoiCfg`.
- Introduced additional commands (`start_stream_images`, `stop_stream_images`) in `CommandM` and its enum.
- Implemented new resolution handling in `RoiCfg` with support for configurable image frames.
- Refactored resolution-related UI elements in `RoiCfgCtrl` to add a dropdown for selecting resolution.
- Made minor UX improvements by replacing inconsistent string formats with verbatim strings in console messages.
- Updated project dependencies with new resolution-related utilities (`Frame` and `ResolutionFrames`).
- Resolved camera-specific symbolic issues by transitioning to `CJMS11.Camera` over prior naming inconsistencies.

.gitattributes

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

.gitignore

@@ -1,13 +1,82 @@
+Common/bin/
+Common/obj/
 Config/bin/
 Config/obj/
+DataMatrix4Net/bin/
+DataMatrix4Net/obj/
+DataStreamInterface/bin/
+DataStreamInterface/obj/
+Decrypt/bin/
+Decrypt/obj/
+DeviceTest/bin/
+DeviceTest/obj/
+Dirichlet.Numerics/bin
+Dirichlet.Numerics/obj
+Encrypt/bin/
+Encrypt/obj/
+EventViewer/bin/
+EventViewer/obj/
+FeatureVectorCalculator/bin/
+FeatureVectorCalculator/obj/
+GemCard/bin/
+GemCard/obj/
+GenCode128/bin/
+GenCode128/obj/
+GenericTest/bin/
+GenericTest/obj/
+GraphLib/bin/
+GraphLib/obj/
+LabelPrinting/bin/
+LabelPrinting/obj/
+MergeResultsDBs/bin/
+MergeResultsDBs/obj/
+OrderManagement/bin/
+OrderManagement/obj/
+ProductionTracing/bin/
+ProductionTracing/obj/
+RecordProcessing/bin/
+RecordProcessing/obj/
+ResetBatchNr/bin/
+ResetBatchNr/obj/
+RestClient/bin/
+RestClient/obj/
 Results/bin/
 Results/obj/
 ResultsBrowser/bin/
 ResultsBrowser/obj/
-TestBenchFramework/bin/
-TestBenchFramework/obj/
-TBFSetup/Debug/
-TBFSetup/Release/
-Doc/
+ResultsParser/bin/
+ResultsParser/obj/
+S640TestApp/bin/
+S640TestApp/obj/
+SharedDatabase/bin
+SharedDatabase/obj
+SchematicDrawing/bin
+SchematicDrawing/obj
+Statistics/bin/
+Statistics/obj/
+TBF/bin/
+TBF/obj/
+ToFirstMonitor/bin/
+ToFirstMonitor/obj/
+ToSecondMonitor/bin/
+ToSecondMonitor/obj/
+UserManagement/bin/
+UserManagement/obj/
+WorkflowConfigurator/bin/
+WorkflowConfigurator/obj/
+Workplace/bin/
+Workplace/obj/
+DataStreamInterfaceTest/bin/
+DataStreamInterfaceTest/obj/
+DataStreamMeter/bin/
+DataStreamMeter/obj/
+Events/bin/
+Events/obj/
+TracingDB/bin/
+TracingDB/obj/
+Users/bin/
+Users/obj/
+.vs/
+.idea/
 *.suo
 *.bak

Common/BackgroundBeep.cs

@@ -0,0 +1,37 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Threading;
+
+namespace Common
+{
+    public class BackgroundBeep
+    {
+        static Thread beepThread;
+        static AutoResetEvent signalBeep;
+
+        static BackgroundBeep()
+        {
+            signalBeep = new AutoResetEvent(false);
+            beepThread = new Thread(() =>
+            {
+                while (true)
+                {
+                    signalBeep.WaitOne();       /// waits for an event
+                    Console.Beep(500, 400);     /// frequency (Hz), duration (ms)
+                }
+            }, 1);
+            beepThread.IsBackground = true;
+            beepThread.Start();
+        }
+
+        /// <summary>
+        /// Invokes one beep in a separate thread (non-blocking function)
+        /// </summary>
+        public static void Beep()
+        {
+            signalBeep.Set();
+        }
+    }
+}

Common/Common.csproj

@@ -0,0 +1,110 @@
+<?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>TRACE;DEBUG</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="log4net, Version=2.0.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\packages\log4net.2.0.15\lib\net45\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BackgroundBeep.cs" />
+    <Compile Include="DatabaseSettings.cs" />
+    <Compile Include="DBSettings.cs" />
+    <Compile Include="Enums.cs" />
+    <Compile Include="Forms\ListViewEx.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Forms\ListViewExtensions.cs" />
+    <Compile Include="Forms\LviDateTimeColumnComparer.cs" />
+    <Compile Include="Forms\LviIntColumnComparer.cs" />
+    <Compile Include="Forms\LviNameSurnameColumnComparer.cs" />
+    <Compile Include="Forms\LviTextColumnComparer.cs" />
+    <Compile Include="Forms\MessageEventArgs.cs" />
+    <Compile Include="Forms\ModelessForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\ModelessForm.designer.cs">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Formulas.cs" />
+    <Compile Include="CurrentUser.cs" />
+    <Compile Include="GlobalData.cs" />
+    <Compile Include="IMeasurementCorrection.cs" />
+    <Compile Include="IOrderInfo.cs" />
+    <Compile Include="IParamsProvider.cs" />
+    <Compile Include="Iperl\OptoTelegramRaw.cs" />
+    <Compile Include="IUncertainty.cs" />
+    <Compile Include="IUser.cs" />
+    <Compile Include="Printers\PrintersCommon.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="QuitAppException.cs" />
+    <Compile Include="SerializableDictionary.cs" />
+    <Compile Include="StatisticalMetrics.cs" />
+    <Compile Include="Telegram.cs" />
+    <Compile Include="UIControls\CoolButtonCtrl.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="UIControls\CoolButtonCtrl.Designer.cs">
+      <DependentUpon>CoolButtonCtrl.cs</DependentUpon>
+    </Compile>
+    <Compile Include="UIControls\RoundedRectangle.cs" />
+    <Compile Include="Units.cs" />
+    <Compile Include="Utils.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <EmbeddedResource Include="Forms\ListViewEx.resx">
+      <DependentUpon>ListViewEx.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\ModelessForm.resx">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </EmbeddedResource>
+  </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/CurrentUser.cs

@@ -0,0 +1,132 @@
+///
+/// Copyright (c) 2021-2022 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+
+namespace Common
+{
+    class UserAndForm
+    {
+        public readonly IUser User;
+        public readonly Form Form;
+
+        public UserAndForm(IUser user, Form form)
+        {
+            User = user;
+            Form = form;
+        }
+    }
+
+    public static class CurrentUser
+    {
+        public const string AdminUsername = "admin";
+        public const string AdminPassword = "staratura";
+
+        public static int MinPasswdLength = 0;
+        public static int PasswdExpirationPeriodDays = 0; 
+
+        public static DBSettings RemoteUsersDB = null;
+		public static DBSettings LocalUsersDB = null;
+
+
+        static readonly Stack<UserAndForm> userStack = new Stack<UserAndForm>();
+
+        public static Common.AuthorizedAs AuthorizedAs;
+        public static DateTime LastAuthorization = DateTime.Now;
+
+
+        /// <summary>
+        /// Push a new user into the stack of users and form references.
+        /// Prevent double user stack entry for the same Windows form.
+        /// </summary>
+        /// <param name="newUser">New user</param>
+        /// <param name="currentForm">Reference to the current form</param>
+        public static void Change(IUser newUser, Form currentForm)
+        {
+            if (userStack.Count > 0 && userStack.Peek().Form == currentForm)
+            {
+                userStack.Pop();
+            }
+
+            userStack.Push(new UserAndForm(newUser, currentForm));
+        }
+
+        /// <summary>
+        /// Restore an original user from the stack of users - remove user at the top of the stack.
+        /// Prevent restoring when there is no entry for the form currently being closed.
+        /// </summary>
+        /// <param name="formBeingClosed">Reference to the form currently being closed</param>
+        /// <returns>true = current user was restored, false = no current user change</returns>
+        public static bool Restore(Form formBeingClosed)
+        {
+            if (userStack.Count > 0 && userStack.Peek().Form == formBeingClosed)
+            {
+                userStack.Pop();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Return the user currenty at the top of the stack of users.
+        /// </summary>
+        public static IUser User()
+        {
+            return (userStack.Count > 0) ? userStack.Peek().User : null;    /// TODO: Return default user when stack is empty
+        }
+
+        public static IUser User2;
+        public static IUser User3;
+
+        /// <summary>
+        /// Return the current user name or an empty string
+        /// </summary>
+        public static string UserName()
+        {
+            if (User() == null || User().UserName == null)
+                return string.Empty;
+            else if (User2 == null || User2.UserName == null)
+                return User().UserName;
+            else if (User3 == null || User3.UserName == null)
+                return string.Format("{0},{1}", User().UserName, User2.UserName);
+            else
+                return string.Format("{0},{1},{2}", User().UserName, User2.UserName, User3.UserName);
+        }
+
+        public static string GetEncodedString(string legalizator)
+        {
+            if (User() == null || User().UserName == null) return string.Empty;
+            return string.Format("{0}~{1}~{2}",
+                                 User().UserName,
+                                 User().FullName == null ? string.Empty : User().FullName,
+                                 legalizator == null ? string.Empty : legalizator);
+        }
+                
+
+        /// <summary>
+        /// Return the current user number or 0
+        /// </summary>
+        public static int Number()
+        {
+            return (User() != null) ? User().Number : 0;
+        }
+
+        public static bool IsPowerUser()
+        {
+            return (User() != null) ? User().IsPowerUser() : false;
+        }
+
+        public static bool IsMemberOf(GID groupId)
+        {
+            return (User() != null) ? User().IsMemberOf(groupId) : false;
+        }
+
+        public static bool IsMemberOf(GID[] groupIds)
+        {
+            return (User() != null) ? User().IsMemberOf(groupIds) : (groupIds == null);
+        }
+    }
+}

Common/DBSettings.cs

@@ -0,0 +1,31 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common
+{
+	/// <summary>
+	/// Database settings required to make a connection
+	/// </summary>
+	public class DBSettings : ICloneable
+	{
+		public DBType DbType;
+		public string ConnectionString;
+
+		public DBSettings()
+		{
+		}
+
+		public DBSettings(DBType dbType, string connectionString)
+		{
+			this.DbType = dbType;
+			this.ConnectionString = connectionString;
+		}
+
+		public object Clone()
+		{
+			return new DBSettings(DbType, ConnectionString);
+		}
+	}
+}

Common/DatabaseSettings.cs

@@ -0,0 +1,121 @@
+///
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace Common
+{
+    /// <summary>
+    /// Test bench database settings, contains bench name and settings od several databases
+    /// </summary>
+    public class DatabaseSettings : ICloneable, IComparable
+    {
+        // Public fields
+        public string BenchName;
+        public bool IsRealBench;
+        public DBSettings ProceduresDBSettings;	/// Configuration database settings
+        public DBSettings WaterMetersDBSettings;	/// Results database settings
+        public DBSettings EventsDBSettings;	    /// Events database settings
+        public DBSettings UsersDBSettings;		/// Shared configuration database settings
+
+        // Constructor
+        public DatabaseSettings()
+        {
+            BenchName = String.Empty;               /// Empty string (avoid null)
+            IsRealBench = false;
+			ProceduresDBSettings  = new DBSettings(DBType.MySql, string.Empty);
+			WaterMetersDBSettings = new DBSettings(DBType.MySql, string.Empty);
+            EventsDBSettings      = new DBSettings(DBType.MySql, string.Empty);
+			UsersDBSettings       = new DBSettings(DBType.MySql, string.Empty);
+        }
+
+        public object Clone()
+        {
+            DatabaseSettings result = new DatabaseSettings();
+
+            result.BenchName    = BenchName;
+            result.IsRealBench  = IsRealBench;
+            result.ProceduresDBSettings = (DBSettings)ProceduresDBSettings.Clone();
+            result.WaterMetersDBSettings = (DBSettings)WaterMetersDBSettings.Clone();
+            result.EventsDBSettings = (DBSettings)EventsDBSettings.Clone();
+            result.UsersDBSettings = (DBSettings)UsersDBSettings.Clone();
+
+            return result;
+        }
+
+        public int CompareTo(object dbs2)
+        {
+            if (!(dbs2 is DatabaseSettings)) return 0;
+            return String.Compare(BenchName, (dbs2 as DatabaseSettings).BenchName);
+        }
+
+
+        /// <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;
+        }
+
+
+		public override string ToString()
+		{
+            return string.Format("{0} config={1} results={2} events={3} users={4}",
+                                 BenchName,
+                                 ProceduresDBSettings.ConnectionString,
+                                 WaterMetersDBSettings.ConnectionString,
+                                 EventsDBSettings.ConnectionString,
+                                 UsersDBSettings.ConnectionString);
+		}
+    }
+}

Common/Enums.cs

@@ -0,0 +1,871 @@
+///
+/// Copyright (c) 2013-2023 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Common
+{
+    /// <summary>
+    /// Helper class to assign descriptions to enum values
+    /// </summary>
+    public class Description : Attribute
+    {
+        public string Text;
+        public Description(string t)
+        {
+            Text = t;
+        }
+    }
+
+    public static class GetDescription
+    {
+        /// Extension method for enum-s
+        public static string ToDescription(this Enum en)
+        {
+            Type type = en.GetType();
+            MemberInfo[] memInfo = type.GetMember(en.ToString());
+
+            if (memInfo != null && memInfo.Length > 0)
+            {
+                object[] attrs = memInfo[0].GetCustomAttributes(typeof(Description), false);
+                if (attrs != null && attrs.Length > 0)
+                    return ((Description)attrs[0]).Text;
+            }
+
+            return en.ToString();   /// Return ToString() value in case there is no description
+        }
+    }
+
+    /// <summary>
+    /// Identifies the type of a database
+    /// </summary>
+    public enum DBType
+    {
+        None,               /// Database disabled
+        MySql,              /// MySQL database
+        SQLite,             /// SQLite
+        Count
+    }
+
+    /// <summary> Identifies the database based on the content </summary>
+    public enum DBKind
+    {
+        Config,
+        Results,
+        RemoteConfig,
+        Count
+    }
+
+    public enum ProcedureSelection
+    {
+#if LANG_CS
+        [Description("Žádné")]                          None,
+        [Description("Lokální postupy")]                FromLocalDB,
+        [Description("Postupy ze sdílené databázy")]    FromSharedDB,
+        [Description("Zakázky z Oracle databázy")]      OrderNrFromOracleDB,
+        [Description("Zakázky ze sledovací databázy")]  OrderNrFromTracingDB,
+#else
+        [Description("None")]                           None,
+        [Description("Local procedures")]               FromLocalDB,
+        [Description("Shared procedures")]              FromSharedDB,
+        [Description("Orders from Oracle DB")]          OrderFromOracleDB,
+        [Description("Orders from Tracing DB")]         OrderFromTracingDB,
+#endif
+        Count
+    }
+
+    public enum LoginMethod
+    {
+        UserName,		/// = alias, abbreviation
+        FullName,		/// = description
+        Number,
+        Count
+    }
+
+    public enum AuthorizedAs
+    {
+        PowerUser,
+        LocalUser,
+        RemoteUser,
+        Count
+    }
+
+    /// <summary>
+    /// GID-s of user groups, each user is member of one or more groups.
+    /// </summary>
+    public enum GID
+    {
+        Testers,
+        TestingSpecialists,
+        HeadOfLab,
+        MaintenanceSpecialists,
+        Metrologists,
+        CalibrationSpecialists,
+        Administrators,             /// application / network / database administrator
+        TraceabilityManagement,
+        MetrologicalAuthority,
+        WaterMeterAuthority,
+        NrOfGroups,                 /// Number of groups (this is not a GroupID)
+        None,
+    }
+
+    public enum MySortOrder
+    {
+        None,
+        Ascending,      /// The same like SortOrder.Ascending
+        Descending,     /// The same like SortOrder.Descending
+        Ascending2,     /// Sorts by a surname in ascending order in case or 'Name Surname' column
+        Descending2,    /// Sorts by a surname in descending order in case or 'Name Surname' column
+    }
+
+    /// <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 
+    }
+
+    /// <summary>
+    /// Event severity
+    /// </summary>
+    public enum Severity
+    {
+        Undefined,
+        Notification,
+        Warning,
+        Error,
+        FatalError,
+        Count
+    }
+
+    public enum EventClass
+    {
+        Undefined,
+        EquipmentHW,
+        Metrology,
+        TestingProcess,
+        BadResults,
+        ComputerResources,
+        Network,
+        Other,
+        Count
+    }
+
+    public enum SubscriberGroup : long
+    {
+        None = 0,
+        Metrology = 1,
+        Maintenance = 2,
+        Production = 4,
+        Management = 8,
+        Finish = 16,
+    }
+
+    public enum EViewerOption
+    {
+        Undefined,
+        AllEvents,
+        RecentEvents,
+        UnreadEvents,
+    }
+
+    public enum ProcedureState
+	{
+		Active,
+		History,
+		Count,
+	}
+
+    public enum FlowNames
+    {
+        QnQtQmin = 0,
+        Q3Q2Q1 = 1,
+        QpQi = 2,
+        Count,
+    }
+
+    public enum ProfileType
+    {
+        Q3R,
+        QnClassColdWater,
+        QnClassHotWater,
+        QpQi,
+        CompoundQ3RQ3R,
+        CompoundQnClassQnClass,
+        CompoundQ3RQnClass,
+        CompoundQnClassQ3R,
+        CompoundQpQiQpQi,
+        Manual,
+        Count,
+    }
+
+    public enum FlowId
+    {
+        Any,
+        Q4,
+        Q3,
+        Q2,
+        Q1,
+        Q4Main,
+        Q3Main,
+        Q2Main,
+        Q1Main,
+        Q4Aux,
+        Q3Aux,
+        Q2Aux,
+        Q1Aux,
+        Qmax,
+        Qn,
+        Qt,
+        Qmin,
+        QmaxMain,
+        QnMain,
+        QtMain,
+        QminMain,
+        QmaxAux,
+        QnAux,
+        QtAux,
+        QminAux,
+        Qp,
+        Qp10,
+        Qi,
+        QpMain,
+        Qp10Main,
+        QiMain,
+        QpAux,
+        Qp10Aux,
+        QiAux,
+        Qdetected,
+        Qfall,
+        Qrise,
+    }
+
+    public enum ErrorLimitType
+    {
+        Manual,
+        QpClass,
+        Count,
+    }
+
+	/// <summary> Kind of meters for the procedure / test </summary>
+	public enum MetersKind
+	{
+#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
+	{
+		Single,
+		CompoundMain,
+		CompoundAux,
+		Compound,
+		HeatMeterVolume,
+		HeatMeterEnergy,
+		SingleOrCompound,		/// Only used when querying results
+	}
+
+	public enum Medium
+	{
+        [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("H")]      H,         /// horizontal
+        [Description("V")]      V,         /// vertical
+        [Description("STR")]    S,         /// standrohre
+        [Description("F")]      F,         /// fall
+        [Description("H/V")]    HV,        /// horizontal / vertical
+#else
+        [Description("H")]      H,         /// horizontal
+        [Description("V")]      V,         /// vertical
+        [Description("S")]      S,         /// steig
+        [Description("F")]      F,         /// fall
+        [Description("H/V")]    HV,        /// horizontal / vertical
+#endif
+		Count
+    }
+
+    public enum TemperatureClass
+    {
+        [Description("")]        NotSpecified,
+        [Description("T30")]     T30,
+        [Description("T50")]     T50,
+        [Description("T70")]     T70,
+        [Description("T90")]     T90,
+        [Description("T130")]    T130,
+        [Description("T180")]    T180,
+        [Description("T30/70")]  T30_70,
+        [Description("T30/90")]  T30_90,
+        [Description("T30/130")] T30_130,
+        [Description("T30/180")] T30_180,
+        [Description("30")]      t30,
+        [Description("50")]      t50,
+        [Description("70")]      t70,
+        [Description("90")]      t90,
+        [Description("130")]     t130,
+        [Description("180")]     t180,
+        Count
+    }
+
+    public enum FlowProfileSensitivityClass
+    {
+        [Description("")]   NotSpecified,
+        [Description("U0")] U0,              /// ?
+        [Description("D0")] D0,              /// ?
+        Count
+    }
+
+    public enum PressureLossClass
+    {
+        [Description("")]     NotSpecified,
+        [Description("dp63")] dp63,           /// 0.063 MPa = 0.63 bar, TODO: Change to "Δp63"
+        [Description("dp40")] dp40,           /// 0.040 MPa = 0.40 bar
+        [Description("dp25")] dp25,           /// 0.025 MPa = 0.25 bar
+        [Description("dp16")] dp16,           /// 0.016 MPa = 0.16 bar
+        [Description("dp10")] dp10,           /// 0.010 MPa = 0.10 bar
+        Count
+    }
+
+    /// <summary> Maximum Admissible Pressure </summary>
+    public enum MaxAdmissiblePressure
+    {
+        [Description("")]      NotSpecified,
+        [Description("MAP6")]  MAP6,
+        [Description("MAP10")] MAP10,
+        [Description("MAP16")] MAP16,
+        [Description("MAP25")] MAP25,
+        [Description("MAP40")] MAP40,
+        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
+	{
+		None,
+		Scale1Empty,
+		Scale2Empty,
+		Scale3Empty,
+		AllScalesEmpty,
+		Count
+	}
+
+    /// <summary>
+    /// State of water filled in the test bench.
+    /// </summary>
+    public enum FillState
+    {
+        Unknown,            /// Test bench fill state is unknown
+        Empty,              /// Test bench is empty, no water
+        Full,               /// Test bench is full of water
+        Count
+    }
+
+    public enum MeretProtocol
+    {
+        [Description("<undefined>")]        Undefined,
+        [Description("Meret (obsolete)")]   Meret,
+        [Description("Modbus")]             Modbus,
+        Count
+    }
+
+	public enum Publish : sbyte
+	{
+#if LANG_DE
+        /// 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
+        /// czech
+        [Description("nikdy")]        Never = 0,
+        [Description("vždy")]         Always = 1,
+        [Description("na obrazovku")] OnScreen = 2,
+        [Description("interně")]      Internal = 3,
+#elif LANG_SK
+        /// slovak
+        [Description("nikdy")]        Never = 0,
+        [Description("vždy")]         Always = 1,
+        [Description("na obrazovku")] OnScreen = 2,
+        [Description("interne")]      Internal = 3,
+#elif LANG_PL
+        /// 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
+		/// english
+		[Description("Never")]        Never = 0,
+        [Description("Always")]       Always = 1,
+        [Description("On screen")]    OnScreen = 2,
+        [Description("Internal")]     Internal = 3,
+#endif
+        Count
+	}
+
+	public enum MassMethod : byte
+	{
+#if LANG_DE
+        /// nemecky
+		[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,
+		[Description("max.rozdíl")]		Spread,
+		[Description("std.dev.")]		StdDev,
+#else
+		[Description("Scale")]			Scale,
+		[Description("Spread")]			Spread,
+		[Description("Std.dev.")]		StdDev,
+#endif
+        Count
+	}
+
+    /// <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
+    {
+#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 TestProfile
+    {
+        UserDefined,
+        UserDefinedCompound,
+        UserDefinedHeatMeter,
+        Protected,                  /// The first protected one
+        ProtectedCompound,
+        ProtectedHeatMeter,
+    }
+
+	public enum Progress
+	{
+		JustStarted,
+        TransitionBefore,
+		SwitchingFlowDetection,
+		FlowSetting,
+        Aborted,                /// Use as an argument when a test was aborted
+        Test,
+		TransitionAfter,
+		Completed,
+		Count,
+	}
+
+	public enum Device
+	{
+		Screen,
+		Printer,
+		Disk,
+	}
+
+	public enum PageOrientation
+	{
+		Portrait,
+		Landscape,
+		Count,
+	}
+
+	public enum ItemCategory
+	{
+#if LANG_DE
+		[Description("Allgemein")]				Other,
+		[Description("Prüfstanddaten")]			BenchData,
+		[Description("Prüfstandergebnisse")]	BenchResult,
+		[Description("Prüfpunktdaten")]			TestData,
+		[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,
+		[Description("Bench result")]	BenchResult,
+		[Description("Test data")]		TestData,
+		[Description("Test result")]	TestResult,
+		[Description("Meter data")]		MeterData,
+		[Description("Meter result")]	MeterResult,
+#endif
+        Count,
+	}
+
+	/// <summary> Possible modes of operation of components and devices. </summary>
+	public enum DebugMode
+	{
+#if LANG_DE
+		[Description("Erkennen-aus")]	DetectedOff = -2,
+        [Description("Erkennen-ein")]	DetectedOn = -1,
+        [Description("Normal")]         Normal = 0,				/// Normal operation
+        [Description("Auto-erkennen")]  AutoDetect,				/// The component (device) will be auto-detected
+        [Description("Fehler")]         FailureDuringOperation,	/// Failure during operation -> disabled 
+        [Description("Aus")]            Off,					/// The component is off
+        [Description("Aufzeichnen")]    Record,
+        [Description("Abspielen")]      Replay,
+        [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")]                           Replay,
+        [Description("Simuler")]                            Simulate,
+        [Description("Hériter")]                            Inherit,
+#else
+        [Description("Detected off")]   DetectedOff = -2,
+        [Description("Detected on")]    DetectedOn = -1,
+        [Description("Normal")]         Normal = 0,				/// Normal operation
+        [Description("Auto detect")]    AutoDetect,				/// The component (device) will be auto-detected
+        [Description("Run-time error")] FailureDuringOperation,	/// Failure during operation -> disabled 
+        [Description("Off")]            Off,					/// The component is off
+        [Description("Record")]         Record,
+        [Description("Replay")]         Replay,
+        [Description("Simulate")]       Simulate,				/// Test bench simulation, this mode does not require any hardware
+        [Description("Inherit")]        Inherit,
+#endif
+        Count,
+    }
+
+    public enum LogLevel
+	{
+#if LANG_DE
+		[Description("Aus")]			Off,
+		[Description("Schwerwiegend")]	Fatal,
+        [Description("Fehler")]			Error,
+		[Description("Warnung")]		Warn,
+        [Description("Info")]			Info,
+        [Description("Debug")]			Debug,
+        [Description("Alles")]			All,
+#else
+        [Description("Off")]    Off,
+        [Description("Fatal")]  Fatal,
+        [Description("Error")]  Error,
+        [Description("Warn")]   Warn,
+        [Description("Info")]   Info,
+        [Description("Debug")]  Debug,
+        [Description("All")]    All,
+#endif
+        Count,
+    }
+
+
+	/// <summary> Arrangement of tests </summary>
+	public enum TestsArrangement
+	{
+		Rows,
+		Columns,
+	}
+
+	/// <summary> Arrangement of meters </summary>
+	public enum MetersArrangement
+	{
+		Vertically,
+		Horizontally,
+	}
+
+    public enum Alignment
+	{
+#if LANG_DE
+		[Description("links")]      Left,
+        [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,
+        [Description("Right")]      Right,
+        [Description("Justified")]  Justified,
+#endif
+        Count
+    }
+
+    public enum VertAlignment
+    {
+        [Description("Top")]        Top,
+        [Description("Middle")]     Middle,
+        [Description("Bottom")]     Bottom,
+    }
+
+    public enum TableForm
+    {
+        None,
+        Rows,
+        Columns,
+        ColumnsPL,
+        Count,
+    }
+
+    public enum DivResolution : int
+    {
+        [Description("1 ms (0.25 s)")]  _1ms = 0,
+        [Description("2 ms (0.5 s)")]   _2ms = 1,
+        [Description("4 ms (1 s)")]     _4ms = 2,
+        [Description("8 ms (2 s)")]     _8ms = 3,
+        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,
+		[Description("stopp")]		Stop,
+#elif LANG_FR
+        [Description("éteindre")]   Off,
+        [Description("info")]       Info,
+        [Description("allumé")]     On,
+        [Description("arrêter")]    Stop,
+#elif LANG_CS
+		[Description("vypnuto")]	Off,
+		[Description("info")]		Info,
+		[Description("zapnuto")]	On,
+		[Description("stop")]	    Stop,
+#elif LANG_RU
+        [Description("выкл")]       Off,
+        [Description("инфо")]       Info,
+        [Description("вкл")]        On,
+        [Description("останов")]    Stop,
+#elif LANG_PL
+		[Description("nie")]		Off,
+		[Description("info")]		Info,
+		[Description("tak")]		On,
+		[Description("przestać")]	Stop,
+#else // LANG_EN
+        [Description("off")]		Off,
+		[Description("info")]		Info,
+		[Description("on")]			On,
+        [Description("stop")]       Stop,
+#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),
+    }
+
+    #region iPERL enums
+
+    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
+    }
+
+    #endregion iPERL enums
+}

Common/Forms/ListViewEx.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections;
@@ -9,7 +9,7 @@ using System.Data;
 using System.Windows.Forms;
 using System.Runtime.InteropServices;
 
-namespace TBF.UiControls
+namespace Common.Forms
 {
 	/// <summary>
 	/// Event Handler for SubItem events
@@ -61,13 +61,17 @@ namespace TBF.UiControls
 		private const int HDN_ITEMCHANGINGW = (HDN_FIRST-20);
 		#endregion
 
+        public MySortOrder SortOrder = MySortOrder.None;
+        public int SortColumn = -1;
+
 		///	<summary>
 		///	Required designer variable.
 		///	</summary>
 		private	System.ComponentModel.Container	components = null;
 
 		public event SubItemEventHandler SubItemClicked;
-		public event SubItemEventHandler SubItemBeginEditing;
+        public event SubItemEventHandler SubItemRightClicked;
+        public event SubItemEventHandler SubItemBeginEditing;
 		public event SubItemEndEditingEventHandler SubItemEndEditing;
 
 		public ListViewEx()
@@ -237,12 +241,22 @@ namespace TBF.UiControls
 		{
 			base.OnMouseUp(e);
 
-			if (DoubleClickActivation)
-			{
-				return;
-			} 
+            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));
+                EditSubitemAt(new Point(e.X, e.Y));
+            }
 		}
 		
 		protected override void OnDoubleClick(EventArgs e)
@@ -273,6 +287,20 @@ namespace TBF.UiControls
 			}
 		}
 
+        ///<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
@@ -298,6 +326,11 @@ namespace TBF.UiControls
 			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
@@ -394,12 +427,18 @@ namespace TBF.UiControls
 
 			OnSubItemEndEditing(e);
 
-			_editItem.SubItems[_editSubItem].Text = e.DisplayText;
+            if (_editSubItem >= 0 && _editSubItem < _editItem.SubItems.Count)
+            {
+                _editItem.SubItems[_editSubItem].Text = e.DisplayText;
+            }
 
-			_editingControl.Leave -= new EventHandler(_editControl_Leave);
-			_editingControl.KeyPress -= new KeyPressEventHandler(_editControl_KeyPress);
+            if (_editingControl != null)
+            {
+                _editingControl.Leave -= new EventHandler(_editControl_Leave);
+                _editingControl.KeyPress -= new KeyPressEventHandler(_editControl_KeyPress);
 
-			_editingControl.Visible = false;
+                _editingControl.Visible = false;
+            }
 
 			_editingControl = null;
 			_editItem = null;

Common/Forms/ListViewExtensions.cs

@@ -0,0 +1,109 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    [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, MySortOrder 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 != MySortOrder.None && columnNumber == columnIndex)
+                {
+                    switch (order)
+                    {
+                        case MySortOrder.Ascending:
+                        case MySortOrder.Ascending2:
+                            item.fmt &= ~HDITEM.Format.SortDown;
+                            item.fmt |= HDITEM.Format.SortUp;
+                            break;
+
+                        case MySortOrder.Descending:
+                        case MySortOrder.Descending2:
+                            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/Forms/LviDateTimeColumnComparer.cs

@@ -0,0 +1,46 @@
+///
+/// Copyright (c) 2019-2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    public class LviDateTimeColumnComparer : IComparer
+    {
+        int column;
+        MySortOrder order;
+
+        public LviDateTimeColumnComparer()
+        {
+            column = 0;
+            order = MySortOrder.Ascending;
+        }
+
+        public LviDateTimeColumnComparer(int column, MySortOrder 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 == MySortOrder.Descending || order == MySortOrder.Descending2))
+            {
+                return (valY > valX) ? 1 : -1;
+            }
+            else
+            {
+                return (valX > valY) ? 1 : -1;
+            }
+        }
+    }
+}

Common/Forms/LviIntColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    public class LviIntColumnComparer : IComparer
+    {
+        int column;
+        MySortOrder order;
+
+        public LviIntColumnComparer()
+        {
+            column = 0;
+            order = MySortOrder.Ascending;
+        }
+
+        public LviIntColumnComparer(int column, MySortOrder 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 == MySortOrder.Descending || order == MySortOrder.Descending2) ? (valY - valX) : (valX - valY);
+        }
+    }
+}

Common/Forms/LviNameSurnameColumnComparer.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    public class LviNameSurnameColumnComparer : IComparer
+    {
+        private int column;
+        MySortOrder order;
+
+        public LviNameSurnameColumnComparer()
+        {
+            column = 0;
+            order = MySortOrder.Ascending;
+        }
+
+        public LviNameSurnameColumnComparer(int column, MySortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            string nameX = ((ListViewItem)x).SubItems[column].Text;
+            string nameY = ((ListViewItem)y).SubItems[column].Text;
+            string surnameX;
+            string surnameY;
+
+            switch (order)
+            {
+                case MySortOrder.Ascending:
+                    return String.Compare(nameX, nameY);
+
+                case MySortOrder.Descending:
+                    return String.Compare(nameY, nameX);
+
+                case MySortOrder.Ascending2:
+                    surnameX = (nameX.IndexOf(' ') > 0) ? nameX.Substring(nameX.IndexOf(' ') + 1) : nameX;
+                    surnameY = (nameX.IndexOf(' ') > 0) ? nameY.Substring(nameY.IndexOf(' ') + 1) : nameY;
+                    return String.Compare(surnameX, surnameY);
+
+                case MySortOrder.Descending2:
+                    surnameX = (nameX.IndexOf(' ') > 0) ? nameX.Substring(nameX.IndexOf(' ') + 1) : nameX;
+                    surnameY = (nameX.IndexOf(' ') > 0) ? nameY.Substring(nameY.IndexOf(' ') + 1) : nameY;
+                    return String.Compare(surnameY, surnameX);
+
+                default:
+                    return 0;
+            }
+        }
+    }
+}

Common/Forms/LviTextColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    public class LviTextColumnComparer : IComparer
+    {
+        private int column;
+        MySortOrder order;
+
+        public LviTextColumnComparer()
+        {
+            column = 0;
+            order = MySortOrder.Ascending;
+        }
+
+        public LviTextColumnComparer(int column, MySortOrder 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 == MySortOrder.Descending || order == MySortOrder.Descending2) ? String.Compare(txtY, txtX) : String.Compare(txtX, txtY);
+        }
+    }
+}

Common/Forms/MessageEventArgs.cs

@@ -0,0 +1,13 @@
+///
+/// Copyright (c) 2021-2023 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common.Forms
+{
+    public class MessageEventArgs : EventArgs
+    {
+        public string Message;
+        public MessageEventArgs(string message) { Message = message; }
+    }
+}

Common/Forms/ModelessForm.Designer.cs

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

Common/Forms/ModelessForm.cs

@@ -0,0 +1,79 @@
+///
+/// Copyright (c) 2021-2023 Sensus Slovensko a.s.
+///
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace Common.Forms
+{
+    public partial class ModelessForm : Form
+    {
+        /// <summary>
+        /// Constructor to be used by the application
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="message">Displayed message</param>
+        public ModelessForm(string message, int backArgb = 0, int textArgb = 0, Font textFont = null, string title = null)
+        {
+            InitializeComponent();
+            ControlBox = false;
+
+            label1.Text = (message != null)  ? message : "Please wait";
+            BackColor   = (backArgb != 0)    ? Color.FromArgb(backArgb) : Color.LightGreen;
+            ForeColor   = (textArgb != 0)    ? Color.FromArgb(textArgb) : Color.Black;
+            label1.Font = (textFont != null) ? textFont : new Font("Arial", 14, FontStyle.Regular);
+            Text = (title != null) ? title : string.Empty;
+
+            float textWidth = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Width;
+            float textHeight = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Height;
+            Width = (int)textWidth + 120;		/// Form width calculated from the text width
+            Height += (int)textHeight;		    /// Form height calculated from the text height
+
+            UpdateMessageHandler += delegate(object sender, MessageEventArgs args)
+            {
+                if (InvokeRequired) { Invoke(new EventHandler<MessageEventArgs>(OnUpdateMessage), sender, args); }
+                else OnUpdateMessage(sender, args);
+            };
+
+            CloseFormHandler += delegate(object sender, EventArgs args)
+            {
+                if (InvokeRequired) { Invoke(new EventHandler<EventArgs>(OnCloseForm), sender, args); }
+                else OnCloseForm(sender, args);
+            };
+        }
+
+
+        /// <summary>
+        /// Called from the state machine when an operation forces a modeless dialog close.
+        /// </summary>
+        public void UpdateMessage(MessageEventArgs args)
+        {
+            if (UpdateMessageHandler == null) return;
+            try { UpdateMessageHandler(null, args); }
+            catch (Exception) { }
+        }
+        public event EventHandler<MessageEventArgs> UpdateMessageHandler;
+        void OnUpdateMessage(object sender, MessageEventArgs args)
+        {
+            if (args != null && args.Message != null) label1.Text = args.Message;
+        }
+
+
+        /// <summary>
+        /// Called from the state machine when an operation forces a modeless dialog close.
+        /// </summary>
+        public void CloseForm()
+        {
+            if (CloseFormHandler == null) return;
+            try { CloseFormHandler(null, null); }
+            catch (Exception) { }
+        }
+        public event EventHandler<EventArgs> CloseFormHandler;
+        void OnCloseForm(object sender, EventArgs args)
+        {
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+    }
+}

Common/Formulas.cs

@@ -0,0 +1,352 @@
+///
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+
+namespace Common
+{
+    public static class Formulas
+    {
+		private static readonly ILog log = LogManager.GetLogger(typeof(Formulas));
+
+
+        ///
+        /// Wrappers
+        ///
+        public static double RealDensity() { return GlobalData.SampleDensity; }
+        public static double AtTemperature() { return GlobalData.SampleTemp; }
+        public static double Buoyancy() { return GlobalData.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
+		/// </summary>
+        static Formulas()
+        {
+            ///
+            /// Initialize tables to calculate specific enthalpies
+            ///
+            Ii = new int[34] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 8, 8, 21, 23, 29, 30, 31, 32 };
+            Ji = new int[34] { -2, -1, 0, 1, 2, 3, 4, 5, -9, -7, -1, 0, 1, 3, -3, 0, 1, 3, 17, -4, 0, 6, -5, -2, 10, -8, -11, -6, -29, -31, -38, -39, -40, -41 };
+            ni = new double[34] {
+                 0.14632971213167,      /// 1
+                -0.84548187169114,      /// 2
+                -0.37563603672040E1,    /// 3
+                 0.33855169168385E1,    /// 4
+                -0.95791963387872,      /// 5
+                 0.15772038513228,      /// 6
+                -0.16616417199501E-1,   /// 7
+                 0.81214629983568E-3,   /// 8
+                 0.28319080123804E-3,   /// 9
+                -0.60706301565874E-3,   /// 10
+                -0.18990068218419E-1,   /// 11
+                -0.32529748770505E-1,   /// 12
+                -0.21841717175414E-1,   /// 13
+                -0.52838357969930E-4,   /// 14
+                -0.47184321073267E-3,   /// 15
+                -0.30001780793026E-3,   /// 16
+                 0.47661393906987E-4,   /// 17
+                -0.44141845330846E-5,   /// 18
+                -0.72694996297594E-15,  /// 19
+                -0.31679644845054E-4,   /// 20
+                -0.28270797985312E-5,   /// 21
+                -0.85205128120103E-9,   /// 22
+                -0.22425281908000E-5,   /// 23
+                -0.65171222895601E-6,   /// 24
+                -0.14341729937924E-12,  /// 25
+                -0.40516996860117E-6,   /// 26
+                -0.12734301741641E-8,   /// 27
+                -0.17424871230634E-9,   /// 28
+                -0.68762131295531E-18,  /// 29
+                 0.14478307828521E-19,  /// 30
+                 0.26335781662795E-22,  /// 31
+                -0.11947622640071E-22,  /// 32
+                 0.18228094581404E-23,  /// 33
+                -0.93537087292458E-25,  /// 34
+            };
+
+			///
+			/// Initialize a table to calculate temperature of a platinum thermometer from resistance
+			///
+			Di = new double[]
+			{
+				 439.932854,
+				 472.418020,
+				 37.684494,
+				 7.472018,
+				 2.920828,
+				 0.005184,
+				-0.963864,
+				-0.188732,
+				 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 (obsolete)
+		/// </summary>
+		/// <param name="t">IPTS-68 temperature in [°C]</param>
+		/// <returns>Density in [kg/m3]</returns>
+        public static double DistilledWaterDensityFromTempIPTS68(double t)
+        {
+            const double a0 = 999.842594;
+            const double a1 = 0.06793952;
+            const double a2 = -0.009095290;
+            const double a3 = 0.0001001685;
+            const double a4 = -0.000001120083;
+            const double a5 = 6.536332e-09;
+
+            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 [°C]</param>
+		/// <returns>Density in [kg/m3]</returns>
+		public static double WaterDensityFromTemp(double 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 * Common.Units.ConvertTo(Common.Unit.Pa, pressure));
+        }
+
+
+		public static float AirDensityFromAmbientVales(float tempC, float pressureBar, float humiPct)
+		{
+			double pressurePa = 100000.0 * (double)pressureBar;		/// [Pa]
+			double tempKelvin = 273.15 + (double)tempC;
+			double coef1 = 1.2811805 / 10000.0 * tempKelvin * tempKelvin
+						 - 1.950987 / 100.0 * tempKelvin
+						 + 34.04926034
+						 - 6.353631 * 1000.0 / tempKelvin;
+			double coef3 = humiPct / 100.0 * System.Math.Exp(coef1) / pressurePa;
+			double airDensityKgm3 = 0.00348353 * pressurePa * (1.0 - 0.378 * coef3) / tempKelvin;	/// kg/m3
+			return (float)airDensityKgm3;
+		}
+
+		/// <summary>
+		/// Convert 'pulses' to 'volume', prevent division by zero
+		/// </summary>
+		public static double VolumeFromPulses(int pulses, double pulsesPerLiter)
+		{
+			if (pulsesPerLiter <= double.Epsilon) return 0;
+			return Convert.ToDouble(pulses) / pulsesPerLiter;
+		}
+
+		/// <summary>
+		/// Calculate the error in % from 'measured' and 'true' volume, prevent division by zero
+		/// </summary>
+		public static double ErrorFromVolumes(double measuredVolume, double trueVolume)
+		{
+			if (Math.Abs(trueVolume) <= float.Epsilon)
+			{
+				if (Math.Abs(measuredVolume) <= float.Epsilon)
+				{
+					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>
+        /// 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="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)
+        {
+            if (T_in == T_out) return 0;
+
+            const double R = 461.526;                       /// [J kg^-1 K^-1]
+            const double p_star_Pa = 16.53E6;               /// [Pa] (=16.53 MPa)
+            const double T_star = 1386.0;                   /// [K]
+
+            double T_in_K = Common.Units.ConvertTo(Common.Unit.K, T_in);
+            double T_out_K = Common.Units.ConvertTo(Common.Unit.K, T_out);
+            double tau_in = T_star / T_in_K;
+            double tau_out = T_star / T_out_K;
+            double pi = Common.Units.ConvertTo(Common.Unit.Pa, pressure) / p_star_Pa;
+
+            double h_in = tau_in * GammaTau(pi, tau_in) * R * T_in_K;
+            double h_out = tau_out * GammaTau(pi, tau_out) * R * T_out_K;
+
+            double ni = flowMeasuredAtInlet ? GammaPi(pi, tau_in) * R * T_in_K / p_star_Pa
+                                            : GammaPi(pi, tau_out) * R * T_out_K / p_star_Pa;
+
+            return (h_in - h_out) / (ni * (T_in - T_out));
+        }
+
+        /// <summary>
+        /// gamma(pi) see also STN EN 1434-1 Annex A (A.4)
+        /// </summary>
+        /// <param name="pi">pi = p / p* where p* = 16.53 MPa</param>
+        /// <param name="tau">tau = T* / T where T* = 1386 K</param>
+        /// <returns>gamma(pi)</returns>
+        static double GammaPi(double pi, double tau)
+        {
+            double result = 0;
+            for (int i = 0; i < 34; i++)
+            {
+                result -= ni[i] * Ii[i] * Math.Pow(7.1 - pi, Ii[i] - 1) * Math.Pow(tau - 1.222, Ji[i]);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// gamma(tau) see also STN EN 1434-1 Annex A (A.7)
+        /// </summary>
+        /// <param name="pi">pi = p / p* where p* = 16.53 MPa</param>
+        /// <param name="tau">tau = T* / T where T* = 1386 K</param>
+        /// <returns>gamma(tau)</returns>
+        static double GammaTau(double pi, double tau)
+        {
+            double result = 0;
+            for (int i = 0; i < 34; i++)
+            {
+                result += ni[i] * Math.Pow(7.1 - pi, Ii[i]) * Ji[i] * Math.Pow(tau - 1.222, Ji[i] - 1);
+            }
+            return result;
+        }
+
+		/// <summary>
+		/// Conversion of measured resistance of a platinum thermometer to temperature according to ITS-90
+		/// </summary>
+		/// <param name="R">Measured resistance in [°C]</param>
+		/// <param name="R001C">Calibrated resistance in Ohm at 0.01°C</param>
+		/// <param name="a7">Calibrated ITS-90 coefficient a7</param>
+		/// <param name="b7">Calibrated ITS-90 coefficient b7</param>
+		/// <param name="c7">Calibrated ITS-90 coefficient c7</param>
+        /// <returns>Temperature in [°C]</returns>
+		public static double PlatinumResistanceTM_ITS90_R2T(double R, double R001C, double a7, double b7, double c7)
+		{
+			double w = R / R001C;			/// ratio
+			double r1 = w - 1.0;
+			double dw = r1 * (a7 + r1 * (b7 + r1 * c7));	/// = a7*r1 + b7*r1^2 + c7*r1^3
+			double wr = w - dw;
+			double x = (wr - 2.64) / 1.64;
+
+			double sum = 0;
+			for (int i = Di.Length - 1; i >= 0; i--)
+			{
+				sum = sum * x + Di[i];
+			}
+
+			return sum;
+		}
+
+        /// <summary>
+        /// Conversion of measured resistance of a platinum thermometer to temperature using Callendar-Van Dusen equations
+        /// </summary>
+        /// <param name="R">Measured resistance in [°C]</param>
+        /// <param name="R0">Calibrated resistance in Ohm at 0°C</param>
+        /// <param name="A">Calibration coefficient a</param>
+        /// <param name="B">Calibration coefficient b</param>
+        /// <returns>Temperature in [°C]</returns>
+        public static double PlatinumResistanceTM_ITS27_R2T(double R, double R0, double A, double B)
+        {
+            if (R0 * R0 * A * A - 4 * R0 * B * (R0 - R) <= 0) return 0;     /// Out of range
+
+            return (-(R0 * A) + Math.Sqrt(R0 * R0 * A * A - 4 * R0 * B * (R0 - R))) / (2 * R0 * B);
+        }
+	}
+}

Common/GlobalData.cs

@@ -0,0 +1,14 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common
+{
+    public static class GlobalData
+    {
+        public static double SampleDensity = 0; /// sample water density measured in an accredited labo [kg/m3]
+        public static double SampleTemp = 0;    /// sample temperature when density measured in an accredited labo [°C]
+        public static double Buoyancy = 0;
+    }
+}

Common/IMeasurementCorrection.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Common
+{
+    public interface IMeasurementCorrection
+    {
+        int RangeIx { get; set; }
+        double Measurement { get; set; }
+        double Correction { get; set; }
+    }
+}

Common/IOrderInfo.cs

@@ -0,0 +1,26 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common
+{
+    public interface IOrderInfo
+    {
+        string POName { get; }
+        string VariantCode { get; }
+        string ModuleParam { get; }
+        int    PiecesCount { get; }
+        string SNPrefix { get; }
+        int    SNFirst { get; }
+        int    SNDigitsCount { get; }
+        string SNSuffix { get; }
+        string RAPrefix { get; }
+        int    RAFirst { get; }
+        string RASuffix { get; }
+        string Remark { get; }
+        int    CurrentPcsCount { get; set; }
+        int    CurrentSN { get; set; }
+        int    CurrentRA { get; set; }
+    }
+}

Common/IParamsProvider.cs

@@ -0,0 +1,75 @@
+///
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace Common
+{
+	public interface IParamsProvider
+	{
+        /// <summary>
+        /// Get XML Serializer
+        /// </summary>
+        XmlSerializer GetSerializer();
+
+		string ComponentName { get; }
+
+		/// <summary>
+		/// Number of parameters
+		/// </summary>
+		int ParamsCount();
+
+		/// <summary>
+		/// 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>
+        ICollection<string> ParamValues(int ix);
+
+		/// <summary>
+		/// Returns a parameter value in the string form
+		/// </summary>
+		/// <param name="ix">Zero based index of the parameter</param>
+		string ToString(int ix);
+
+		/// <summary>
+		/// Initialize values of all parameters
+		/// </summary>
+		void InitializeAll();
+
+		/// <summary>
+		/// Validates the string representation of a parameter
+		/// </summary>
+		/// <param name="ix">Zero based index of the parameter</param>
+		/// <param name="strValue">String representation of the parameter</param>
+		/// <param name="message">Warning message in case the string is wrong or null</param>
+		/// <returns>true = string is OK, false = string is wrong (see 'message')</returns>
+		bool ValidateParam(int ix, string strValue, out string message);
+
+		/// <summary>
+		/// Update the parameter from a string
+		/// </summary>
+		/// <param name="ix">Zero based index of the parameter</param>
+		/// <param name="strValue">String representation of the parameter</param>
+        CfgUpdateFlags UpdateParam(int ix, string strValue);
+
+        /// <summary>
+        /// Updates DB entities for related parameters
+        /// </summary>
+        /// <returns>true when successful</returns>
+        bool UpdateEmbeddedDbEntity();
+
+        /// <summary>
+        /// Creates an object copy
+        /// </summary>
+        /// <returns></returns>
+        IParamsProvider Clone();
+	}
+}

Common/IUncertainty.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Common
+{
+    public interface IUncertainty
+    {
+        float Measurement { get; }
+        float MainUncertainty { get; }
+        float Resolution { get; }
+        float DriftPerYr { get; }
+        float Conditions { get; }
+        float UncertaintyOfCorrection { get; }
+    }
+}

Common/IUser.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Common
+{
+    public interface IUser
+    {
+        string UserName { get; }	    /// = name, alias, abbreviation
+        string FullName { get; }	    /// = description
+        string Tag { get; }
+        int Number { get; }
+
+        /// Access rights
+        bool IsPowerUser();
+        bool IsMemberOf(GID group);
+        bool IsMemberOf(GID[] groups);
+        bool IsCorrectPassword(string password);
+
+        /// Password complexity, history, etc.
+        bool IsPasswordExpired();
+        bool IsPasswordUsedInPast(string passwordCandidate);
+        void SetPassword(string password);
+    }
+}

Common/Iperl/OptoTelegramRaw.cs

@@ -0,0 +1,269 @@
+///
+/// Copyright (c) 2015-2021 Sensus Metering Systems
+///
+using System;
+using System.Globalization;
+
+namespace Common.Iperl
+{
+    public enum OptoTelegramFlags : byte
+    {
+        OK = 0,
+        OK_TestStart,
+        OK_TestEnd,
+        InvalidTelegram,	/// Wrong telegram format of checksum error
+        SyncError,
+    }
+
+    public class OptoTelegramRaw
+	{
+		public static readonly int Length = 42;
+		private static CultureInfo culture;
+
+
+        ///
+        /// Strobed value
+        ///
+        public static decimal TestStartTimestampDec;
+
+		///
+		/// Stored values
+		///
+		public OptoTelegramFlags Flags;
+
+		public DateTime DateTime;		/// From PC
+		public float RefFlow;			/// [m3/h]
+		public int Counter;				
+
+		public Int32 EmfRaw;			/// Signed EMF from iPerl opto data
+		public Int16 MagneticFieldRaw;
+		public Int16 FlowRaw;
+		public UInt32 VolumeRaw;
+        public Int64 VolumeRawExt;
+		public Int16 Impedance;
+		public UInt32 Timestamp;
+        public Int64 TimestampExt;
+        public byte CheckSum;
+
+		///
+		/// Calculated values
+		///
+		public double EMF()
+		{
+            return 0.000000333 * (double)EmfRaw;
+		}
+		public double MagneticField() { return (double)MagneticFieldRaw; }
+		public double Flow(double scalingFactor) { return 0.225 * scalingFactor * (double)FlowRaw; }
+		public double Volume(double scalingFactor) { return 0.0000625 * scalingFactor * (double)VolumeRawExt; }
+		public Int32 FlipTime() { return Impedance; }
+		public decimal TimestampDec() { return (decimal)TimestampExt / (decimal)8192; }
+		public double VolumeDelta(double scalingFactor, OptoTelegramRaw previous) { return (previous == null) ? 0 : Volume(scalingFactor) - previous.Volume(scalingFactor); }
+        public decimal TimeDelta() { return TimestampDec() - TestStartTimestampDec; }
+		public string Label()
+		{
+            if (Flags == OptoTelegramFlags.OK_TestStart) return "####  start test  ####";
+			else if (Flags == OptoTelegramFlags.OK_TestEnd) return "####  end of test  ####";
+			else return string.Empty;
+		}
+
+
+		static OptoTelegramRaw()
+		{
+			culture = CultureInfo.CreateSpecificCulture("DE");		/// This is to use comma as decimal number separator
+        }
+
+		public OptoTelegramRaw()
+		{
+		}
+
+        /// <summary>
+        /// Parses optical telegram and returns OptoTelegramRaw object
+        /// </summary>
+        /// <description>
+        /// Create a configuration structure from a complete byte array
+		/// 
+		/// Telegram description:
+		/// 
+		/// AAAAAA[tab]BBBB[tab]CCCC[tab]DDDDDD[tab]EEEE[tab]FFFFFFFF[tab]GG[cr][lf]  (42 bytes)
+		/// 
+		/// Data     Comment         Type     Calculate to decimal
+		/// ----------------------------------------------------------------
+		/// AAAAAA   EMF             Int24    Value * 0.000000333
+		/// BBBB     Magnetic field  Int16    Value
+		/// CCCC     Flow            Int16    Value * 0.225 * Scalig factor
+		/// DDDDDD   Volume          Int24    Value / 16000 * Scaling factor
+		/// EEEE     Impedance       Int16    Value
+		/// FFFFFFFF Timestamp       Uint32   Value / 8192
+		/// GG       Checksum        Byte
+		/// ----------------------------------------------------------------
+		/// 
+		/// Example:
+		/// FFFFFE	51EA	0000	65324E	0087	F6319DFF	86
+		/// FFDD3A	51F9	0000	65324E	0088	F631A60B	45
+		/// ...
+        /// </description>
+        /// <param name="data">A complete byte array data</param>
+        /// <returns>true = telegram OK, false = telegram NOK</returns>
+        public bool UpdateFromString(string telegram, int counter, float refFlow, ref Int64 volumeRawExtLast, ref Int64 timestampExtLast, bool isLog = false)
+		{
+			DateTime = DateTime.Now;
+			Counter = counter;
+			RefFlow = refFlow;
+
+			if ((telegram == null) || (telegram.Length < Length) ||
+				(telegram[6]  != '\t') || (telegram[11] != '\t') || (telegram[16] != '\t') ||
+				(telegram[23] != '\t') || (telegram[28] != '\t') || (telegram[37] != '\t') ||
+                (!isLog && (telegram[40] != '\r' || telegram[41] != '\n')))
+			{
+                Flags = OptoTelegramFlags.InvalidTelegram;
+				return false;
+			}
+
+            UInt32 uEmfRaw;
+            bool f1 = UInt32.TryParse(telegram.Substring(0, 6), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out uEmfRaw);
+            EmfRaw = (uEmfRaw > 0x7FFFFF) ? ((int)uEmfRaw - 0x1000000) : (int)uEmfRaw;
+
+			bool f2 = Int16.TryParse(telegram.Substring(7, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out MagneticFieldRaw);
+			bool f3 = Int16.TryParse(telegram.Substring(12, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out FlowRaw);
+			bool f4 = UInt32.TryParse(telegram.Substring(17, 6), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out VolumeRaw);
+			bool f5 = Int16.TryParse(telegram.Substring(24, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out Impedance);
+			bool f6 = UInt32.TryParse(telegram.Substring(29, 8), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out Timestamp);
+			bool f7 = byte.TryParse(telegram.Substring(38, 2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out CheckSum);
+
+            byte calculatedCheckSum = 0;
+            for (int i = 0; i < Length - 4; i++)
+            {
+                calculatedCheckSum += (byte)telegram[i];
+            }
+
+            bool allOk = f1 && f2 && f3 && f4 && f5 && f6 && f7 && (calculatedCheckSum == CheckSum);
+
+            if (allOk)
+            {
+                ///
+                /// Cope with 'VolumeRaw' overflow
+                ///
+                Int64 uncorrected = (Int64)(((UInt64)volumeRawExtLast & 0xFFFFFFFFFF000000UL) | VolumeRaw);
+                if (Math.Abs(uncorrected - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected;
+                }
+                else if (Math.Abs(uncorrected + 0x1000000L - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected + 0x1000000L;
+                }
+                else if (Math.Abs(uncorrected - 0x1000000L - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected - 0x1000000L;
+                }
+                else
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected;
+                }
+
+                ///
+                /// Cope with 'Timestamp' overflow
+                ///
+                uncorrected = (Int64)(((UInt64)timestampExtLast & 0xFFFFFFFF00000000UL) | Timestamp);
+                if (Math.Abs(uncorrected - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected;
+                }
+                else if (Math.Abs(uncorrected + 0x100000000L - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected + 0x100000000L;
+                }
+                else if (Math.Abs(uncorrected - 0x100000000L - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected - 0x100000000L;
+                }
+                else
+                {
+                    TimestampExt = timestampExtLast = uncorrected;
+                }
+            }
+
+            Flags = allOk ? OptoTelegramFlags.OK : OptoTelegramFlags.InvalidTelegram;
+
+            return allOk;
+		}
+
+        /// <summary>
+        /// Alternative to UpdateFromString(...) when data are flushed
+        /// </summary>
+        public bool UpdateFromStringDummy(string telegram)
+        {
+            DateTime = DateTime.Now;
+            RefFlow = 0;
+
+            if ((telegram == null) || (telegram.Length < Length) ||
+                (telegram[6]  != '\t') || (telegram[11] != '\t') || (telegram[16] != '\t') ||
+                (telegram[23] != '\t') || (telegram[28] != '\t') || (telegram[37] != '\t') ||
+                (telegram[40] != '\r') || (telegram[41] != '\n'))
+            {
+                Flags = OptoTelegramFlags.InvalidTelegram;
+                return false;
+            }
+
+            bool f7 = byte.TryParse(telegram.Substring(38, 2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out CheckSum);
+
+            byte calculatedCheckSum = 0;
+            for (int i = 0; i < Length - 4; i++)
+            {
+                calculatedCheckSum += (byte)telegram[i];
+            }
+
+            bool allOk = f7 && (calculatedCheckSum == CheckSum);
+            
+            Flags = allOk ? OptoTelegramFlags.OK : OptoTelegramFlags.InvalidTelegram;
+
+            return allOk;
+        }
+
+
+        public void SetFlags(OptoTelegramFlags flags)
+		{
+			this.Flags = flags;
+		}
+
+
+		public string ToString(double scalingFactor, OptoTelegramRaw previous)
+		{
+			if (Flags == OptoTelegramFlags.SyncError)
+			{
+				return "Sychronization error";
+			}
+			else if (Flags == OptoTelegramFlags.InvalidTelegram)
+			{
+				return "Invalid telegram";
+			}
+			else /// if (flags == OptoTelegramFlags.OK / OptoTelegramFlags.OK_TestStart / OptoTelegramFlags.OK_TestEnd)
+			{
+                return string.Format("{0}:{1}:{2}.{3}\t{4} :\t{5}\t{6}\t{7}\t{8}\t{9}\t{10}\t{11}\t{12}\t{13}\t{14}\t{15}\t{16}\t{17}\t{18}\t{19}\t{20}\t{21}\t{22}",
+									DateTime.Hour.ToString("D2"),
+									DateTime.Minute.ToString("D2"),
+									DateTime.Second.ToString("D2"),
+									DateTime.Millisecond.ToString("D4"),
+									Counter,
+									(EmfRaw & 0x00FFFFFF).ToString("X6"),
+									MagneticFieldRaw.ToString("X4"),
+									FlowRaw.ToString("X4"),
+									VolumeRaw.ToString("X6"),
+                                    Impedance.ToString("X4"),
+									Timestamp.ToString("X8"),
+									CheckSum.ToString("X2"),
+									EMF().ToString("F4", culture),
+									MagneticField().ToString("F0", culture),
+									Flow(scalingFactor).ToString("F2", culture),
+									Volume(scalingFactor).ToString("F4", culture),
+									FlipTime().ToString("F0", culture),
+									TimestampDec().ToString("F4", culture),
+									(RefFlow * 1000).ToString("F2", culture),
+									VolumeDelta(scalingFactor, previous).ToString("F4", culture),
+									TimeDelta().ToString("F3", culture),
+									scalingFactor.ToString("F1", culture),
+									Label());
+			}
+		}
+	}
+}

Common/Printers/PrintersCommon.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Printing;
+
+namespace Common.Printers
+{
+    public class PrintersCommon : PrintDocument
+    {
+        static Font lastFont = null;
+        static float lastSpacing = 0;
+
+        /// <summary>
+        /// Measure the size of a paragraph of text, lines are separated by '~'.
+        /// </summary>
+        /// <param name="e">PrintPageEventArgs</param>
+        /// <param name="text">Text, lines are separated by '~'</param>
+        /// <param name="font">Font</param>
+        /// <returns>Size of the paragraph of text</returns>
+        public static SizeF Measure(System.Drawing.Printing.PrintPageEventArgs e, string text, Font font)
+        {
+            if (font != lastFont)
+            {
+                lastFont = font;
+                lastSpacing = e.Graphics.MeasureString("Abcgq", font).Height;
+            }
+
+            string[] lines = text.Split(new char[] { '~' });
+            float width = 0;
+            foreach (var line in lines)
+            {
+                float lineWid = e.Graphics.MeasureString(line, font).Width;
+                if (lineWid > width) width = lineWid;
+            }
+
+            return new SizeF(width, 0.8f * lines.Length * lastSpacing + 0.2f);
+        }
+
+        /// <summary>
+        /// Print a paragraph of text, lines are separated by '~'.
+        /// </summary>
+        /// <param name="e">PrintPageEventArgs</param>
+        /// <param name="text">Text, lines are separated by '~'</param>
+        /// <param name="font">Font</param>
+        /// <param name="x">Position x</param>
+        /// <param name="y">Position y</param>
+        /// <param name="width">Width (required when alignment=Alignment.Center or alignment=Aligmenr.Right</param>
+        /// <param name="height">Height, 0 = no vertical centering</param>
+        /// <param name="horizAlignment">Horizontal alignment</param>
+        /// <param name="vertAlignment">Vertical alignment</param>
+        public static void PrintAt(System.Drawing.Printing.PrintPageEventArgs e, string text, Font font,
+                                   float x, float y, float width, float height,
+                                   Alignment horizAlignment, VertAlignment vertAlignment)
+        {
+            SizeF size = PrintersCommon.Measure(e, text, font);
+
+            string[] lines = text.Split(new char[] { '~' });
+
+            if (height <= size.Height) vertAlignment = VertAlignment.Top;
+            float y0;
+            switch (vertAlignment)
+            {
+                default:
+                case VertAlignment.Top:     y0 = y; break;
+                case VertAlignment.Middle:  y0 = y + (height - size.Height) / 2; break;
+                case VertAlignment.Bottom:  y0 = y + (height - size.Height); break;
+            }
+                     
+            foreach (var line in lines)
+            {
+                float x0;
+                switch (horizAlignment)
+                {
+                    default:
+                    case Alignment.Left:    x0 = x; break;
+                    case Alignment.Center:  x0 = x + (width - e.Graphics.MeasureString(line, font).Width) / 2; break;
+                    case Alignment.Right:   x0 = x + width - e.Graphics.MeasureString(line, font).Width; break;
+                }
+                e.Graphics.DrawString(line, font, Brushes.Black, new PointF(x0, y0));
+                y0 += 0.8f * lastSpacing;
+            }
+        }
+    }
+}

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/QuitAppException.cs

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

Common/SerializableDictionary.cs

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

Common/StatisticalMetrics.cs

@@ -0,0 +1,338 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Common.Iperl;
+
+namespace Common
+{
+    public static class Extensions
+    {
+        public static float[] SubArray(this float[] array, int offset, int length)
+        {
+            float[] result = new float[length];
+            Array.Copy(array, offset, result, 0, length);
+            return result;
+        }
+    }
+
+    public class StatisticalMetrics
+    {
+        const int VectorSize = 7;
+        const int MinLength = 100;
+        const float AdcBit = (float)57e-9;
+        const int NeighbourhoodSize = 30;       /// To determine extended outliers
+
+        /// <summary>
+        /// Calculates a 7-dimensional vector with these components:
+        /// x[0] = X1 = Number of outliers
+        /// x[1] = X2 = Relative cal-factor shift due to outliers
+        /// x[2] = X3 = Standard deviation of high-pass filteres ++++ demodulation of EMF (cut-off at Nyquist frequency)
+        /// x[3] = X4 = Robust standard deviation of high-pass filtered ++++ demodulation
+        /// x[4] = X5 = Peak-to-peak of low-pass filtered ++++ demodulation of EMF (cut-off TBD)
+        /// x[5] = X6 = Peak-to-peak of reference flow rate
+        /// x[6] = X7 = Mean impedance (++-- demodulation)
+        /// </summary>
+        /// <param name="optoData"></param>
+        /// <param name="optoDataCount"></param>
+        /// <param name="startIx"></param>
+        /// <param name="endIx"></param>
+        /// <returns></returns>
+        public static float[] Calculate(OptoTelegramRaw[] optoData, int optoDataCount, int startIx, int endIx, bool downsample,
+                                        out float[] offsetV, out float[] kOhmsR, out float[] kOhmsC, out float[] dutFlow,
+                                        out float[] refFlow, out float[] flowRatio, out float[] magField, out float[] emfV,
+                                        out PointF[] outliers, out PointF[] extendedOutliers)
+        {
+            offsetV = kOhmsR = kOhmsC = dutFlow = refFlow = flowRatio = magField = emfV = null;
+            outliers = extendedOutliers = null;
+
+            if (optoData == null || optoData.Length < optoDataCount ||
+                startIx < 0 || endIx >= optoDataCount || endIx <= startIx + MinLength + 3) return null;
+
+            float[] modulatedData = GetModulatedEmf(optoData, optoDataCount, AdcBit);
+
+            FindShiftAndDemodulate(modulatedData, downsample,
+                                   new float[] { +1, +1, +1, +1 }, out offsetV,
+                                   new float[] { +1, +1, -1, -1 }, out kOhmsR,
+                                   new float[] { +1, -1, -1, +1 }, out kOhmsC,
+                                   new float[] { +1, -1, +1, -1 }, out dutFlow);
+            //offsetV = FirFilter(modulatedData, new float[] { 1, 3, 4, 4, 3, 1}, 0.0625F); 
+
+            magField = GetMagField(optoData, optoDataCount, downsample, new float[] { 1, 1, 1, 1 });
+            
+            refFlow = GetRefFlow(optoData, optoDataCount, downsample, new float[] { 1, 1, 1, 1 });
+            
+            flowRatio = new float[Math.Min(dutFlow.Length, refFlow.Length)];
+            for (int i = 0; i < flowRatio.Length; i++)
+            {
+                flowRatio[i] = (refFlow[i] != 0) ? dutFlow[i] / refFlow[i] : 1;
+            }
+
+
+            float[] x = new float[VectorSize];
+
+            /// X1 = Number of outliers
+            int outliersCount = GetOutliers(flowRatio, out outliers, out extendedOutliers);
+
+            
+            /// X2 = Relative cal-factor shift due to outliers
+
+            /// X3 = Standard deviation of high-pass filteres ++++ demodulation of EMF (cut-off at Nyquist frequency)
+
+            /// X4 = Robust standard deviation of high-pass filtered ++++ demodulation
+            
+            /// X5 = Peak-to-peak of low-pass filtered ++++ demodulation of EMF (cut-off TBD)
+            
+            /// X6 = Peak-to-peak of reference flow rate
+            
+            /// X7 = Mean impedance (++-- demodulation)
+            double sum = 0;
+            foreach (var z in kOhmsR) sum += z;
+            x[6] = Convert.ToSingle(sum / kOhmsR.Length);
+
+            return x;
+        }
+
+
+        static float[] GetModulatedEmf(OptoTelegramRaw[] optoData, int optoDataCount, float factor)
+        {
+            if (optoData == null || optoDataCount < 0) return null;
+
+            float[] result = new float[optoDataCount];
+            for (int i = 0; i < optoDataCount; i++)
+            {
+                result[i] = optoData[i].EmfRaw * factor;
+            }
+            return result;
+        }
+
+
+        static float[] GetMagField(OptoTelegramRaw[] optoData, int optoDataCount, bool downsample, float[] kernel)
+        {
+            if (optoData == null || optoDataCount < 0 || (downsample && (kernel == null || kernel.Length < 4))) return null;
+
+            int resultLen = downsample ? (optoDataCount / 4) : optoDataCount;
+            float[] result = new float[resultLen];
+
+            if (downsample)
+            {
+                float ksum = 0;
+                for (int j = 0; j < kernel.Length; j++) ksum += kernel[j];
+                for (int j = 0; j < kernel.Length; j++) kernel[j] /= ksum;
+
+                for (int i = 0; (4 * i) + kernel.Length - 1 < optoDataCount; i++)
+                {
+                    float sum = 0;
+                    for (int j = 0; j < kernel.Length; j++) sum += Convert.ToSingle(optoData[4 * i + j].MagneticFieldRaw) * kernel[j]; 
+                    result[i] = sum;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < optoDataCount; i++) result[i] = optoData[i].MagneticFieldRaw;
+            }
+
+            return result;
+        }
+
+
+        static float[] GetRefFlow(OptoTelegramRaw[] optoData, int optoDataCount, bool downsample, float[] kernel)
+        {
+            if (optoData == null || optoDataCount < 0 || (downsample && (kernel == null || kernel.Length < 4))) return null;
+
+            int resultLen = downsample ? (optoDataCount / 4) : optoDataCount;
+            float[] result = new float[resultLen];
+
+            if (downsample)
+            {
+                float ksum = 0;
+                for (int j = 0; j < kernel.Length; j++) ksum += kernel[j];
+                for (int j = 0; j < kernel.Length; j++) kernel[j] /= ksum;
+
+                for (int i = 0; (4 * i) + kernel.Length - 1 < optoDataCount; i++)
+                {
+                    float sum = 0;
+                    for (int j = 0; j < kernel.Length; j++) sum += Convert.ToSingle(optoData[4 * i + j].RefFlow) * kernel[j];
+                    result[i] = sum;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < optoDataCount; i++) result[i] = optoData[i].RefFlow;
+            }
+
+            return result;
+        }
+
+
+        public static void FindShiftAndDemodulate(float[] modulatedData, bool downsample,
+                                                  float[] kernel1, out float[] data1,
+                                                  float[] kernel2, out float[] data2,
+                                                  float[] kernel3, out float[] data3,
+                                                  float[] kernel4, out float[] data4)
+        {
+            int shift = GetShift(modulatedData.SubArray(0, MinLength));
+
+            data1 = (kernel1 != null) ? Demodulate(modulatedData, kernel1, shift, downsample) : null;
+            data2 = (kernel2 != null) ? Demodulate(modulatedData, kernel2, shift, downsample) : null;
+            data3 = (kernel3 != null) ? Demodulate(modulatedData, kernel3, shift, downsample) : null;
+            data4 = (kernel4 != null) ? Demodulate(modulatedData, kernel4, shift, downsample) : null;
+        }
+
+
+        /// <summary>
+        /// Unlike FIR filtering, demodulation shifts the kernel in 4 phases
+        /// </summary>
+        /// <param name="data">Input data</param>
+        /// <param name="kernel">Demodulation kernel</param>
+        /// <param name="shift">shift 0..3</param>
+        /// <returns>Output data</returns>
+        static float[] Demodulate(float[] data, float[] kernel, int shift, bool downsample)
+        {
+            if (data == null || data.Length < MinLength || kernel == null || kernel.Length != 4)
+            {
+                return null;
+            }
+
+            float ksum = 0;
+            for (int i = 0; i < 4; i++) ksum += Math.Abs(kernel[i]);
+            for (int i = 0; i < 4; i++) kernel[i] /= ksum;
+
+            int rsltLen = downsample ? (data.Length - 3) / 4 : data.Length - 3;
+            float[] result = new float[rsltLen];
+
+            if (downsample)
+            {
+                for (int i = shift; i < 4 * rsltLen; i += 4)
+                {
+                    float sum = 0;
+                    for (int j = 0; j < 4; j++) sum += data[i + j] * kernel[(i + j + 4 - shift) % 4];
+                    result[i / 4] = sum;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < rsltLen; i++)
+                {
+                    float sum = 0;
+                    for (int j = 0; j < 4; j++) sum += data[i + j] * kernel[(i + j + 4 - shift) % 4];
+                    result[i] = sum;
+                }
+            }
+
+            return result;
+        }
+
+
+        /// <summary>
+        /// Determine modulation phase by maximizing ++-- demodulation result.
+        /// </summary>
+        /// <param name="modulatedEmf">Input data</param>
+        /// <returns>0..3 = modulation phase or, -1 = error</returns>
+        static int GetShift(float[] modulatedData)
+        {
+            float[] kernel = new float[4] { 1, 1, -1, -1 };
+            int maximizingShift = -1;
+            float maximum = float.MinValue;
+
+            for (int shift = 0; shift <= 3; shift++)
+            {
+                var demodulatedCandidate = Demodulate(modulatedData, kernel, shift, false);
+                float sum = 0;
+                foreach (var d in demodulatedCandidate) sum += d;
+                if (sum > maximum)
+                {
+                    maximum = sum;
+                    maximizingShift = shift;
+                }
+            }
+
+            return maximizingShift;
+        }
+
+
+        /// <summary>
+        /// FIR filtering = convolution with a kernel
+        /// </summary>
+        /// <param name="data">Input data</param>
+        /// <param name="kernel">Convolution kernel</param>
+        /// <returns>Output data</returns>
+        static float[] FirFilter(float[] data, float[] kernel, float factor)
+        {
+            if (data == null || kernel == null) return null;
+
+            int kernelLen = kernel.Length;
+            int rsltLen = data.Length - kernelLen + 1;
+            if (rsltLen < 0) return null;
+
+            float[] result = new float[rsltLen];
+            for (int i = 0; i < rsltLen; i++)
+            {
+                float sum = 0;
+                for (int j = 0; j < kernelLen; j++) sum += data[i + j] * kernel[j];
+                result[i] = sum * factor;
+            }
+            return result;
+        }
+
+
+        static int GetOutliers(float[] flowRatio, out PointF[] outliers, out PointF[] extendedOutliers)
+        {
+            float mean = Enumerable.Average(flowRatio);
+            var fr = new float[flowRatio.Length];
+            for (int i = 0; i < fr.Length; i++) fr[i] = flowRatio[i] - mean;
+
+            Array.Sort(fr);
+            float qLo = fr[fr.Length / 4];
+            float qHi = fr[3 * fr.Length / 4];
+
+            int N = fr.Length / 2;
+            float sumY = 0;
+            float sumYY = 0;
+            for (int i = fr.Length / 4; i < 3 * fr.Length / 4; i++)
+            {
+                sumY += fr[i];
+                sumYY += fr[i] * fr[i];
+            }
+            float std = (float)Math.Sqrt(sumYY / N - (sumY / N) * (sumY / N));
+            float robustStd = std * 5.1812824F;
+            float threshold = 7 * robustStd;
+
+            /// Restore fr as it was before sorting
+            for (int i = 0; i < fr.Length; i++) fr[i] = flowRatio[i] - mean;
+
+            IList<PointF> listOfOutliers = new List<PointF>();
+            bool[] boolExtendedOutliers = new bool[fr.Length];
+            int outliersCount = 0;
+            for (int i = 0; i < fr.Length; i++)
+            {
+                if (fr[i] < -threshold || fr[i] > threshold)
+                {
+                    /// This is an outlier
+                    listOfOutliers.Add(new PointF(Convert.ToSingle(i), fr[i] + mean));
+                    outliersCount++;
+                    for (int j = Math.Max(0, i - NeighbourhoodSize); j <= Math.Min(i + NeighbourhoodSize, fr.Length - 1); j++)
+                    {
+                        boolExtendedOutliers[j] = true;
+                    }
+                }
+            }
+
+            IList<PointF> listOfExtendedOutliers = new List<PointF>();
+            for (int i = 0; i < fr.Length; i++)
+            {
+                if (boolExtendedOutliers[i])
+                {
+                    listOfExtendedOutliers.Add(new PointF(Convert.ToSingle(i), fr[i] + mean));
+                }
+            }
+
+            outliers = listOfOutliers.ToArray<PointF>();
+            extendedOutliers = listOfExtendedOutliers.ToArray<PointF>();
+
+            return outliersCount;
+        }
+    }
+}

Common/Telegram.cs

@@ -0,0 +1,272 @@
+///
+/// Copyright (c) 2013-2021 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+
+namespace Common
+{
+	public static class Telegram
+	{
+		const UInt16 crcSeed = 0xFFFF;		// Initial crc value
+		const UInt16 crcGP = 0xA001;		// Generating polynomial
+
+		/// <summary>
+		/// For standard CRC16 (remainder of division)
+		/// to start a new crc, set CRC16 = SEED
+		/// then for each byte call UpdateCRC(byte, &CRC16);
+		/// CRC16 will contain the result
+		/// (if you calculate all of the incoming data
+		/// INCLUDING the crc, the result should be 0x0000
+		/// and if you are sending the crc be sure to
+		/// send the bytes in the correct order)
+		/// <summary>
+		static void UpdateCRC(byte b, ref UInt16 crc)
+		{
+			crc ^= (UInt16)b;
+			for (int i = 0; i < 8; i++)
+			{
+				bool carry = (crc & 0x0001) != 0;
+				crc >>= 1;
+				if (carry) crc ^= crcGP;
+			}
+		}
+
+		/// <summary>
+		/// Calculates the CRC from a data telegram (an array of bytes).
+		/// A complete telegram including two bytes reserved for the CRC
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		/// <returns>Calculated CRC</returns>
+		public static UInt16 CalculateTelegramCRC(byte[] data, int enforcedLen = 0)
+		{
+            int len = (enforcedLen != 0) ? Math.Min(enforcedLen, data.Length) : data.Length;
+			UInt16 crc = crcSeed;
+            for (int i = 0; i < len - 2; i++) UpdateCRC(data[i], ref crc);
+			return crc;
+		}
+
+        /// <summary>
+        /// Calculates the CRC from a data telegram (an array of bytes).
+        /// A complete telegram including two bytes reserved for the CRC
+        /// must be supplied as an argument.
+        /// </summary>
+        /// <param name="data">Data telegram</param>
+        /// <returns>Calculated CRC</returns>
+        public static UInt16 CalculateTelegramCRC(int offset, byte[] data, int enforcedLen = 0)
+        {
+            int len = (enforcedLen != 0) ? Math.Min(enforcedLen, data.Length - offset) : data.Length - offset;
+            UInt16 crc = crcSeed;
+            for (int i = 0; i < len - 2; i++) UpdateCRC(data[offset + i], ref crc);
+            return crc;
+        }
+
+		/// <summary>
+		/// This function modifies the last 2 bytes in the message buffer
+		/// by the CRC calculated from the remaining first (Lenght - 2) bytes.
+		/// A complete telegram including two bytes reserved for the CRC
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		public static void UpdateTelegramCRC(byte[] data)
+		{
+			int len = data.Length;
+			if (len < 2) return;
+
+			UInt16 crc = CalculateTelegramCRC(data);
+
+			data[len - 2] = (byte)(crc & 0xFF);
+			data[len - 1] = (byte)(crc >> 8);
+		}
+
+		/// <summary>
+		/// This function compares the last 2 bytes in the message buffer
+		/// with the CRC calculated from the remaining first (Lenght - 2) bytes.
+		/// A complete telegram including two bytes reserved for the CRC
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		/// <returns>true if the CRC in the telegram is correct</returns>
+		public static bool VerifyTelegramCRC(byte[] data, int enforcedLen = 0)
+		{
+            if (data == null || data.Length == 0 || enforcedLen > data.Length) return false;
+
+			int len = (enforcedLen != 0) ? enforcedLen : data.Length;
+			if (len < 2) return false;
+
+			UInt16 crc = CalculateTelegramCRC(data, len);
+
+			return (data[len - 2] == (byte)(crc & 0xFF)) && (data[len - 1] == (byte)(crc >> 8));
+		}
+
+        /// <summary>
+        /// This function compares the last 2 bytes in the message buffer
+        /// with the CRC calculated from the remaining first (Lenght - 2) bytes.
+        /// A complete telegram including two bytes reserved for the CRC
+        /// must be supplied as an argument.
+        /// </summary>
+        /// <param name="data">Data telegram</param>
+        /// <returns>true if the CRC in the telegram is correct</returns>
+        public static bool VerifyTelegramCRC(int offset, byte[] data, int enforcedLen = 0)
+        {
+            if (data == null || data.Length == 0 || enforcedLen > data.Length - offset) return false;
+
+            int len = (enforcedLen != 0) ? enforcedLen : data.Length - offset;
+            if (len < 2) return false;
+
+            UInt16 crc = CalculateTelegramCRC(offset, data, len);
+
+            return (data[offset + len - 2] == (byte)(crc & 0xFF)) && (data[offset + len - 1] == (byte)(crc >> 8));
+        }
+
+
+
+		/// <summary>
+		/// Calculates the checksum from a data telegram (an array of bytes).
+		/// A complete telegram including one byte reserved for the checksum
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		/// <returns>Calculated checksum</returns>
+		public static byte CalculateTelegramChecksum(byte[] data)
+		{
+			byte checksum = 0;
+			for (int i = 0; i < data.Length - 1; i++) checksum = (byte)(checksum ^ data[i]);
+			return checksum;
+		}
+
+		/// <summary>
+		/// Calculates the checksum from a data telegram (an array of bytes).
+		/// A complete telegram including one bytes reserved for the checksum
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="hartPreambLen">Length of HART telegram preamble (FF bytes)</param>
+		/// <param name="data">Data telegram</param>
+		/// <returns>Calculated checksum</returns>
+		public static byte CalculateTelegramChecksum(int hartPreambLen, byte[] data)
+		{
+			byte checksum = 0;
+			for (int i = hartPreambLen; i < data.Length - 1; i++) checksum = (byte)(checksum ^ data[i]);
+			return checksum;
+		}
+
+		/// <summary>
+		/// This function modifies the last byte in the message buffer
+		/// by the checksum calculated from the remaining first (Lenght - 1) bytes.
+		/// A complete telegram including one bytes reserved for the checksum
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		public static void UpdateTelegramChecksum(byte[] data)
+		{
+			int len = data.Length;
+			if (len < 1) return;
+			data[len - 1] = CalculateTelegramChecksum(data);
+		}
+
+		/// <summary>
+		/// This function modifies the last byte in the message buffer
+		/// by the checksum calculated from the preceeding (Lenght - hartPreambLen - 1) bytes.
+		/// First hartPreambLen bytes in the telegram are skipped.
+		/// A complete telegram including preamble and one bytes reserved for the checksum
+		/// after data bytes must be supplied as an argument.
+		/// </summary>
+		/// <param name="hartPreambLen">Length of HART telegram preamble (FF bytes)</param>
+		/// <param name="data">Data telegram</param>
+		public static void UpdateTelegramChecksum(int hartPreambLen, byte[] data)
+		{
+			if (data.Length - hartPreambLen < 1) return;
+			data[data.Length - 1] = CalculateTelegramChecksum(hartPreambLen, data);
+		}
+
+		/// <summary>
+		/// This function compares the last byte in the message buffer
+		/// with the checksum calculated from the remaining first (Lenght - 1) bytes.
+		/// A complete telegram including two bytes reserved for the checksum
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="data">Data telegram</param>
+		/// <returns>true if the checksum in the telegram is correct</returns>
+		public static bool VerifyTelegramChecksum(byte[] data)
+		{
+			int len = data.Length;
+			if (len < 1) return false;
+			return (data[len - 1] == CalculateTelegramChecksum(data));
+		}
+
+		/// <summary>
+		/// This function compares the last byte in the message buffer
+		/// with the checksum calculated from the remaining first (Lenght - 1) bytes.
+		/// A complete telegram including two bytes reserved for the checksum
+		/// must be supplied as an argument.
+		/// </summary>
+		/// <param name="hartPreambLen">Length of HART telegram preamble (FF bytes)</param>
+		/// <param name="data">Data telegram</param>
+		/// <returns>true if the checksum in the telegram is correct</returns>
+		public static bool VerifyTelegramChecksum(int hartPreambLen, byte[] data)
+		{
+			if (data.Length - hartPreambLen < 1) return false;
+			return (data[data.Length - 1] == CalculateTelegramChecksum(hartPreambLen, data));
+		}
+
+
+		public static string LogTelegram(string intro, byte[] data, int from = 0, int len = -1)
+		{
+			System.Text.StringBuilder sb = new System.Text.StringBuilder(256);
+
+            int length = (len >= 0) ? len : (data.Length - from);
+
+            sb.Append(intro);
+            sb.Append(length.ToString());
+			sb.Append(" bytes:");
+			
+            for (int i = from; i < from + length; i++)
+			{
+                byte b = data[i];
+				sb.Append(" ");
+				sb.Append(((int)b).ToString("X2"));
+			}
+
+			return sb.ToString();
+		}
+
+
+        public static string LogTelegram(string intro, IList<byte> data, int from = 0, int len = -1)
+        {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder(256);
+
+            int length = (len >= 0) ? len : (data.Count - from);
+            
+            sb.Append(intro);
+            sb.Append(length.ToString());
+            sb.Append(" bytes:");
+
+            for (int i = from; i < from + length; i++)
+            {
+                byte b = data[i];
+                sb.Append(" ");
+                sb.Append(((int)b).ToString("X2"));
+            }
+
+            return sb.ToString();
+        }
+
+
+		public static string LogTelegram(string intro, string data)
+		{
+			System.Text.StringBuilder sb = new System.Text.StringBuilder(80);
+
+			sb.Append(intro);
+			sb.Append(data.Length.ToString());
+			sb.Append(" bytes:");
+			foreach (var d in data)
+			{
+				sb.Append(" ");
+				sb.Append(((int)d).ToString("X2"));
+			}
+
+			return sb.ToString();
+		}
+	}
+}

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/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/Units.cs

@@ -0,0 +1,606 @@
+///
+/// Copyright (c) 2016-2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common
+{
+    public enum Unit
+    {
+		[Description("---")]		None,
+
+        [Description("imp.")]       pulse,
+#if LANG_PL
+        [Description("stopień")]    degree,
+#else
+        [Description("degree")]     degree,
+#endif
+        [Description("ml")]         ml,         ///   1 ml = 0.001 l
+        [Description("l")]          l,          /// * 1 liter
+        [Description("dm3")]        dm3,        ///   1 dm3 = 1 l
+        [Description("US gal")]     USgal,      ///   1 US gallon = 3.78541178 l
+        [Description("imper.gal")]  UKgal,      ///   1 imperial gallon = 4.54609 l
+        [Description("cf")]         cf,         ///   1 cubic foot = 28.316846592 l
+        [Description("m3")]         m3,         ///   1 m3 = 1000 l
+
+        [Description("l/h")]        lph,        ///   1 l/h = 0.001 m3/h
+        [Description("cf/h")]       cfph,       ///   1 cf/h = 0.028316846592 m3/h
+        [Description("l/m")]        lpm,        ///   1 l/m = 60 l/h = 0.06 m3/h
+        [Description("US gal/m")]   USgalpm,    ///   1 US gallon per minute = 0.2271247068 m3/h
+        [Description("m3/h")]       m3ph,       /// * 1 m3/h
+        [Description("l/s")]        lps,        ///   1 liter/s = 3.6 m3/h
+        [Description("US gal/s")]   USgalps,    ///   1 US gallon per second = 13.627482408 m3/h
+        [Description("m3/m")]       m3pm,       ///   1 m3/m = 60 m3/h
+        [Description("cf/s")]       cfs,        ///   1 cubic foot per second = 101.9406477312 m3/h
+
+        [Description("g")]          g,          ///   0.001 kg
+        [Description("oz")]         oz,         ///   0.0283495231 kg
+        [Description("lb")]         lb,         ///   0.45359237 kg
+        [Description("kg")]         kg,         /// * 1 kilogram
+        [Description("t")]          t,          ///   1000 kg
+
+        [Description("ms")]         ms,         ///   1 ms = 0.001 s
+        [Description("s")]          s,          /// * 1 second
+        [Description("min")]        min,        ///   1 min = 60 s
+        [Description("hr")]         hour,       ///   1 hour = 60 min = 3600 s
+
+		[Description("°C")]         C,          /// * degree Celsius (°C)
+        [Description("°F")]         F,          ///   degree Fahrenheit
+        [Description("K")]          K,          ///   degree Kelvin
+
+        [Description("Pa")]         Pa,         ///   1 Pa = 0.01 hPa
+        [Description("hPa")]        hPa,        ///   1 hPa = 100 Pa
+        [Description("mbar")]       mbar,       ///   1 mbar = 1 hPa = 100 Pa
+        [Description("kPa")]        kPa,        ///   1 kPa = 10 hPa = 1000 Pa
+        [Description("inHg")]       inHg,       ///   1 inHg = 33.864 hPa
+        [Description("psi")]        psi,        ///   1 psi = 0.0689475729 bar
+        [Description("bar")]        bar,        /// * 1 Bar = 1000 mbar = 0.1 MPa = 100000 Pa
+        [Description("MPa")]        MPa,        ///   1 MPa = 10000 hPa
+
+        [Description("R%")]         RPct,       /// * 1 R%
+
+        [Description("promile")]    Promile,    ///   1 promile = 0.1 %
+        [Description("%")]          Pct,        /// * 1 %
+
+        [Description("mm")]         mm,         /// * 1 millimeter
+        [Description("cm")]         cm,         ///   1 cm = 10 mm
+        [Description("in")]         inch,       ///   1 inch = 25.4 mm
+        [Description("dm")]         dm,         ///   1 dm = 100 mm
+        [Description("ft")]         foot,       ///   1 foot = 304.8 mm
+        [Description("yd")]         yard,       ///   1 yard = 914.4 mm
+        [Description("m")]          m,          ///   1 m = 1000 mm
+
+        [Description("kg/m3")]      kgpm3,		/// * 1 kg/m3 = 0.001 kg/l
+        [Description("kg/l")]       kgpl,		///   1 kg/l = 1000 kg/m3
+
+        [Description("J")]          J,			/// * 1 Joul
+        [Description("kJ")]         kJ,			///   1 kJ = 1000 J
+        [Description("MJ")]         MJ,         ///   1 MJ = 1000000 J
+        [Description("Wh")]         Wh,			///   1 Wh = 3600 J
+        [Description("kWh")]        kWh,		///   1 kWh = 3600000 J
+        [Description("MWh")]        MWh,		///   1 MWh = 3600000000 J
+
+        [Description("uS/cm")]      uSpcm,      /// * 1 uS/cm
+        [Description("mS/m")]       mSpm,       ///   1 mS/m = 10 uS/cm
+
+#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
+        
+        ///
+        [Description("A")]  A, /// *1 A
+	    [Description("mA")] mA, /// 1 mA = 0.001 A
+        ///
+        [Description("V")]  V, /// *1 V
+        [Description("mV")] mV, /// 1 mV = 0.001 V                     
+                               
+                                                
+        Count
+    }
+
+	public enum Quantity
+	{
+        /// Quantities with units and conversions (double -> double)
+#if LANG_DE
+		[Description("Volumen")]			Volume,
+		[Description("Durchfluss")]			Flow,
+		[Description("Masse")]				Mass,
+        [Description("Zeit")]				Time,
+        [Description("Temperatur")]			Temperature,
+		[Description("Druck")]				Pressure,
+        [Description("Feuchtigkeit")]		Humidity,
+        [Description("Fehler")]				Error,
+		[Description("Länge")]				Length,
+		[Description("Dichte")]				Density,
+		[Description("Energie")]			Energy,
+		[Description("Impulse")]			Pulses,
+        [Description("Impulse/l")]			PulsePerLtr,
+        [Description("Impulse/kWh")]		PulsePerKWh,
+        [Description("Leitfähigkeit")]      Conductivity,
+
+        /// Quantities without units and conversions
+        [Description("Nummer")]				Number,
+        [Description("Text")]				String,
+        [Description("Boolean")]			Boolean,
+        [Description("Datum und Uhrzeit")]  DateTime,
+        [Description("Aufgezählt")]         Enumerated,
+        [Description("Strom")]              Current,
+		[Description("Spannung")]           Voltage,
+#elif LANG_PL
+        [Description("Objętość")]			Volume,
+		[Description("Przepływ")]           Flow,
+		[Description("Masa")]				Mass,
+        [Description("Czas")]				Time,
+        [Description("Temperatura")]		Temperature,
+		[Description("Ciśnienie")]			Pressure,
+        [Description("Wilgotność")]			Humidity,
+        [Description("Błąd")]				Error,
+		[Description("Długość")]			Length,
+		[Description("Gęstość")]			Density,
+		[Description("Energia")]			Energy,
+        [Description("Impulsy")]            Pulses,
+        [Description("Impulsy/litr")]       PulsePerLtr,
+        [Description("Impulsy/kWh")]		PulsePerKWh,
+        [Description("Przewodność")]        Conductivity,
+
+        /// Quantities without units and conversions
+        [Description("Numer")]				Number,
+        [Description("Tekst")]				String,
+        [Description("Boolean")]			Boolean,
+        [Description("Data i czas")]		DateTime,
+        [Description("Wyliczone")]          Enumerated,
+        [Description("Prąd")]               Current,
+        [Description("Napięcie")]            Voltage,
+#elif LANG_CS
+		[Description("Objem")]				Volume,
+		[Description("Průtok")]				Flow,
+		[Description("Hmotnost")]           Mass,
+        [Description("Čas")]				Time,
+        [Description("Teplota")]			Temperature,
+		[Description("Tlak")]				Pressure,
+        [Description("Vlhkost")]			Humidity,
+        [Description("Chyba")]				Error,
+		[Description("Délka")]				Length,
+		[Description("Hustota")]			Density,
+		[Description("Energie")]			Energy,
+		[Description("Pulzy")]				Pulses,
+        [Description("Pulzy/litr")]			PulsePerLtr,
+        [Description("Pulzy/kWh")]			PulsePerKWh,
+        [Description("Vodivost")]           Conductivity,
+
+        /// Quantities without units and conversions
+        [Description("Počet")]				Number,
+        [Description("Text")]				String,
+        [Description("Boolean")]			Boolean,
+        [Description("Datum a čas")]		DateTime,
+        [Description("Vyjmenované")]        Enumerated,
+		[Description("Proud")]				Current,
+		[Description("Napětí")]            Voltage,
+#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,
+        [Description("Conduttività")]       Conductivity,
+
+        /// Quantities without units and conversions
+        [Description("Numero")]				Number,
+        [Description("Stringa")]			String,
+        [Description("Boolean")]			Boolean,
+        [Description("Data e ora")]		    DateTime,
+        [Description("Enumerato")]          Enumerated,
+		[Description("Corrente")]            Current,
+		[Description("Voltaggio")]            Voltage,
+#else
+        [Description("Volume")]				Volume,
+		[Description("Flow")]				Flow,
+		[Description("Mass")]				Mass,
+        [Description("Time")]				Time,
+        [Description("Temperature")]		Temperature,
+		[Description("Pressure")]			Pressure,
+        [Description("Humidity")]			Humidity,
+        [Description("Error")]				Error,
+		[Description("Length")]				Length,
+		[Description("Density")]			Density,
+		[Description("Energy")]				Energy,
+		[Description("Pulses")]				Pulses,
+        [Description("Pulses/liter")]		PulsePerLtr,
+        [Description("Pulses/kWh")]			PulsePerKWh,
+        [Description("Conductivity")]       Conductivity,
+
+        /// Quantities without units and conversions
+        [Description("Number")]				Number,
+        [Description("String")]				String,
+        [Description("Boolean")]			Boolean,
+        [Description("Date and time")]		DateTime,
+        [Description("Enumerated")]         Enumerated,
+		[Description("Current")]            Current,
+		[Description("Voltage")]            Voltage,
+#endif
+        Count,
+	}
+
+    public static class Units
+    {
+        public static bool IsUnitless(Quantity quantity)
+        {
+            return quantity >= Quantity.Number;
+        }
+
+        public static bool IsDefaultUnit(Unit unit)
+        {
+            return unit == Unit.l || unit == Unit.m3ph || unit == Unit.kg || unit == Unit.s || unit == Unit.C ||
+                   unit == Unit.bar || unit == Unit.RPct || unit == Unit.Pct || unit == Unit.mm || unit == Unit.kgpm3 ||
+                   unit == Unit.J || unit == Unit.uSpcm || unit == Unit.ppl || unit == Unit.ppkWh || unit == Unit.A || 
+                   unit == Unit.V;
+        }
+
+        public static bool IsQuantity(Unit unit, Quantity quantity)
+        {
+            return (quantity == GetQuantity(unit));
+        }
+
+        public static Quantity GetQuantity(Unit unit)
+		{
+            switch (unit)
+            {
+                case Unit.pulse:
+                case Unit.degree:
+                    return Quantity.Pulses;
+
+                case Unit.ml:
+                case Unit.l:
+                case Unit.dm3:
+                case Unit.USgal:
+                case Unit.UKgal:
+                case Unit.cf:
+                case Unit.m3:
+					return Quantity.Volume;
+
+                case Unit.lph:
+                case Unit.cfph:
+                case Unit.lpm:
+                case Unit.USgalpm:
+                case Unit.m3ph:
+                case Unit.lps:
+                case Unit.USgalps:
+                case Unit.m3pm:
+                case Unit.cfs:
+                    return Quantity.Flow;
+
+                case Unit.g:
+                case Unit.oz:
+                case Unit.lb:
+                case Unit.kg:
+                case Unit.t:
+					return Quantity.Mass;
+
+                case Unit.ms:
+                case Unit.s:
+                case Unit.min:
+                case Unit.hour:
+                    return Quantity.Time;
+
+                case Unit.C:
+                case Unit.F:
+                case Unit.K:
+					return Quantity.Temperature;
+
+                case Unit.Pa:
+                case Unit.hPa:
+                case Unit.mbar:
+                case Unit.kPa:
+                case Unit.inHg:
+                case Unit.psi:
+                case Unit.bar:
+                case Unit.MPa:
+                    return Quantity.Pressure;
+
+                case Unit.RPct:
+                    return Quantity.Humidity;
+
+                case Unit.Promile:
+                case Unit.Pct:
+					return Quantity.Error;
+
+                case Unit.mm:
+                case Unit.cm:
+                case Unit.inch:
+                case Unit.dm:
+                case Unit.foot:
+                case Unit.yard:
+                case Unit.m:
+					return Quantity.Length;
+
+				case Unit.kgpm3:
+				case Unit.kgpl:
+					return Quantity.Density;
+
+				case Unit.J:
+				case Unit.kJ:
+                case Unit.MJ:
+                case Unit.Wh:
+				case Unit.kWh:
+                case Unit.MWh:
+                    return Quantity.Energy;
+
+                case Unit.uSpcm:
+                case Unit.mSpm:
+                    return Quantity.Conductivity;
+
+                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 Quantity.PulsePerLtr;
+
+                case Unit.ppkWh:
+                case Unit.kWhpp:
+                    return Quantity.PulsePerKWh;
+                
+                case Unit.A:
+                case Unit.mA:
+		                return Quantity.Current;
+                
+                case Unit.V:
+                case Unit.mV:
+	                return Quantity.Voltage;
+
+                default:
+					return Quantity.Number;
+            }
+		}
+
+		public static bool IsVolume(Unit unit)       { return IsQuantity(unit, Quantity.Volume); }
+		public static bool IsFlow(Unit unit)         { return IsQuantity(unit, Quantity.Flow); }
+        public static bool IsMass(Unit unit)         { return IsQuantity(unit, Quantity.Mass); }
+        public static bool IsTime(Unit unit)         { return IsQuantity(unit, Quantity.Time); }
+        public static bool IsTemperature(Unit unit)  { return IsQuantity(unit, Quantity.Temperature); }
+		public static bool IsPressure(Unit unit)     { return IsQuantity(unit, Quantity.Pressure); }
+        public static bool IsHumidity(Unit unit)     { return IsQuantity(unit, Quantity.Humidity); }
+        public static bool IsError(Unit unit)        { return IsQuantity(unit, Quantity.Error); }
+		public static bool IsLength(Unit unit)       { return IsQuantity(unit, Quantity.Length); }
+		public static bool IsDensity(Unit unit)      { return IsQuantity(unit, Quantity.Density); }
+		public static bool IsEnergy(Unit unit)       { return IsQuantity(unit, Quantity.Energy); }
+        public static bool IsPulses(Unit unit)       { return IsQuantity(unit, Quantity.Pulses); }
+        public static bool IsPulsePerLtr(Unit unit)  { return IsQuantity(unit, Quantity.PulsePerLtr); }
+        public static bool IsPulsePerKWh(Unit unit)  { return IsQuantity(unit, Quantity.PulsePerKWh); }
+        public static bool IsConductivity(Unit unit) { return IsQuantity(unit, Quantity.Conductivity); }
+        public static bool IsCurrent(Unit unit) { return IsQuantity(unit, Quantity.Current); }
+        public static bool IsVoltage(Unit unit) { return IsQuantity(unit, Quantity.Voltage); }
+
+
+
+        public static float ConvertTo(Unit unit, float v)
+        {
+            return (float)ConvertTo(unit, (double)v);
+        }
+
+        public static double ConvertTo(Unit unit, double v)
+        {
+            switch (unit)
+            {
+                /// Volume: internal representation in l
+                case Unit.ml:       return 1000 * v;            /// 1 ml = 0.001 l
+                case Unit.USgal:    return 0.26417205 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 0.21996925 * v;      /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 0.0353146667215 * v; /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 0.001 * v;           /// 1 m3 = 1000 l
+
+                /// Flow: internal representation in m3/h
+                case Unit.lph:      return 1000 * v;            /// 1 l/h
+                case Unit.cfph:     return 35.3146667214886 * v;/// 1 cf/h
+                case Unit.lpm:      return v / 0.06;            /// 1 l/m
+                case Unit.USgalpm:  return 4.40286754395493 * v;/// 1 US gallon per minute
+                case Unit.lps:      return v / 3.6;             /// 1 l/s
+                case Unit.USgalps:  return 0.0733811257326 * v; /// 1 US gallon per second
+                case Unit.m3pm:     return v / 60;              /// 1 m3/m
+                case Unit.cfs:      return 0.009809629644858 * v; /// 1 cubic foot per second
+
+                /// Mass: internal representation in kg
+                case Unit.g:        return 1000 * v;            /// 1 g = 0.001 kg
+                case Unit.oz:       return 35.273962 * v;       /// 1 oz = 0.0283495231 kg
+                case Unit.lb:       return 2.2046226 * v;       /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 0.001 * v;           /// 1 t = 1000 kg
+
+                /// Time or duration: internal representation in seconds [s] 
+                case Unit.ms:       return 1000 * v;
+                case Unit.min:      return v / 60;
+                case Unit.hour:     return v / 3600;
+
+				/// Temperature: internal representation in °C
+                case Unit.F:        return 1.8 * v + 32;        /// degree Fahrenheit
+                case Unit.K:        return v + 273.15;          /// degree Kelvin
+
+                /// Pressure: internal representation in  bar = 0.1 MPa
+                case Unit.Pa:       return 100000 * v;          /// 1 hPa = 100 Pa
+                case Unit.hPa:      return 1000 * v;            /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 1000 * v;            /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 100 * v;             /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 29.53 * v;           /// 1 inHg =
+                case Unit.psi:      return 14.5037738 * v;      /// 1 psi =
+                case Unit.MPa:      return 0.1 * v;             /// 1 MPa = 10000 hPa
+
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 10 * v;              /// 1 promile = 0.1 %
+
+                /// Diameter, length: internal representation in mm
+                case Unit.cm:       return 0.1 * v;             /// 1 cm = 10 mm
+                case Unit.inch:     return v / 25.4;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 0.01 * v;            /// 1 dm = 100 mm
+                case Unit.foot:     return v / 304.8;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return v / 914.4;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 0.001 * v;           /// 1 m = 1000 mm
+                                                                
+				/// Density: internal representation in kg/m3
+				case Unit.kgpl:     return 0.001 * v;
+
+				/// Energy, internal representation in Joul
+				case Unit.kJ:       return 0.001 * v;           /// 1 kJ = 1000 J
+                case Unit.MJ:       return 0.000001 * v;        /// 1 kJ = 1000000 J
+                case Unit.Wh:       return v / 3600.0;          /// 1 Wh = 3600 J
+				case Unit.kWh:      return v / 3600000.0;       /// 1 kWh = 3600000 J
+                case Unit.MWh:      return v / 3600000000.0;    /// 1 MWh = 3600000000 J
+
+                /// Electrical conductivity
+                case Unit.mSpm:     return 0.1 * v;
+
+                /// Invert pulses
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
+                
+                /// Current: internal representation in A
+                case Unit.mA:       return 1000 * v;           /// 1000 mA = 1 A
+                                                                
+                /// Voltage: internal representation in V
+                case Unit.mV:     return 1000 * v;				/// 1000 mV = 1 V
+
+
+                default:            return v;                   /// Do not convert
+            }
+        }
+
+
+        public static float ConvertFrom(Unit unit, float v)
+        {
+            return (float)ConvertFrom(unit, (double)v);
+        }
+
+        public static double ConvertFrom(Unit unit, double v)
+        {
+            switch (unit)
+            {
+                /// Volume: internal representation in l
+                case Unit.ml:       return 0.001 * v;           /// 0.001 l
+                case Unit.USgal:    return 3.78541178 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 4.54609 * v;         /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 28.316846592 * v;    /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 1000 * v;            /// 1000 l
+
+                /// Flow: internal representation in m3/h
+                case Unit.lph:      return 0.001 * v;           /// 1 l/h
+                case Unit.cfph:     return 0.028316846592 * v;  /// 1 cf/h
+                case Unit.lpm:      return 0.06 * v;            /// 1 l/m
+                case Unit.USgalpm:  return 0.2271247068 * v;    /// 1 US gallon per minute
+                case Unit.lps:      return 3.6 * v;             /// 1 l/s
+                case Unit.USgalps:  return 13.627482408 * v;    /// 1 US gallon per second
+                case Unit.m3pm:     return 60 * v;              /// 1 m3/m
+                case Unit.cfs:      return 101.9406477312 * v;  /// 1 cubic foot per second
+
+                /// Mass: internal representation in kg
+                case Unit.g:        return 0.001 * v;           /// 1 g = 0.001 kg
+                case Unit.oz:       return 0.0283495231 * v;    /// 1 oz = 0.0283495231 kg
+                case Unit.lb:       return 0.45359237 * v;      /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 1000 * v;            /// 1 t = 1000 kg
+
+                /// Time or duration: internal representation in seconds [s] 
+                case Unit.ms:       return 0.001 * v;
+                case Unit.min:      return 60 * v;
+                case Unit.hour:     return 3600 * v;
+
+				/// Temperature: internal representation in °C
+                case Unit.F:        return 5 * (v - 32) / 9;    /// degree Fahrenheit
+                case Unit.K:        return v - 273.15;          /// degree Kelvin
+
+                /// Pressure: internal representation in  bar = 0.1 MPa
+                case Unit.Pa:       return 0.00001 * v;         /// 1 hPa = 100 Pa
+                case Unit.hPa:      return 0.001 * v;           /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 0.001 * v;           /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 0.01 * v;            /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 0.033864 * v;        /// 1 inHg = 33.864 hPa
+                case Unit.psi:      return 0.0689475729 * v;    /// 1 psi = 0.0689475729 bar
+                case Unit.MPa:      return 10 * v;              /// 1 MPa = 10000 hPa
+
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 0.1 * v;             /// 1 promile = 0.1 %
+
+                /// Diameter, length: internal representation in mm
+                case Unit.cm:       return 10 * v;              /// 1 cm = 10 mm
+                case Unit.inch:     return 25.4 * v;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 100 * v;             /// 1 dm = 100 mm
+                case Unit.foot:     return 304.8 * v;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return 914.4 * v;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 1000 * v;            /// 1 m = 1000 mm
+
+				/// Density: internal representation in kg/m3
+				case Unit.kgpl:     return 1000 * v;
+
+				/// Energy, internal representation in Joul
+				case Unit.kJ:		return 1000 * v;            /// 1 kJ = 1000 J
+                case Unit.MJ:       return 1000000 * v;         /// 1 kJ = 1000000 J
+                case Unit.Wh:       return 3600 * v;            /// 1 Wh = 3600 J
+				case Unit.kWh:		return 3600000 * v;         /// 1 kWh = 3600000 J
+                case Unit.MWh:      return 3600000000 * v;      /// 1 kWh = 3600000000 J
+
+                /// Electrical conductivity
+                case Unit.mSpm:     return 10 * v;
+                
+                /// Current: internal representation in A
+                case Unit.mA:       return 0.001 * v;           /// 1 mA = 0.001 A
+                                                                
+                /// Voltage: internal representation in V
+                case Unit.mV:     return 0.001 * v;				/// 1 mV = 0.001 V
+
+                /// Invert
+                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;                   /// Do not convert
+            }
+        }
+
+        /// <summary>
+        /// Converts a string to a unit
+        /// </summary>
+        /// <param name="description">Unit description string</param>
+        /// <returns>Converted unit or Unit.None if not recognized</returns>
+        public static Unit FromDescription(string description)
+        {
+            for (Unit unit = 0; unit < Unit.Count; unit++)
+            {
+                if (unit.ToDescription() == description) return unit;
+            }
+
+            return Unit.None;
+        }
+	}
+}

Common/Utils.cs

@@ -0,0 +1,358 @@
+///
+/// Copyright (c) 2021-2023 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Common
+{
+    public static class Utils
+    {
+        public static string GetTestName(string name, int repeats, int repetitionNr)
+        {
+            if (name == null) return null;
+            if (repeats == 1) return name;
+            return string.Format("{0} ({1}/{2})", name, repetitionNr, repeats);
+        }
+
+        public static string ToNiceString(double value, int sigDigits)
+        {
+            string format = SignificantDigitsToFmt(value, sigDigits);
+            return (format == "F0") ? value.ToString("F0") : value.ToString(format).TrimEnd(new char[] { '0' });
+        }
+
+        public static FlowNames ProfileType2FlowNames(ProfileType pt, bool isAux = false)
+        {
+            switch (pt)
+            {
+                case ProfileType.Q3R:
+                case ProfileType.CompoundQ3RQ3R:
+                    return FlowNames.Q3Q2Q1;
+                case ProfileType.CompoundQ3RQnClass:
+                    return isAux ? FlowNames.QnQtQmin : FlowNames.Q3Q2Q1;
+                case ProfileType.QnClassColdWater:
+                case ProfileType.QnClassHotWater:
+                case ProfileType.CompoundQnClassQnClass:
+                    return FlowNames.QnQtQmin;
+                case ProfileType.CompoundQnClassQ3R:
+                    return isAux ? FlowNames.Q3Q2Q1 : FlowNames.QnQtQmin;
+                case ProfileType.QpQi:
+                case ProfileType.CompoundQpQiQpQi:
+                    return FlowNames.QpQi;
+                default:
+                    return FlowNames.Q3Q2Q1;
+            }
+        }
+
+        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>
+        /// 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, Medium medium = 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 == 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, Medium medium = 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 == 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, Medium medium = 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;
+            }
+        }
+
+
+        /// <summary>
+        /// Checks requirements on the password regardless of the password history
+        /// </summary>
+        /// <param name="password">Password</param>
+        /// <returns>true when the password is OK</returns>
+        public static bool IsPasswordMeetsRequirements(string password, out string explanation)
+        {
+            int length = string.IsNullOrEmpty(password) ? 0 : password.Length;
+
+            /// Password length must be at least 6
+            if (length < CurrentUser.MinPasswdLength)
+            {
+                explanation = string.Format("Password must have at least {0} characters", CurrentUser.MinPasswdLength);
+                return false;
+            }
+            else
+            {
+                explanation = string.Empty;
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// getHash encrypts a string 
+        /// </summary>
+        /// <param name="text">the string to encrypt</param>
+        /// <returns></returns>
+        public static string GetHash(string text)
+        {
+            byte[] bytes = System.Text.Encoding.Unicode.GetBytes(text);
+            System.Security.Cryptography.SHA512Managed hashstring = new System.Security.Cryptography.SHA512Managed();
+            byte[] hash = hashstring.ComputeHash(bytes);
+            string hashString = string.Empty;
+            foreach (byte x in hash)
+            {
+                hashString += String.Format("{0:x2}", x);
+            }
+            return hashString;
+        }
+
+        public static string EncodedStrToUserName(string encodedStr)
+        {
+            string[] subStrings = encodedStr.Split(new char[] { '~' });
+            return (subStrings.Length >= 1) ? subStrings[0] : string.Empty;
+        }
+
+        public static string EncodedStrToFullName(string encodedStr)
+        {
+            string[] subStrings = encodedStr.Split(new char[] { '~' });
+            return (subStrings.Length >= 2) ? subStrings[1] : string.Empty;
+        }
+
+        public static string EncodedStrToLegalizator(string encodedStr)
+        {
+            string[] subStrings = encodedStr.Split(new char[] { '~' });
+            return (subStrings.Length >= 3) ? subStrings[2] : string.Empty;
+        }
+
+        /// <summary>
+        /// Returns 'true' when authentication data are valid for a power user.
+        /// </summary>
+        /// <param name="userName">User name</param>
+        /// <param name="password">Password</param>
+        /// <returns>true = authenticated, false = refused</returns>
+        public static bool IsPowerUser(string userName, string password)
+        {
+            DateTime date = DateTime.Now.Date;
+            int number = (date.Year % 10) + 10 * (date.Month - 1) + 120 * date.Day;
+            string passwordOfDay = Convert.ToString(number, 8);
+
+            return (userName.Equals("milan") && password.Equals("kraken")) ||
+                   (userName.Equals("michal") && password.Equals("70630")) ||
+                   (userName.Equals("igor") && password.Equals("mojronko8")) ||
+                   (userName.Equals("lubo1212") && password.Equals("Tatry52")) ||
+                   (userName.Equals("Michal") && password.Equals("Plok789456123")) ||
+                   (userName.Equals("martin") && password.Equals("vaclavek84")) ||
+                   (userName.Equals("pakan") && password.Equals("kuriatko")) ||
+                   (userName.Equals("jan") && password.Equals("jaugust")) ||
+                   (userName.Equals("JCermak") && password.Equals("Zt6911")) ||
+                   (userName.Equals("gilles") && password.Equals("alibaba")) ||
+                   (userName.Equals(passwordOfDay) && password.Equals(passwordOfDay));
+        }
+
+        public static void CalculateFeatureVector(Iperl.OptoTelegramRaw[] optoData, int optoDataCount, int startIx, int endIx, ref float[] x)
+        {
+            if (startIx < 0 || endIx >= optoDataCount || startIx >= endIx) return;
+
+            int n = 0;
+            Int64 sumFlow = 0;
+            Int64 sumFlow2 = 0;
+            Int64 sumEmf = 0;
+            Int64 sumEmf2 = 0;
+            Int64 sumMagF = 0;
+            Int64 sumMagF2 = 0;
+            Int64 sumImp = 0;
+            Int64 sumImp2 = 0;
+
+            for (int ix = startIx; ix <= endIx; ix++)
+            {
+                if (optoData[ix].Flags == Iperl.OptoTelegramFlags.OK ||
+                    optoData[ix].Flags == Iperl.OptoTelegramFlags.OK_TestStart ||
+                    optoData[ix].Flags == Iperl.OptoTelegramFlags.OK_TestEnd)
+                {
+                    n++;
+                    sumFlow += optoData[ix].FlowRaw;
+                    sumFlow2 += ((int)optoData[ix].FlowRaw * (int)optoData[ix].FlowRaw);
+                    sumEmf += (int)optoData[ix].EmfRaw;
+                    sumEmf2 += ((Int64)optoData[ix].EmfRaw * (Int64)optoData[ix].EmfRaw);
+                    sumMagF += optoData[ix].MagneticFieldRaw;
+                    sumMagF2 += ((int)optoData[ix].MagneticFieldRaw * (int)optoData[ix].MagneticFieldRaw);
+                    sumImp += optoData[ix].Impedance;
+                    sumImp2 += ((int)optoData[ix].Impedance * (int)optoData[ix].Impedance);
+                }
+            }
+
+            if (n >= 2)
+            {
+                if (x.Length > 0) x[0] = ((float)sumFlow2 - (float)sumFlow * (float)sumFlow / n) / (n - 1);
+                if (x.Length > 1) x[1] = ((float)sumEmf2 - (float)sumEmf * (float)sumEmf / n) / (n - 1);
+                if (x.Length > 2) x[2] = ((float)sumMagF2 - (float)sumMagF * (float)sumMagF / n) / (n - 1);
+                if (x.Length > 3) x[3] = ((float)sumImp2 - (float)sumImp * (float)sumImp / n) / (n - 1);
+            }
+        }
+    }
+}

Common/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="log4net" version="2.0.15" targetFramework="net472" />
+</packages>

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,43 +10,46 @@
     <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;IPERLST</DefineConstants>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
-    <PlatformTarget>x86</PlatformTarget>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;IPERLST</DefineConstants>
+    <DefineConstants>TRACE;JUZNA_AFRIKA_NEW</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="FluentNHibernate">
-      <HintPath>..\packages\FluentNHibernate.1.3.0.733\lib\FluentNHibernate.dll</HintPath>
+      <HintPath>..\packages\FluentNHibernate.2.0.3.0\lib\net40\FluentNHibernate.dll</HintPath>
     </Reference>
     <Reference Include="Iesi.Collections">
-      <HintPath>..\packages\Iesi.Collections.3.2.0.4000\lib\Net35\Iesi.Collections.dll</HintPath>
+      <HintPath>..\packages\Iesi.Collections.4.0.0.4000\lib\net40\Iesi.Collections.dll</HintPath>
     </Reference>
     <Reference Include="log4net">
-      <HintPath>..\packages\log4net.2.0.2\lib\net40-full\log4net.dll</HintPath>
+      <HintPath>..\packages\log4net.2.0.15\lib\net45\log4net.dll</HintPath>
     </Reference>
-    <Reference Include="MySql.Data, Version=6.6.5.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d, processorArchitecture=MSIL">
-      <HintPath>..\packages\MySql.Data.6.6.5\lib\net20\MySql.Data.dll</HintPath>
+    <Reference Include="MySql.Data">
+      <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
     </Reference>
-    <Reference Include="NHibernate, Version=3.3.1.4000, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
-      <HintPath>..\packages\NHibernate.3.3.3.4001\lib\Net35\NHibernate.dll</HintPath>
+    <Reference Include="NHibernate">
+      <HintPath>..\packages\NHibernate.4.0.4.4000\lib\net40\NHibernate.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -64,63 +67,78 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Data.cs" />
-    <Compile Include="DatabaseSettings.cs" />
-    <Compile Include="DBSettings.cs" />
+    <Compile Include="CalendarEvent\ICalendarEvent.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" />
-    <Compile Include="Entities\Enums.cs" />
     <Compile Include="Entities\FeedingPath.cs" />
     <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\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\TestInstance.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="Grp.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" />
-    <Compile Include="ResultItemSpec.cs" />
+    <Compile Include="PurchaseResources.cs" />
+    <Compile Include="Resources\Strings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
   </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>
     </EmbeddedResource>
+    <EmbeddedResource Include="Resources\Strings.ru.resx" />
+    <EmbeddedResource Include="Resources\Strings.zh-CN.resx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{c8939821-ba5c-4988-a3d0-bf53b74865c7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

Config/DBSettings.cs

@@ -1,31 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-
-namespace Config
-{
-    /// <summary>
-    /// Database settings required to make a connection
-    /// </summary>
-    public class DBSettings : ICloneable
-    {
-        public Entities.DBType DbType;
-        public string ConnectionString;
-
-        public DBSettings()
-        {
-        }
-
-		public DBSettings(Entities.DBType dbType, string connectionString)
-        {
-            this.DbType = dbType;
-            this.ConnectionString = connectionString;
-        }
-
-        public object Clone()
-        {
-            return new DBSettings(DbType, ConnectionString);
-        }
-    }
-}

Config/Data.cs

@@ -1,42 +0,0 @@
-using System;
-
-namespace Config
-{
-	public class Data
-	{
-		public const string AdminUsername = "admin";
-		public const string AdminPassword = "staratura";
-		public const string SQLiteDbFName = "SQLite.db";
-
-#if MUNICH
-		public const int WMsCount = 3;
-		public const int LineSize = 1;
-		public const int CompoundWMsCount = 1;
-#elif DN100 || BADGER_VELKA_TRAT
-		public const int WMsCount = 3;
-		public const int LineSize = 3;
-		public const int CompoundWMsCount = 1;
-#elif FUZHOU300 || FUZHOU150 || PT200IL
-		public const int WMsCount = 6;
-		public const int LineSize = 6;
-		public const int CompoundWMsCount = 3;
-#elif TORINO50 || BADGER_MALA_TRAT
-		public const int WMsCount = 6;
-		public const int LineSize = 6;
-		public const int CompoundWMsCount = 1;
-#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40
-		public const int WMsCount = 20;
-		public const int LineSize = 10;
-		public const int CompoundWMsCount = 1;
-#elif IPERLST
-		public const int WMsCount = 40;
-		public const int LineSize = 20;
-		public const int CompoundWMsCount = 1;
-#endif
-
-		///
-		/// Database related: This object reference is set after a successful user login
-		///
-		public static DatabaseSettings CurrentBench;
-	}
-}

Config/DatabaseSettings.cs

@@ -1,47 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Text;
-using System.Xml.Serialization;
-
-namespace Config
-{
-    /// <summary>
-    /// Test bench database settings, contains bench name and settings od several databases
-    /// </summary>
-    public class DatabaseSettings : ICloneable
-    {
-        // Public fields
-        public string BenchName;
-        public bool IsRealBench;
-        public DBSettings ProceduresDBSettings;		/// Config database settings
-        public DBSettings WaterMetersDBSettings;	/// Results database settings
-
-        // Constructor
-        public DatabaseSettings()
-        {
-            BenchName = String.Empty;           /// Empty string to avoid null
-            IsRealBench = false;
-			ProceduresDBSettings  = new DBSettings(Entities.DBType.MySql, "SERVER=localhost; DATABASE=tbf_procedures; UID=root; PASSWORD=;");
-			WaterMetersDBSettings = new DBSettings(Entities.DBType.MySql, "SERVER=localhost; DATABASE=tbf_watermeters; UID=root; PASSWORD=;");
-        }
-
-        public object Clone()
-        {
-            DatabaseSettings result = new DatabaseSettings();
-
-            result.BenchName    = BenchName;
-            result.IsRealBench  = IsRealBench;
-            result.ProceduresDBSettings  = (DBSettings)ProceduresDBSettings.Clone();
-            result.WaterMetersDBSettings = (DBSettings)WaterMetersDBSettings.Clone();
-
-            return result;
-        }
-
-		public override string ToString()
-		{
-			return string.Format("{0} conn.str.={1}", BenchName, ProceduresDBSettings.ConnectionString);
-		}
-    }
-}

Config/Entities/BenchPath.cs

@@ -1,34 +1,46 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using Common;
 
 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 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 TempIn { get; set; }
-        public virtual string TempOut { get; set; }
-        public virtual string PressIn { get; set; }
-        public virtual string PressOut { get; set; }
+        public virtual string OriName { get; set; }         /// Not mapped to database
+        public virtual double Qfrom { get; set; }           /// Water flow in [m3/h]
+        public virtual double Qto { get; set; }             /// Water flow in [m3/h]
+        public virtual Unit   FlowUnit { get; set; }        /// Not mapped to database, used in UI
+        public virtual string Selector { get; set; }
+        public virtual string TempMtrUp { get; set; }
+        public virtual string TempMtrDown { get; set; }
+        public virtual string PressMtrUp { get; set; }
+        public virtual string PressMtrDown { get; set; }
+		public virtual string PressMtrDelta { get; set; }
+		public virtual string ElectricMtrUp { get; set; }
+		public virtual string ElectricMtrDown { get; set; }
+		public virtual string ElectricMtrDelta { get; set; }
+		public virtual string StopBFValve { get; set; }
 
         /// Valves		
 		public virtual string ValvesOpen { get; set; }
 		public virtual string ValvesClose { get; set; }
 
+        public virtual bool QfromTextChngd { get; set; }    /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool QtoTextChngd { get; set; }      /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+
         /// ------------- Additional stuff not mapped into the database -------------
 
 		public BenchPath()
         {
-			ValvesOpen = string.Empty;
+			ValvesOpen  = string.Empty;
 			ValvesClose = string.Empty;
-		}
+        }
 
 		public BenchPath(string name, int itemNr)
 			: this()
@@ -41,14 +53,21 @@ namespace Config.Entities
         {
 			BenchPath result = new BenchPath(name, itemNr);
 
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.TempIn = TempIn;
-			result.TempOut = TempOut;
-			result.PressIn = PressIn;
-			result.PressOut = PressOut;
-			result.ValvesOpen = ValvesOpen;
-			result.ValvesClose = ValvesClose;
+			result.Qfrom         = Qfrom;
+            result.Qto           = Qto;
+            result.FlowUnit      = FlowUnit;
+            result.Selector      = Selector;
+            result.TempMtrUp     = TempMtrUp;
+			result.TempMtrDown   = TempMtrDown;
+			result.PressMtrUp    = PressMtrUp;
+			result.PressMtrDown  = PressMtrDown;
+			result.PressMtrDelta = PressMtrDelta;
+			result.ElectricMtrUp    = ElectricMtrUp;
+			result.ElectricMtrDown  = ElectricMtrDown;
+			result.ElectricMtrDelta = ElectricMtrDelta;
+			result.StopBFValve   = StopBFValve;
+			result.ValvesOpen    = ValvesOpen;
+			result.ValvesClose   = ValvesClose;
 
             return result;
         }

Config/Entities/Component.cs

@@ -1,28 +1,34 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.IO;
+using Common;
 
 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; }
 		public virtual string Name { get; set; }
 		public virtual string ClassName { get; set; }
-		public virtual string ParentName { get; set; }
-        public virtual DebugMode Mode { get; set; }
-		public virtual LogLevel Logging { get; set; }
+		public virtual string Parent { get; set; }
+        public virtual DebugMode DebugMode { get; set; }
+		public virtual LogLevel LogLevel { get; set; }
 		public virtual string Parameters { get; set; }
-		public virtual IList<MeasurementCorrection> Corrections { 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,
@@ -32,9 +38,9 @@ namespace Config.Entities
 			result.ItemNr = itemNr;
 			result.Name = name;
 			result.ClassName = className;
-			result.ParentName = parentName;
-            result.Mode = debugLevel;
-			result.Logging = logLevel;
+			result.Parent = parentName;
+            result.DebugMode = debugLevel;
+			result.LogLevel = logLevel;
 			result.Parameters = parameters;
 			return result;
 		}
@@ -46,13 +52,66 @@ namespace Config.Entities
 			result.ItemNr = ItemNr;
 			result.Name = Name;
             result.ClassName = ClassName;
-			result.ParentName = ParentName;
-            result.Mode = Mode;
-			result.Logging = Logging;
+			result.Parent = Parent;
+            result.DebugMode = DebugMode;
+			result.LogLevel = LogLevel;
 			result.Parameters = Parameters;
 			return result;
 		}
 
+        public virtual void Export(StreamWriter output)
+        {
+            output.WriteLine(Name);
+            output.WriteLine(ClassName);
+            output.WriteLine(Parent);
+            output.WriteLine(DebugMode.ToString());
+            output.WriteLine(LogLevel.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.Parent = input.ReadLine();
+
+            string line = input.ReadLine();
+            if (line.Equals(DebugMode.DetectedOff.ToString()))                 result.DebugMode = DebugMode.DetectedOff;
+            else if (line.Equals(DebugMode.DetectedOn.ToString()))             result.DebugMode = DebugMode.DetectedOn;
+            else if (line.Equals(DebugMode.Normal.ToString()))                 result.DebugMode = DebugMode.Normal;
+            else if (line.Equals(DebugMode.AutoDetect.ToString()))             result.DebugMode = DebugMode.AutoDetect;
+            else if (line.Equals(DebugMode.FailureDuringOperation.ToString())) result.DebugMode = DebugMode.FailureDuringOperation;
+            else if (line.Equals(DebugMode.Off.ToString()))                    result.DebugMode = DebugMode.Off;
+            else if (line.Equals(DebugMode.Record.ToString()))                 result.DebugMode = DebugMode.Record;
+            else if (line.Equals(DebugMode.Replay.ToString()))                 result.DebugMode = DebugMode.Replay;
+            else if (line.Equals(DebugMode.Simulate.ToString()))               result.DebugMode = DebugMode.Simulate;
+            else if (line.Equals(DebugMode.Inherit.ToString()))                result.DebugMode = DebugMode.Inherit;
+
+            line = input.ReadLine();
+            if (line.Equals(LogLevel.Off.ToString()))        result.LogLevel = LogLevel.Off;
+            else if (line.Equals(LogLevel.Fatal.ToString())) result.LogLevel = LogLevel.Fatal;
+            else if (line.Equals(LogLevel.Error.ToString())) result.LogLevel = LogLevel.Error;
+            else if (line.Equals(LogLevel.Warn.ToString()))  result.LogLevel = LogLevel.Warn;
+            else if (line.Equals(LogLevel.Info.ToString()))  result.LogLevel = LogLevel.Info;
+            else if (line.Equals(LogLevel.Debug.ToString())) result.LogLevel = LogLevel.Debug;
+            else if (line.Equals(LogLevel.All.ToString()))   result.LogLevel = 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;
@@ -60,15 +119,20 @@ namespace Config.Entities
             result += indent + "ItemNr = " + (ItemNr + 1).ToString() + Environment.NewLine;
             result += indent + "Name = " + Name + Environment.NewLine;
 			result += indent + "ClassName = " + ClassName + Environment.NewLine;
-			if (ParentName != null)
+			if (Parent != null)
 			{
-				result += indent + "ParentName = " + ParentName + Environment.NewLine;
+				result += indent + "ParentName = " + Parent + Environment.NewLine;
 			}
-			result += indent + "DebugLevel = " + Mode.ToString() + Environment.NewLine;
-			result += indent + "LogLevel = " + Logging.ToString() + Environment.NewLine;
+			result += indent + "DebugLevel = " + DebugMode.ToString() + Environment.NewLine;
+			result += indent + "LogLevel = " + LogLevel.ToString() + Environment.NewLine;
 			result += indent + "Parameters = " + Parameters + Environment.NewLine;
 
 			return result;
 		}
+
+        public override string ToString()
+        {
+            return string.Format("{0} ({1})", Name, ClassName);
+        }
 	}
 }

Config/Entities/ComponentProcedure.cs

@@ -1,6 +1,10 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
+using System;
+using System.IO;
+using Common;
+
 namespace Config.Entities
 {
 	public class ComponentProcedure
@@ -10,13 +14,49 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Procedure Procedure { get; set; }
 
-		public virtual ComponentProcedure Clone()
+        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 = Procedure;
-			return result;
+            return new ComponentProcedure(CmpntName, Parameters, newProcedure);
 		}
+
+        public virtual void Export(StreamWriter output)
+        {
+            output.WriteLine(CmpntName);
+            output.WriteLine(Parameters.Replace(Environment.NewLine, "~"));
+        }
+
+        public static ComponentProcedure Import(StreamReader input, Procedure newProcedure)
+        {
+            string firstLine = input.ReadLine();
+
+            if (string.IsNullOrEmpty(firstLine)) return null;
+
+            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,6 +1,10 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
+using System;
+using System.IO;
+using Common;
+
 namespace Config.Entities
 {
 	public class ComponentTest
@@ -10,13 +14,49 @@ 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)
+        {
+            output.WriteLine(CmpntName);
+            output.WriteLine(Parameters.Replace(Environment.NewLine, "~"));
+        }
+
+        public static ComponentTest Import(StreamReader input, Test newTest)
+        {
+            string firstLine = input.ReadLine();
+
+            if (string.IsNullOrEmpty(firstLine)) return null;
+
+            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,290 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-
-namespace Config.Entities
-{
-    /// <summary>
-    /// Helper class to assign descriptions to enum values
-    /// </summary>
-    public class Description : Attribute
-    {
-        public string Text;
-        public Description(string t)
-        {
-            Text = t;
-        }
-    }
-
-    public static class GetDescription
-    {
-        /// Extension method for enum-s
-        public static string ToDescription(this Enum en)
-        {
-            Type type = en.GetType();
-            MemberInfo[] memInfo = type.GetMember(en.ToString());
-
-            if (memInfo != null && memInfo.Length > 0)
-            {
-                object[] attrs = memInfo[0].GetCustomAttributes(typeof(Description), false);
-                if (attrs != null && attrs.Length > 0)
-                    return ((Description)attrs[0]).Text;
-            }
-
-            return en.ToString();   /// Return ToString() value in case there is no description
-        }
-    }
-
-	/// <summary> Identifies the type of a database </summary>
-	public enum DBType
-	{
-		MySql,              /// MySQL database
-		SQLite,             /// SQLite
-		DbTypesCount,
-	}
-
-	/// <summary> Identifies the database based on the content </summary>
-	public enum DBKind
-	{
-		Config,
-		Results,
-		Count,
-	}
-
-	public enum ProcedureState
-	{
-		Active,
-		History,
-		Template,
-		Count,
-	}
-
-	/// <summary> Kind of meters for the procedure / test </summary>
-	public enum MetersKind
-	{
-		Single,
-		Combined,
-        HeatMeter,
-	}
-
-	public enum CompoundMeterId : byte
-	{
-		Single,
-		CompoundMain,
-		CompoundAux,
-		Compound,
-	}
-
-	public enum Medium
-	{
-        [Description("")]  NotSpecified,
-		ColdWater,
-		HotWater,
-        Count
-    }
-
-    public enum Mounting
-    {
-        [Description("")]  NotSpecified,
-        [Description("H")] H,              /// horizontal
-        [Description("V")] V,              /// vertical
-        [Description("S")] S,              /// steig
-        [Description("F")] F,              /// fall
-        Count
-    }
-
-    public enum TemperatureClass
-    {
-        [Description("")]        NotSpecified,
-        [Description("T30")]     T30,
-        [Description("T50")]     T50,
-        [Description("T70")]     T70,
-        [Description("T90")]     T90,
-        [Description("T130")]    T130,
-        [Description("T180")]    T180,
-        [Description("T30/70")]  T30_70,
-        [Description("T30/90")]  T30_90,
-        [Description("T30/130")] T30_130,
-        [Description("T30/180")] T30_180,
-        [Description("30")]      t30,
-        [Description("50")]      t50,
-        [Description("70")]      t70,
-        [Description("90")]      t90,
-        [Description("130")]     t130,
-        [Description("180")]     t180,
-        Count
-    }
-
-    public enum FlowProfileSensitivityClass
-    {
-        [Description("")]   NotSpecified,
-        [Description("U0")] U0,              /// ?
-        [Description("D0")] D0,              /// ?
-        Count
-    }
-
-    public enum PressureLossClass
-    {
-        [Description("")]     NotSpecified,
-        [Description("dp63")] dp63,           /// 0.063 MPa = 0.63 bar, TODO: Change to "Δp63"
-        [Description("dp40")] dp40,           /// 0.040 MPa = 0.40 bar
-        [Description("dp25")] dp25,           /// 0.025 MPa = 0.25 bar
-        [Description("dp16")] dp16,           /// 0.016 MPa = 0.16 bar
-        [Description("dp10")] dp10,           /// 0.010 MPa = 0.10 bar
-        Count
-    }
-
-    /// <summary> Maximum Admissible Pressure </summary>
-    public enum MaxAdmissiblePressure
-    {
-        [Description("")]      NotSpecified,
-        [Description("MAP6")]  MAP6,
-        [Description("MAP10")] MAP10,
-        [Description("MAP16")] MAP16,
-        [Description("MAP25")] MAP25,
-        [Description("MAP40")] MAP40,
-        Count
-    }
-
-	/// <summary> Transition step is finished when this condition is fulfilled </summary>
-	public enum StepCondition
-	{
-		None,
-		Scale1Empty,
-		Scale2Empty,
-		Scale3Empty,
-		AllScalesEmpty,
-		Count
-	}
-
-	public enum Publish : sbyte
-	{
-#if MUNICH
-        /// nemecky
-        [Description("nie")]          Never = 0,
-        [Description("immer")]        Always = 1,
-        [Description("Bildschirm")]   OnScreen = 2,
-        [Description("intern")]       Internal = 3,
-#elif CEVAK || BADGER_MALA_TRAT || BADGER_VELKA_TRAT
-        /// cesky
-        [Description("nikdy")]        Never = 0,
-        [Description("vždy")]         Always = 1,
-        [Description("na obrazovku")] OnScreen = 2,
-        [Description("interně")]      Internal = 3,
-#elif IPERLST || IPERLST_SPECIAL || SLM_50
-        /// slovensky
-        [Description("nikdy")]        Never = 0,
-        [Description("vždy")]         Always = 1,
-        [Description("na obrazovku")] OnScreen = 2,
-        [Description("interne")]      Internal = 3,
-#else
-        [Description("Never")]        Never = 0,
-        [Description("Always")]       Always = 1,
-        [Description("On screen")]    OnScreen = 2,
-        [Description("Internal")]     Internal = 3,
-#endif
-        Count
-	}
-
-    public enum TestRedType
-    {
-        Fix,
-        /// etc.
-		Count,
-	}
-
-    public enum FQC1
-    {
-        FQC1,
-        FQP1,
-		Count,
-	}
-
-	public enum Progress
-	{
-		JustStarted,
-		TransitionBefore,
-		SwitchingFlowDetection,
-		FlowSetting,
-		Test,
-		TransitionAfter,
-		Completed,
-		Count,
-	}
-
-	public enum Device
-	{
-		Screen,
-		Printer,
-		Disk,
-	}
-
-	public enum PageOrientation
-	{
-		Portrait,
-		Landscape,
-		Count,
-	}
-
-	public enum UnitsVolume
-	{
-		Liter,
-		CubicMtr,
-	}
-
-	/// <summary> Possible modes of operation of components and devices. </summary>
-	public enum DebugMode
-    {
-		DetectedOff = -2,
-		DetectedOn = -1,
-        Normal = 0,				/// Normal operation
-		AutoDetect,				/// The component (device) will be auto-detected
-		FailureDuringOperation,	/// Failure during operation -> disabled 
-		Off,					/// The component is off
-        Record,
-        Reply,
-        Simulate,				/// Test bench simulation, this mode does not require any hardware
-		Inherit,
-		Count,
-    }
-
-    public enum LogLevel
-    {
-        Off,
-        Fatal,
-        Error,
-        Warn,
-        Info,
-        Debug,
-        All,
-        Count,
-    }
-
-
-	/// <summary> Arrangement of tests </summary>
-	public enum TestsArrangement
-	{
-		Rows,
-		Columns,
-	}
-
-	/// <summary> Arrangement of meters </summary>
-	public enum MetersArrangement
-	{
-		Vertically,
-		Horizontally,
-	}
-
-    public enum Alignment
-    {
-        Left,
-        Center,
-        Right,
-        Justified,
-        Count
-    }
-}
-

Config/Entities/FeedingPath.cs

@@ -1,24 +1,32 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using Common;
 
 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 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 double Qfrom { get; set; }           /// Water flow in [m3/h]
+        public virtual double Qto { get; set; }             /// Water flow in [m3/h]
+        public virtual Unit   FlowUnit { get; set; }        /// Not mapped to database, used in UI
+        public virtual string Selector { get; set; }
 		public virtual string Pump { get; set; }
+        public virtual string RegVPositions { get; set; }	/// Positions of regulation valves in Category.Feeding in % separated by ';'
 
-        /// Valves		
+        /// Valves
 		public virtual string ValvesOpen { get; set; }
 		public virtual string ValvesClose { get; set; }
 
+        public virtual bool QfromTextChngd { get; set; }    /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool QtoTextChngd { get; set; }      /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+
         /// ------------- Additional stuff not mapped into the database -------------
 
 		public FeedingPath()
@@ -38,11 +46,14 @@ namespace Config.Entities
         {
 			FeedingPath result = new FeedingPath(name, itemNr);
 
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.Pump = Pump;
-			result.ValvesOpen = ValvesOpen;
-			result.ValvesClose = ValvesClose;
+			result.Qfrom         = Qfrom;
+            result.Qto           = Qto;
+            result.FlowUnit      = FlowUnit;
+            result.Selector      = Selector;
+			result.Pump          = Pump;
+            result.RegVPositions = RegVPositions;
+            result.ValvesOpen    = ValvesOpen;
+			result.ValvesClose   = ValvesClose;
 
             return result;
         }

Config/Entities/Group.cs

@@ -1,15 +1,28 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using Common;
 
 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 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(GID gid)
+            : this()
+        {
+			GID = gid;
+		}
     }
 }

Config/Entities/HeatMetersPath.cs

@@ -0,0 +1,65 @@
+///
+/// Copyright (c) 2016-2017 Sensus Metering Systems
+///
+using System;
+
+namespace Config.Entities
+{
+	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]
+        public virtual float TempColdFrom { get; set; }     /// Cold temperature range from [°C]
+        public virtual float TempColdTo { get; set; }       /// Cold temperature renge to [°C]
+
+        public virtual string TMeterRefWarm1 { get; set; }
+		public virtual string TMeterRefWarm2 { get; set; }
+		public virtual string TMeterRefCold1 { get; set; }
+		public virtual string TMeterRefCold2 { get; set; }
+
+        public virtual string TMeterWorkWarm1 { get; set; }
+        public virtual string TMeterWorkWarm2 { get; set; }
+        public virtual string TMeterWorkCold1 { get; set; }
+        public virtual string TMeterWorkCold2 { get; set; }
+
+        /// ------------- Additional stuff not mapped into the database -------------
+
+		public HeatMetersPath()
+        {
+		}
+
+		public HeatMetersPath(string name, int itemNr)
+			: this()
+		{
+			Name = name;
+			ItemNr = itemNr;
+		}
+
+		public virtual HeatMetersPath Clone(string name, int itemNr)
+        {
+			HeatMetersPath result = new HeatMetersPath(name, itemNr);
+
+            result.TempWarmFrom = TempWarmFrom;
+            result.TempWarmTo = TempWarmTo;
+            result.TempColdFrom = TempColdFrom;
+            result.TempColdTo = TempColdTo;
+
+            result.TMeterRefWarm1 = TMeterRefWarm1;
+			result.TMeterRefWarm2 = TMeterRefWarm2;
+			result.TMeterRefCold1 = TMeterRefCold1;
+			result.TMeterRefCold2 = TMeterRefCold2;
+
+            result.TMeterWorkWarm1 = TMeterWorkWarm1;
+            result.TMeterWorkWarm2 = TMeterWorkWarm2;
+            result.TMeterWorkCold1 = TMeterWorkCold1;
+            result.TMeterWorkCold2 = TMeterWorkCold2;
+
+            return result;
+        }
+    }
+}

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/MeasurementCorrection.cs

@@ -1,14 +1,90 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using System;
+using System.Collections.Generic;
 
 namespace Config.Entities
 {
-	public class MeasurementCorrection
+    public class MeasurementCorrection : Common.IMeasurementCorrection, IComparable<MeasurementCorrection>
 	{
 		public virtual int Id { get; protected set; }
-		public virtual float Measurement { get; set; }
-		public virtual float Correction { get; set; }
-	}
+        public virtual int RangeIx { get; set; }        /// 0..5
+		public virtual double Measurement { get; set; }
+		public virtual double Correction { get; set; }
+
+        public MeasurementCorrection()
+        {
+            RangeIx = 0; 
+        }
+
+        public MeasurementCorrection(int rangeIx)
+        {
+            RangeIx = rangeIx; 
+        }
+
+        public virtual int CompareTo(MeasurementCorrection other)
+        {
+            return (Measurement > other.Measurement) ? 1 : ((Measurement == other.Measurement) ? 0 : -1);
+        }
+
+
+        /// <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<MeasurementCorrection> corrections)
+        {
+            return rawValue + GetCorrection(rawValue, corrections);
+        }
+
+        /// <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<MeasurementCorrection> corrections)
+        {
+            if ((corrections == null) || (corrections.Count == 0)) return 0;    /// No correction
+
+            if (rawValue < corrections[0].Measurement)
+            {
+                /// rawValue is below the lowest value in the correction table
+                return corrections[0].Correction;
+            }
+
+            for (int i = 1; i < corrections.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[corrections.Count - 1].Correction;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("{0} {1} ({2})", Measurement, Correction, 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,29 +1,28 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 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 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
 
         /// Sensors
-		public virtual string Sensor1 { get; set; }
-		public virtual string Sensor2 { get; set; }
-		public virtual string Sensor3 { get; set; }
-		public virtual string Sensor4 { get; set; }
-		public virtual string Sensor5 { get; set; }
-		public virtual string Sensor6 { get; set; }
-		public virtual string Sensor7 { get; set; }
-		public virtual string Sensor8 { get; set; }
-		public virtual string Sensor9 { get; set; }
+		public virtual string Sensor1  { get; set; }
+		public virtual string Sensor2  { get; set; }
+		public virtual string Sensor3  { get; set; }
+		public virtual string Sensor4  { get; set; }
+		public virtual string Sensor5  { get; set; }
+		public virtual string Sensor6  { get; set; }
+		public virtual string Sensor7  { get; set; }
+		public virtual string Sensor8  { get; set; }
+		public virtual string Sensor9  { get; set; }
 		public virtual string Sensor10 { get; set; }
 		public virtual string Sensor11 { get; set; }
 		public virtual string Sensor12 { get; set; }
@@ -35,28 +34,6 @@ namespace Config.Entities
 		public virtual string Sensor18 { get; set; }
 		public virtual string Sensor19 { get; set; }
 		public virtual string Sensor20 { get; set; }
-#if IPERLST
-        public virtual string Sensor21 { get; set; }
-        public virtual string Sensor22 { get; set; }
-        public virtual string Sensor23 { get; set; }
-        public virtual string Sensor24 { get; set; }
-        public virtual string Sensor25 { get; set; }
-        public virtual string Sensor26 { get; set; }
-        public virtual string Sensor27 { get; set; }
-        public virtual string Sensor28 { get; set; }
-        public virtual string Sensor29 { get; set; }
-        public virtual string Sensor30 { get; set; }
-        public virtual string Sensor31 { get; set; }
-        public virtual string Sensor32 { get; set; }
-        public virtual string Sensor33 { get; set; }
-        public virtual string Sensor34 { get; set; }
-        public virtual string Sensor35 { get; set; }
-        public virtual string Sensor36 { get; set; }
-        public virtual string Sensor37 { get; set; }
-        public virtual string Sensor38 { get; set; }
-        public virtual string Sensor39 { get; set; }
-        public virtual string Sensor40 { get; set; }
-#endif
 
         /// ------------- Additional stuff not mapped into the database -------------
 
@@ -74,17 +51,15 @@ namespace Config.Entities
 		public virtual MetersPath Clone(string name, int itemNr)
         {
             MetersPath result = new MetersPath(name, itemNr);
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.Sensor1 = Sensor1;
-			result.Sensor2 = Sensor2;
-			result.Sensor3 = Sensor3;
-			result.Sensor4 = Sensor4;
-            result.Sensor5 = Sensor5;
-            result.Sensor6 = Sensor6;
-            result.Sensor7 = Sensor7;
-            result.Sensor8 = Sensor8;
-            result.Sensor9 = Sensor9;
+			result.Sensor1  = Sensor1;
+			result.Sensor2  = Sensor2;
+			result.Sensor3  = Sensor3;
+			result.Sensor4  = Sensor4;
+            result.Sensor5  = Sensor5;
+            result.Sensor6  = Sensor6;
+            result.Sensor7  = Sensor7;
+            result.Sensor8  = Sensor8;
+            result.Sensor9  = Sensor9;
             result.Sensor10 = Sensor10;
             result.Sensor11 = Sensor11;
             result.Sensor12 = Sensor12;
@@ -96,124 +71,59 @@ namespace Config.Entities
             result.Sensor18 = Sensor18;
             result.Sensor19 = Sensor19;
             result.Sensor20 = Sensor20;
-#if IPERLST
-            result.Sensor21 = Sensor21;
-            result.Sensor22 = Sensor22;
-            result.Sensor23 = Sensor23;
-            result.Sensor24 = Sensor24;
-            result.Sensor25 = Sensor25;
-            result.Sensor26 = Sensor26;
-            result.Sensor27 = Sensor27;
-            result.Sensor28 = Sensor28;
-            result.Sensor29 = Sensor29;
-            result.Sensor30 = Sensor30;
-            result.Sensor31 = Sensor31;
-            result.Sensor32 = Sensor32;
-            result.Sensor33 = Sensor33;
-            result.Sensor34 = Sensor34;
-            result.Sensor35 = Sensor35;
-            result.Sensor36 = Sensor36;
-            result.Sensor37 = Sensor37;
-            result.Sensor38 = Sensor38;
-            result.Sensor39 = Sensor39;
-            result.Sensor40 = Sensor40;
-#endif
+
             return result;
         }
 
         /// Returns the component name
-        public virtual string GetSensor(int i)
+        public virtual string GetSensor(int wmNr0)
         {
-            if (i == 0) return Sensor1;
-            else if (i == 1) return Sensor2;
-            else if (i == 2) return Sensor3;
-            else if (i == 3) return Sensor4;
-            else if (i == 4) return Sensor5;
-            else if (i == 5) return Sensor6;
-            else if (i == 6) return Sensor7;
-            else if (i == 7) return Sensor8;
-            else if (i == 8) return Sensor9;
-            else if (i == 9) return Sensor10;
-            else if (i == 10) return Sensor11;
-            else if (i == 11) return Sensor12;
-            else if (i == 12) return Sensor13;
-            else if (i == 13) return Sensor14;
-            else if (i == 14) return Sensor15;
-            else if (i == 15) return Sensor16;
-            else if (i == 16) return Sensor17;
-            else if (i == 17) return Sensor18;
-            else if (i == 18) return Sensor19;
-            else if (i == 19) return Sensor20;
-#if IPERLST
-            else if (i == 20) return Sensor21;
-            else if (i == 21) return Sensor22;
-            else if (i == 22) return Sensor23;
-            else if (i == 23) return Sensor24;
-            else if (i == 24) return Sensor25;
-            else if (i == 25) return Sensor26;
-            else if (i == 26) return Sensor27;
-            else if (i == 27) return Sensor28;
-            else if (i == 28) return Sensor29;
-            else if (i == 29) return Sensor30;
-            else if (i == 30) return Sensor31;
-            else if (i == 31) return Sensor32;
-            else if (i == 32) return Sensor33;
-            else if (i == 33) return Sensor34;
-            else if (i == 34) return Sensor35;
-            else if (i == 35) return Sensor36;
-            else if (i == 36) return Sensor37;
-            else if (i == 37) return Sensor38;
-            else if (i == 38) return Sensor39;
-            else if (i == 39) return Sensor40;
-#endif
+            if      (wmNr0 == 0)  return Sensor1;
+            else if (wmNr0 == 1)  return Sensor2;
+            else if (wmNr0 == 2)  return Sensor3;
+            else if (wmNr0 == 3)  return Sensor4;
+            else if (wmNr0 == 4)  return Sensor5;
+            else if (wmNr0 == 5)  return Sensor6;
+            else if (wmNr0 == 6)  return Sensor7;
+            else if (wmNr0 == 7)  return Sensor8;
+            else if (wmNr0 == 8)  return Sensor9;
+            else if (wmNr0 == 9)  return Sensor10;
+            else if (wmNr0 == 10) return Sensor11;
+            else if (wmNr0 == 11) return Sensor12;
+            else if (wmNr0 == 12) return Sensor13;
+            else if (wmNr0 == 13) return Sensor14;
+            else if (wmNr0 == 14) return Sensor15;
+            else if (wmNr0 == 15) return Sensor16;
+            else if (wmNr0 == 16) return Sensor17;
+            else if (wmNr0 == 17) return Sensor18;
+            else if (wmNr0 == 18) return Sensor19;
+            else if (wmNr0 == 19) return Sensor20;
             else return null;
         }
 
         /// Sets the component name
-        public virtual void SetSensor(int i, string cmpntName)
+        public virtual void SetSensor(int wmNr0, string cmpntName)
         {
-            if (i == 0) Sensor1 = cmpntName;
-            else if (i == 1) Sensor2 = cmpntName;
-            else if (i == 2) Sensor3 = cmpntName;
-            else if (i == 3) Sensor4 = cmpntName;
-            else if (i == 4) Sensor5 = cmpntName;
-            else if (i == 5) Sensor6 = cmpntName;
-            else if (i == 6) Sensor7 = cmpntName;
-            else if (i == 7) Sensor8 = cmpntName;
-            else if (i == 8) Sensor9 = cmpntName;
-            else if (i == 9) Sensor10 = cmpntName;
-            else if (i == 10) Sensor11 = cmpntName;
-            else if (i == 11) Sensor12 = cmpntName;
-            else if (i == 12) Sensor13 = cmpntName;
-            else if (i == 13) Sensor14 = cmpntName;
-            else if (i == 14) Sensor15 = cmpntName;
-            else if (i == 15) Sensor16 = cmpntName;
-            else if (i == 16) Sensor17 = cmpntName;
-            else if (i == 17) Sensor18 = cmpntName;
-            else if (i == 18) Sensor19 = cmpntName;
-            else if (i == 19) Sensor20 = cmpntName;
-#if IPERLST
-            else if (i == 20) Sensor21 = cmpntName;
-            else if (i == 21) Sensor22 = cmpntName;
-            else if (i == 22) Sensor23 = cmpntName;
-            else if (i == 23) Sensor24 = cmpntName;
-            else if (i == 24) Sensor25 = cmpntName;
-            else if (i == 25) Sensor26 = cmpntName;
-            else if (i == 26) Sensor27 = cmpntName;
-            else if (i == 27) Sensor28 = cmpntName;
-            else if (i == 28) Sensor29 = cmpntName;
-            else if (i == 29) Sensor30 = cmpntName;
-            else if (i == 30) Sensor31 = cmpntName;
-            else if (i == 31) Sensor32 = cmpntName;
-            else if (i == 32) Sensor33 = cmpntName;
-            else if (i == 33) Sensor34 = cmpntName;
-            else if (i == 34) Sensor35 = cmpntName;
-            else if (i == 35) Sensor36 = cmpntName;
-            else if (i == 36) Sensor37 = cmpntName;
-            else if (i == 37) Sensor38 = cmpntName;
-            else if (i == 38) Sensor39 = cmpntName;
-            else if (i == 39) Sensor40 = cmpntName;
-#endif
+            if      (wmNr0 == 0)  Sensor1  = cmpntName;
+            else if (wmNr0 == 1)  Sensor2  = cmpntName;
+            else if (wmNr0 == 2)  Sensor3  = cmpntName;
+            else if (wmNr0 == 3)  Sensor4  = cmpntName;
+            else if (wmNr0 == 4)  Sensor5  = cmpntName;
+            else if (wmNr0 == 5)  Sensor6  = cmpntName;
+            else if (wmNr0 == 6)  Sensor7  = cmpntName;
+            else if (wmNr0 == 7)  Sensor8  = cmpntName;
+            else if (wmNr0 == 8)  Sensor9  = cmpntName;
+            else if (wmNr0 == 9)  Sensor10 = cmpntName;
+            else if (wmNr0 == 10) Sensor11 = cmpntName;
+            else if (wmNr0 == 11) Sensor12 = cmpntName;
+            else if (wmNr0 == 12) Sensor13 = cmpntName;
+            else if (wmNr0 == 13) Sensor14 = cmpntName;
+            else if (wmNr0 == 14) Sensor15 = cmpntName;
+            else if (wmNr0 == 15) Sensor16 = cmpntName;
+            else if (wmNr0 == 16) Sensor17 = cmpntName;
+            else if (wmNr0 == 17) Sensor18 = cmpntName;
+            else if (wmNr0 == 18) Sensor19 = cmpntName;
+            else if (wmNr0 == 19) Sensor20 = cmpntName;
         }
     }
 }

Config/Entities/OutputPath.cs

@@ -1,38 +1,45 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using Common;
 
 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 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 RegulValve { get; set; }
+        public virtual string OriName { get; set; }         /// Not mapped to database
+        public virtual double Qfrom { get; set; }			/// Water flow in [m3/h]
+        public virtual double Qto { get; set; }				/// Water flow in [m3/h]
+        public virtual Unit   FlowUnit { get; set; }        /// Not mapped to database, used in UI
+        public virtual string Selector { get; set; }
+        public virtual string RegValve { get; set; }
 		public virtual string FlowMeter { get; set; }
-		public virtual float PidCoef { get; set; }		/// PID coefficient for the regulation path
+		public virtual float  PidCoef { get; set; }			/// PID coefficient for the regulation path
         public virtual string StartValve { get; set; }
         public virtual string Diverter { get; set; }
-		public virtual string TempDiv { get; set; }
-		public virtual string Balance { get; set; }
-		public virtual string EmptyTankValve { get; set; }
+		public virtual string TempMtrDiv { get; set; }
+		public virtual string Scale { get; set; }
+        public virtual string RegVPositions { get; set; }	/// Positions of regulation valves in Category.Output in % separated by ';'
 
         /// Valves		
 		public virtual string ValvesOpen { get; set; }
 		public virtual string ValvesClose { get; set; }
 
+        public virtual bool QfromTextChngd { get; set; }    /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool QtoTextChngd { get; set; }      /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+
         /// ------------- Additional stuff not mapped into the database -------------
 
 		public OutputPath()
         {
 			ValvesOpen = string.Empty;
 			ValvesClose = string.Empty;
-		}
+        }
 
 		public OutputPath(string name, int itemNr)
 			: this()
@@ -45,18 +52,20 @@ namespace Config.Entities
         {
 			OutputPath result = new OutputPath(name, itemNr);
 
-			result.Name = Name;
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.RegulValve = RegulValve;
-			result.FlowMeter = FlowMeter;
-			result.PidCoef = PidCoef;
-            result.StartValve = StartValve;
-			result.Diverter = Diverter;
-			result.TempDiv = TempDiv;
-			result.Balance = Balance;
-			result.EmptyTankValve = EmptyTankValve;
-			result.ValvesOpen = ValvesOpen;
+			result.Name        = Name;
+			result.Qfrom       = Qfrom;
+            result.Qto         = Qto;
+            result.FlowUnit    = FlowUnit;
+            result.Selector    = Selector;
+            result.RegValve    = RegValve;
+			result.FlowMeter   = FlowMeter;
+			result.PidCoef     = PidCoef;
+            result.StartValve  = StartValve;
+			result.Diverter    = Diverter;
+			result.TempMtrDiv  = TempMtrDiv;
+			result.Scale       = Scale;
+            result.RegVPositions= RegVPositions;
+			result.ValvesOpen  = ValvesOpen;
 			result.ValvesClose = ValvesClose;
 
             return result;

Config/Entities/PTest.cs

@@ -0,0 +1,367 @@
+///
+/// Copyright (c) 2019-2023 Sensus Slovensko a.s.
+///
+using System;
+using System.Globalization;
+using System.IO;
+using Common;
+
+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 FlowId FlowId { get; set; }
+        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 string Method { get; set; }              /// Test method (component name)
+
+        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)Common.Publish.Always;
+            Evaluate = true;
+            Method = string.Empty;
+
+            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.Method = Method;
+
+            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(((ushort)FlowId).ToString(ci));
+            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(Method);
+
+            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.FlowId = (FlowId)ushort.Parse(input.ReadLine(), ci);
+            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.PressLimLo = double.Parse(input.ReadLine(), ci);
+            tst.PressLimHi = double.Parse(input.ReadLine(), ci);
+            tst.Publish = sbyte.Parse(input.ReadLine(), ci);
+            tst.Evaluate = bool.Parse(input.ReadLine());
+            tst.Method = input.ReadLine();
+
+            tst.E1 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E2 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E3 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E4 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E5 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E6 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E7 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E8 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E9 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E10 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E11 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E12 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E13 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E14 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E15 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E16 = sbyte.Parse(input.ReadLine(), ci);
+            tst.E21 = sbyte.Parse(input.ReadLine(), ci);
+
+            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 != ((ushort)FlowId).ToString()){diff.AppendFormat(fmt, "FlowId", ((ushort)FlowId).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 != Method)                    { diff.AppendFormat(fmt, "Method", Method, 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,15 +1,18 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2023 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Common;
 
 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; }
@@ -25,23 +28,41 @@ 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 double 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; }
 
-        ////public virtual string MetrologicalClass { get; set; }
-        ////public virtual IList<WMType> WMTypes { get; set; }
+        TestInstance[] testInstances;
+
+        /// Wrapper
+        public virtual IList<Test> RegularTests()
+        {
+            IList<Test> rslt = new List<Test>();
+            foreach (var t in Tests) if (t.IsRegular()) rslt.Add(t);
+            return rslt;
+        }
 
         /// ------------- Additional stuff not mapped into the database -------------
 
@@ -49,16 +70,24 @@ namespace Config.Entities
         {
 			MoreParams = new List<ComponentProcedure>();
 			Tests = new List<Test>();
+            testInstances = null;
 
 			///
 			/// Default values
 			/// 
-			CreationUser = (User.CurrentUser != null) ? User.CurrentUser.Name : null;
+            CreationUser = Common.CurrentUser.UserName();
 			CreationTime = DateTime.Now;
 			LastChgUser = CreationUser;
 			LastChgTime = CreationTime;
-			MetersKind = Entities.MetersKind.Single;
-			ProtocolTitle = "Watermeter test protocol";
+			MetersKind = MetersKind.Single;
+			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)
@@ -68,38 +97,275 @@ namespace Config.Entities
 			ItemNr = itemNr;
 		}
 
+        public virtual TestInstance[] UpdateTestInstances(IList<string> loopStartNames, IList<string> loopEndNames, IList<string> autoTests = null)
+        {
+            List<TestInstance> instances = new List<TestInstance>();
+
+            if (Tests != null)
+            {
+                int i = 0;
+                while (i < Tests.Count)
+                {
+                    if (!loopStartNames.Contains(Tests[i].Method) && !loopEndNames.Contains(Tests[i].Method))   /// Loop.End is ignored outside a loop
+                    {
+                        ///
+                        /// Outside a loop
+                        ///
+                        for (int j = 1; j <= Tests[i].Repeats; j++)
+                            if (Tests[i].BelongsTo(autoTests))
+                                instances.Add(new TestInstance(Tests[i], j));
+                    }
+                    else if (loopStartNames.Contains(Tests[i].Method))
+                    {
+                        ///
+                        /// Entering a loop
+                        ///
+                        int loopsCount = Tests[i].Repeats;
+                        List<Test> testsInsideLoop = new List<Test>();
+                        i++;
+
+                        while (i < Tests.Count && !loopEndNames.Contains(Tests[i].Method))
+                        {
+                            ///
+                            /// Inside a loop
+                            ///
+                            if (Tests[i].Repeats == loopsCount && !loopStartNames.Contains(Tests[i].Method))    /// Loop.Start is ignored inside a loop
+                            {
+                                if (Tests[i].BelongsTo(autoTests))
+                                    testsInsideLoop.Add(Tests[i]);
+                            }
+
+                            i++;
+                        }
+
+                        ///
+                        /// Append instances of tests inside the last loop to the list
+                        ///
+                        for (int j = 1; j <= loopsCount; j++)
+                        {
+                            foreach (var t in testsInsideLoop)
+                                instances.Add(new TestInstance(t, j));
+                        }
+                    }
+
+                    i++;
+                }
+            }
+
+            testInstances = instances.ToArray();
+            return testInstances;
+        }
+
+        public virtual TestInstance[] GetTestInstances()
+        {
+            return testInstances;
+        }
+
         public virtual Procedure Clone()
         {
             Procedure result = new Procedure();
 
+			result.ItemNr = ItemNr;
 			result.Name = Name;
-			result.MetersKind = MetersKind;
 			result.Description = Description;
 			result.CreationUser = CreationUser;
 			result.CreationTime = CreationTime;
 			result.LastChgUser = LastChgUser;
 			result.LastChgTime = LastChgTime;
 			result.LongDescription = LongDescription;
-
-			result.ProcedureState = ProcedureState.Active;
+			result.ProcedureState = ProcedureState;
+			result.Revision = Revision;
 			result.PredecessorId = Id;
-
+			result.ObtainedByCopy = ObtainedByCopy;
+			result.MetersKind = MetersKind;
 			result.Watermeters = Watermeters;
+            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;
 
-			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
+            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()); }
 
-			//result.MetrologicalClass = MetrologicalClass;
-            //result.WMType = WMType.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));
+			output.WriteLine(MetersKind.ToString());
+            output.WriteLine(Watermeters);
+            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);
+
+            foreach (var prms in MoreParams) { prms.Export(output); }
+            output.WriteLine();
+
+            foreach (var test in Tests) { test.Export(output); }
+            output.WriteLine();
+
+            output.Close();
+        }
+
+        public static Procedure Import(StreamReader input)
+        {
+            Procedure result = new Procedure();
+
+			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();
+            result.MetersKind = line.Equals(MetersKind.Single.ToString()) ? MetersKind.Single : (line.Equals(MetersKind.Combined.ToString()) ? MetersKind.Combined : MetersKind.HeatMeter);
+            result.Watermeters = 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();
+
+            while(true)
+            {
+                ComponentProcedure prms = ComponentProcedure.Import(input, result);
+                if (prms == null)
+                    break;
+                else
+                    result.MoreParams.Add(prms);
+            }
+
+            while (true)
+            {
+                Test tst = Test.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
+            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,147 @@
+///
+/// Copyright (c) 2019 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Common;
+
+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 = CurrentUser.UserName();
+			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));
+            output.WriteLine(((sbyte)ProfileType).ToString());
+            output.WriteLine(((sbyte)ErrorLimitType).ToString());
+
+            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);
+            result.ProfileType = (ProfileType)sbyte.Parse(input.ReadLine());
+            result.ErrorLimitType = (ErrorLimitType)sbyte.Parse(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,62 +1,94 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-/// Author: Milan Hanajik
+/// Copyright (c) 2013-2023 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Common;
 
 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, UserDefinedCompound, UserDefinedHeatMeter, Protected, ProtectedCompound, 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 double Qtg { get; set; }             /// When == -1 => Qtg is determined by the test method, otherwise Qtg is in [m3/h], 
+        public virtual double Qfrom { get; set; }			/// Water flow low limit in [m3/h] or in [%] of Qtg
+        public virtual double Qto { get; set; }				/// Water flow high limit in [m3/h] or in [%] of Qtg
+        public virtual bool IsFromToInPct { get; set; }     /// true: Qfrom and Qto are in % of Qtg, false: Qfrom and Qto are in [m3/h]
+		public virtual double Volume { get; set; }			/// Test volume (target) in [l]
+        public virtual double TestTime { 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 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 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
-        public virtual bool MassMethod { get; set; }    /// method of mass. measurement at the beginning/end of test: false=slow (precise), true=fast (immediate)
-        public virtual int TimeBeforeFlow { get; set; } /// Delay time before the start of flow control in [s]
-        public virtual int TimeFlow2Mass { get; set; }	/// Delay time from the flow stable to the 1st mass measurement in [s]
-        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 bool DoDraining { get; set; }
+        public virtual bool DoDrainingAfter { 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 string TempControl { get; set; }     /// Water temperature controller, null or empty = Do not control water temp
+        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
+		public virtual MassMethod MassMethod { get; set; }	/// method of mass. measurement at the beginning/end of test: false=slow (precise), true=using immediate mass measurement and evaluation
+        public virtual int TimeBeforeFlow { get; set; }		/// Delay time before the start of flow control in [s]
+        public virtual int TimeFlow2Mass { get; set; }		/// Delay time from the flow stable to the 1st mass measurement in [s]
+        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 int ShortPulses { get; set; }		/// Short pulses
 		public virtual string FeedingPath { get; set; }
 		public virtual string BenchPath { get; set; }
 		public virtual string OutputPath { get; set; }
 		public virtual string MetersPath { get; set; }
-#if HEAT_METERS_SUPPORT
+#if HEAT_METERS
         public virtual string HeatMetersPath { get; set; }
 #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 string TransBefore { get; set; }
+		public virtual string TransBetween { get; set; }
+		public virtual string TransAfter { get; set; }
 
-		public virtual IList<ComponentTest> MoreParams { get; set; }
+        public virtual IList<ComponentTest> MoreParams { get; set; }
 
-		public virtual Procedure Procedure { get; set; }
+        public virtual Procedure Procedure { get; set; }
 
-        /// ------------- Additional stuff not mapped into the database -------------
+        /// Additional stuff not mapped into the database
+        public virtual bool IsOuterLoopStart { get; set; }   /// Not mapped to database
+        public virtual bool IsOuterLoopEnd { get; set; }     /// Not mapped to database
+
+        public virtual bool QtgTextChngd { get; set; }       /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool QfromTextChngd { get; set; }     /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool QtoTextChngd { get; set; }       /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool VolumeTextChngd { get; set; }    /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool TempLimLoTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual bool TempLimHiTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit VolumeUnit { get; set; }         /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit FlowUnit { get; set; }           /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit MassUnit { get; set; }           /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit TempUnit { get; set; }           /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit PressUnit { get; set; }          /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+        public virtual Unit LengthUnit { get; set; }         /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+	    public virtual Unit ElectricUnit { get; set; }         /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
+
+        /// Wrappers        
+        public virtual double QfromM3ph()
+        {
+            return !IsFromToInPct ? Qfrom : Qtg >= 0 ? Qtg * Qfrom / 100 : 0;
+        }
+        public virtual double QtoM3ph()
+        {
+            return !IsFromToInPct ? Qto : Qtg >= 0 ? Qtg * Qto / 100 : 0;
+        }
 
         public Test()
         {
@@ -65,27 +97,32 @@ namespace Config.Entities
 			///
 			/// Default values
 			///
-			Publish = (sbyte)Config.Entities.Publish.Always;
-			Evaluate = true;
-			Repeats = 1;
-			Emptying = false;
-			Zeroing = false;
-			ErrLimLo = -2.0f;		/// [%] lower error limit
-			ErrLimHi = 2.0f;		/// [%] upper error limit
-			Uncertainty = 0;
-            PumpPower = 60.0f;		/// [%]
-            MassRepeats = 0;        /// default
-            MassSpread = 0;         /// default
-            MassMethod = false;     /// default
-            TimeBeforeFlow = 10;	/// [s] time before the start of flow control in [s]
-            TimeFlow2Mass = 5;		/// [s] time from the flow stable to the 1st mass measurement in [s]
-            TimePump2StartV = 1;	/// [s] time from the 1st mass measurement to the test start in [s]
-            TimeStop2Mass = 5;		/// [s] between the test end and the final mass measurement
-            TolerRed = 0;			/// = Filter parameter
-			RelTransBefore = string.Empty;
-			RelTransBetween = string.Empty;
-			RelTransAfter = string.Empty;
-			TransitionAfter = string.Empty;
+            Part = 0;
+            Profile = TestProfile.UserDefined;
+            Publish = (sbyte)Common.Publish.Always;
+			DoEvaluate = true;
+            IsFromToInPct = false;
+            ErrLimLo = -2.0f;				/// [%] lower error limit
+            ErrLimHi = 2.0f;				/// [%] upper error limit
+            Uncertainty = 0;
+            Repeats = 1;
+			DoDraining = false;
+			DoDrainingAfter = false;
+			TempLimLo = 15.0f;
+			TempLimHi = 25.0f;
+            TempControl = string.Empty;
+            PumpPower = 60.0f;				/// [%]
+            MassRepeats = 0;				/// default
+            MassSpread = 0;					/// default
+            MassMethod = MassMethod.Scale;  /// default
+            TimeBeforeFlow = 10;			/// [s] time before the start of flow control in [s]
+            TimeFlow2Mass = 5;				/// [s] time from the flow stable to the 1st mass measurement in [s]
+            TimePump2StartV = 1;			/// [s] time from the 1st mass measurement to the test start in [s]
+            TimeStop2Mass = 5;				/// [s] between the test end and the final mass measurement
+            ShortPulses = 0;				/// Short pulses parameter (0 or 1)
+			TransBefore = string.Empty;
+			TransBetween = string.Empty;
+			TransAfter = string.Empty;
 		}
 
 		public Test(string name, int itemNr, Procedure procedure)
@@ -96,22 +133,58 @@ namespace Config.Entities
 			Procedure = procedure;
 		}
 
+        public virtual bool IsRegular()
+        {
+            /// Irregular / event triggered test names have form "[event] TestName"
+            return (Name.Length > 0 && Name[0] != '[') || !Name.Contains("]");
+        }
+
+        public virtual bool BelongsTo(IList<string> autoTests)
+        {
+            if (IsRegular()) return true;
+
+            if (autoTests == null) return false;
+
+            string action = Name.Substring(1, Name.IndexOf(']') - 1);
+            return autoTests.Contains(action);
+        }
+
+        public virtual void ResetChngdFlags()
+        {
+            QtgTextChngd = false;
+            QfromTextChngd = false;
+            QtoTextChngd = false;
+            VolumeTextChngd = false;
+            TempLimLoTextChngd = false;
+            TempLimHiTextChngd = false;
+        }
+
         // Makes a new copy of this object (not just a reference)
         public virtual Test Clone()
         {
             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.IsFromToInPct = IsFromToInPct;
+            result.Volume = Volume;
+			result.TestTime = TestTime;
+			result.Method = Method;
+			result.ErrLimLo = ErrLimLo;
+			result.ErrLimHi = ErrLimHi;
+			result.Uncertainty = Uncertainty;
 			result.Repeats = Repeats;
-            result.Emptying = Emptying;
-            result.Zeroing = Zeroing;
-			result.PumpPower = PumpPower;
+            result.DoDraining = DoDraining;
+            result.DoDrainingAfter = DoDrainingAfter;
+			result.TempLimLo = TempLimLo;
+			result.TempLimHi = TempLimHi;
+            result.TempControl = TempControl;
+            result.PumpPower = PumpPower;
             result.MassRepeats = MassRepeats;
             result.MassSpread = MassSpread;
             result.MassMethod = MassMethod;
@@ -119,33 +192,295 @@ 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.ShortPulses = ShortPulses;
 			result.FeedingPath = FeedingPath;
 			result.BenchPath = BenchPath;
 			result.OutputPath = OutputPath;
 			result.MetersPath = MetersPath;
-#if HEAT_METERS_SUPPORT
+#if HEAT_METERS
             result.HeatMetersPath = HeatMetersPath;
 #endif
-			result.RelTransBefore = RelTransBefore;
-			result.RelTransBetween = RelTransBetween;
-			result.RelTransAfter = RelTransAfter;
-			result.TransitionAfter = TransitionAfter;
-			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
+			result.TransBefore = TransBefore;
+			result.TransBetween = TransBetween;
+			result.TransAfter = TransAfter;
+            result.VolumeUnit = VolumeUnit;
+            result.FlowUnit = FlowUnit;
+            result.FlowUnit = FlowUnit;
+            result.MassUnit = MassUnit;
+            result.TempUnit = TempUnit;
+            result.PressUnit = PressUnit;
+            result.LengthUnit = LengthUnit;
+            result.ElectricUnit = ElectricUnit;
+            foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
 
             return result;
         }
 
+        public virtual void Export(StreamWriter output)
+        {
+            CultureInfo ci = CultureInfo.InvariantCulture;
+
+            output.WriteLine(Name);
+            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(IsFromToInPct.ToString());
+            output.WriteLine(Volume.ToString(ci));
+            output.WriteLine(TestTime.ToString(ci));
+            output.WriteLine(Method);
+            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(TempLimLo.ToString(ci));
+			output.WriteLine(TempLimHi.ToString(ci));
+            output.WriteLine((TempControl != null) ? TempControl : string.Empty);
+            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(ShortPulses.ToString(ci));
+            output.WriteLine(FeedingPath);
+            output.WriteLine(BenchPath);
+            output.WriteLine(OutputPath);
+            output.WriteLine(MetersPath);
+            output.WriteLine(TransBefore);
+            output.WriteLine(TransBetween);
+            output.WriteLine(Profile);
+            output.WriteLine(TransAfter);
+
+            foreach (var prms in MoreParams) { prms.Export(output); }
+            output.WriteLine();
+        }
+
+        public static Test Import(StreamReader input, Procedure newProcedure)
+        {
+            string firstLine = input.ReadLine();
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                return null;
+            }
+
+            CultureInfo ci = CultureInfo.InvariantCulture;
+            Test tst = new Test();
+
+            tst.Name = firstLine;
+			tst.Part = int.Parse(input.ReadLine(), ci);
+			tst.Publish = sbyte.Parse(input.ReadLine(), ci);
+			tst.DoEvaluate = bool.Parse(input.ReadLine());
+            tst.Qtg = double.Parse(input.ReadLine(), ci);
+            tst.Qfrom = double.Parse(input.ReadLine(), ci);
+            tst.Qto = double.Parse(input.ReadLine(), ci);
+            tst.IsFromToInPct = bool.Parse(input.ReadLine());
+            tst.Volume = double.Parse(input.ReadLine(), ci);
+            tst.TestTime = double.Parse(input.ReadLine(), ci);
+            tst.Method = input.ReadLine();
+			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.TempLimLo = float.Parse(input.ReadLine(), ci);
+			tst.TempLimHi = float.Parse(input.ReadLine(), ci);
+            tst.TempControl = input.ReadLine();
+            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.ShortPulses = int.Parse(input.ReadLine(), ci);
+            tst.FeedingPath = input.ReadLine();
+            tst.BenchPath = input.ReadLine();
+            tst.OutputPath = input.ReadLine();
+            tst.MetersPath = input.ReadLine();
+            tst.TransBefore = input.ReadLine();
+            tst.TransBetween = input.ReadLine();
+            string line = input.ReadLine();
+            tst.Profile = line.Equals(TestProfile.ProtectedHeatMeter.ToString()) ? TestProfile.ProtectedHeatMeter
+                        : line.Equals(TestProfile.ProtectedCompound.ToString()) ? TestProfile.ProtectedCompound
+                        : line.Equals(TestProfile.Protected.ToString()) ? TestProfile.Protected
+                        : line.Equals(TestProfile.UserDefinedHeatMeter.ToString()) ? TestProfile.UserDefinedHeatMeter
+                        : line.Equals(TestProfile.UserDefinedCompound.ToString()) ? TestProfile.UserDefinedCompound
+                        : TestProfile.UserDefined;  /// UserDefined is the default
+            tst.TransAfter = input.ReadLine();
+
+            while (true)
+            {
+                ComponentTest prms = ComponentTest.Import(input, tst);
+                if (prms == null)
+                    break;
+                else
+                    tst.MoreParams.Add(prms);
+            }
+
+            tst.Procedure = newProcedure;
+            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 != IsFromToInPct.ToString())        { diff.AppendFormat(fmt, "IsFromToInPct", IsFromToInPct.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != Volume.ToString(ci))             { diff.AppendFormat(fmt, "Volume", Volume.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != TestTime.ToString(ci))           { diff.AppendFormat(fmt, "TstTime", TestTime.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())           { diff.AppendFormat(fmt, "DoDraining", DoDraining.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != DoDrainingAfter.ToString())      { diff.AppendFormat(fmt, "DoDrainingAfter", DoDrainingAfter.ToString(), 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 != TempControl)                     { diff.AppendFormat(fmt, "TempController", TempControl, 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 != TransBefore)                     { diff.AppendFormat(fmt, "TransBefore", TransBefore, ln); };
+            ln = inp.ReadLine(); if (ln != TransBetween)                    { diff.AppendFormat(fmt, "TransBetween", TransBetween, ln); };
+            ln = inp.ReadLine(); if (ln != Profile.ToString())              { diff.AppendFormat(fmt, "Profile", Profile, ln); };
+            ln = inp.ReadLine(); if (ln != TransAfter)                      { diff.AppendFormat(fmt, "TransAfter", TransAfter, 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;
+		}
+
 		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/TestInstance.cs

@@ -0,0 +1,32 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+    public class TestInstance
+    {
+        public Test Test;
+        public int Repetition;
+
+        public string Name
+        {
+            get
+            {
+                return (Test != null) ? Common.Utils.GetTestName(Test.Name, Test.Repeats, Repetition) : string.Empty;
+            }
+        }
+
+        public TestInstance(Test test, int repetition)
+        {
+            Test = test;
+            Repetition = repetition;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

Config/Entities/TestResult.cs

@@ -1,171 +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));
-			}
-		}
-
-		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.Emptying;
-			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 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
 {
@@ -12,7 +14,7 @@ namespace Config.Entities
 		public virtual int ItemNr { get; set; }					/// Order of the preparation step
 		public virtual int Duration { get; set; }				/// Duration in seconds
         public virtual string Message { get; set; }				/// Message
-		public virtual StepCondition EndCondition { get; set; }	/// Condition when transition step is finished (next to the duration)
+		public virtual string EndCondition { get; set; }		/// Condition when transition step is finished (next to the duration)
 		public virtual string ValvesOpen { get; set; }			/// List of valves to be opened
 		public virtual string ValvesClose { get; set; }			/// List of valves to be closed
 		public virtual string RegulValvesPct { get; set; }		/// Positions of regulation valves in % separated by ';'
@@ -24,8 +26,8 @@ namespace Config.Entities
 
 		public TransitionStep()
 		{
-			Duration = 5;		/// sec.
-			EndCondition = (int)StepCondition.None;
+			Duration = 5;			/// sec.
+			EndCondition = "None";
 		}
 
 		public TransitionStep(int itemNr, TransitionSequence sequence)
@@ -54,12 +56,71 @@ namespace Config.Entities
 			result += indent + "ItemNr = " + ItemNr.ToString() + ", ";
 			result += indent + "Duration = " + Duration.ToString() + ", ";
 			result += indent + "Message = " + Message + ", ";
-			result += indent + "EndCondition = " + EndCondition.ToString() + ", ";
-			result += indent + "ValvesOpen = " + ValvesOpen.ToString() + ", ";
-			result += indent + "ValvesClose = " + ValvesClose.ToString() + ", ";
-            result += indent + "RegulValvesPct = " + RegulValvesPct.ToString() + ", ";
-            result += indent + "PumpsWithFMPct = " + RegulValvesPct.ToString() + Environment.NewLine;
+			result += indent + "EndCondition = " + EndCondition + ", ";
+			result += indent + "ValvesOpen = " + ValvesOpen + ", ";
+			result += indent + "ValvesClose = " + ValvesClose + ", ";
+            result += indent + "RegulValvesPct = " + RegulValvesPct + ", ";
+            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-2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+    public class Uncertainty : Common.IUncertainty
+    {
+        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,105 +1,188 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
-using System.Security.Cryptography;
-using System.Text;
-using System.Diagnostics;
+using log4net;
+using Common;
 using Config.Resources;
 
 namespace Config.Entities
 {
-    public class User
+    public class User : Common.IUser
     {
+        static readonly ILog log = LogManager.GetLogger(typeof(User));
+
         public virtual int Id { get; protected set; }
-        public virtual string Name { get; set; }
-        public virtual string Password { get; set; }
-        public virtual string Description { get; set; }
+        public virtual string UserName { get; set; }	/// = name, alias, abbreviation
+		public virtual string FullName { get; set; }	/// = description
+        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
 
-		private bool powerUser;		/// Set to tue for built-in users, power users have full access even with empty Groups
+        private bool powerUser;		        /// true for built-in users, power users have full access even with empty Groups list
+        public virtual bool IsPowerUser() { return powerUser; }
+
+        private string legalizator;         /// Not mapped to a database !!!, 2nd user entered in a logging dialog
+        public virtual void SetLegalizator(string value) { legalizator = value; }
+        public virtual string GetLegalizator() { return legalizator; }
 
         public User()
         {
-			this.powerUser = false;
             Groups = new List<Group>();
         }
 
-        public virtual void AddGroup(Group group)
+        public User(string userName, int number, bool powerUser)
         {
-            Groups.Add(group);
+            UserName = userName;
+            Number = number;
+            this.powerUser = powerUser;
+            Groups = new List<Group>();
+            FullName = powerUser ? "Power User" : string.Empty;
         }
 
-
-		public User(string name)
+		/// <summary>
+		/// Adds a group to the user.
+		/// </summary>
+		/// <param name="group">Group to be added</param>
+		public virtual void AddGroup(Group group)
 		{
-			this.powerUser = true;
-			Name = name;
-			Groups = new List<Group>();
-			Description = "Power user";
+			Groups.Add(group);
 		}
 
-        /// ------------- Additional stuff not mapped into the database -------------
-
-        ///
-        /// Authorized user (static)
-        ///
-        private static User currentUser = null;                         /// Updated by instance methods Authorize, Unauthorize
-        public static User CurrentUser
+        /// <summary>
+        /// All members are copied except of ID (so that NHibernate works properly).
+        /// List of groups is empty.
+        /// </summary>
+        /// <param name="user"></param>
+        /// <returns></returns>
+        public virtual object Clone()
         {
-            get { return currentUser; }
-            set { currentUser = value; }
+            User newUser = new User(UserName, Number, false);
+            newUser.FullName = FullName;
+            newUser.Number = Number;
+            newUser.Tag = Tag;
+            newUser.Password = Password;
+            newUser.LastPwChange = LastPwChange;
+            return newUser;
         }
 
-        private static DateTime lastAuthorization = DateTime.Now;
-        public static DateTime LastAuthorization { get { return lastAuthorization; } }
+        public override string ToString()
+        {
+            return (UserName != null) ? UserName : Number.ToString();
+        }
+
+        /// ------------- Additional stuff not mapped into the database -------------
 
         /// <summary>
         /// Check whether user is a member of a group.
         /// </summary>
         /// <param name="groupId">Group GID</param>
         /// <returns>true is user is a member of the specified group</returns>
-        public virtual bool IsMemberOf(Grp.GID groupId)
+        public virtual bool IsMemberOf(GID groupId)
         {
-            if (groupId == Grp.GID.None || powerUser)
+            if (powerUser)
             {
                 return true;
             }
-            else if (groupId >= 0 && (int)groupId < Grp.Count)
+            else if ((groupId >= 0) && (groupId < GID.NrOfGroups))
             {
-                // for all group elements in User.groups
-                for (int i = 0; i < Groups.Count; ++i)
+                foreach (var g in Groups)
                 {
-                    // element GID = parameter GroupId ?
-                    if (((Group)Groups[i]).Gid == (int)groupId)
-                    {
-                        return true;
-                    }
+                    if (g.GID == groupId) return true;
                 }
-                return false;
-            }
-            else
-            {
-                return false;
             }
+
+            return false;
         }
 
         /// <summary>
-        /// Sets users password. It then will be encrypted.
+        /// Check whether user is a member of any of specified groups.
+        /// Returns true also when no groups are defined (groupIds = null).
+        /// </summary>
+        /// <param name="groupIds">An array of group GID-s or null (no membership required)</param>
+        /// <returns>true if user is a member of any of specified groups</returns>
+        public virtual bool IsMemberOf(GID[] groupIds)
+        {
+            if (groupIds == null || powerUser)
+            {
+                return true;
+            }
+
+            foreach (var gid in groupIds)
+            {
+                if ((gid >= 0) && (gid < GID.NrOfGroups))
+                {
+                    /// for all group elements in User.Groups
+                    foreach (var grp in Groups)
+                    {
+                        /// element GID = parameter GroupId ?
+                        if (grp.GID == gid) return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks requirements on the password regardless of the password history
+        /// </summary>
+        /// <param name="password">Password</param>
+        /// <returns>true when the password is OK</returns>
+        public static bool IsPasswordMeetsRequirements(string password, out string explanation)
+        {
+            return Common.Utils.IsPasswordMeetsRequirements(password, out explanation);
+        }
+
+        /// <summary>
+        /// Returns true when password was already used in the past
+        /// </summary>
+        /// <param name="passwordCandidate">Password</param>
+        /// <returns>false when password is new, true when it was used in the past</returns>
+        public virtual bool IsPasswordUsedInPast(string passwordCandidate)
+        {
+            string encryptedPW = EncryptedPassword(passwordCandidate);
+            return (encryptedPW == Password) || (encryptedPW == Password2) || (encryptedPW == Password3);
+        }
+
+        /// <summary>
+        /// Checks 'LastPwChange' and returns true when password expired
+        /// </summary>
+        /// <returns></ returns>
+        public virtual bool IsPasswordExpired()
+        {
+            if (IsPowerUser() || IsMemberOf(GID.Administrators) || CurrentUser.PasswdExpirationPeriodDays == 0)
+            {
+                /// Password cannot expirate for this user or this feature is disabled in Backup and Security options
+                return false;
+            }
+
+            /// Password expiration time is 3 months
+            return (DateTime.Now - LastPwChange > new TimeSpan(CurrentUser.PasswdExpirationPeriodDays, 0, 0, 0));
+        }
+
+        /// <summary>
+        /// Encrypts and saves users password.
         /// </summary>
         /// <param name="password">Password</param>
         public virtual void SetPassword(string password)
         {
-            this.Password = EncryptedPassword(password);
+            Password4 = Password3;
+            Password3 = Password2;
+            Password2 = Password;
+            Password = EncryptedPassword(password);
             LastPwChange = DateTime.Now;
         }
 
-
-        public virtual string EncryptedPassword(string password)
+        string EncryptedPassword(string password)
         {
-            return getHash(password);
+            return Common.Utils.GetHash(password);
         }
 
         /// <summary>
@@ -107,157 +190,20 @@ namespace Config.Entities
         /// </summary>
         /// <param name="password">Password</param>
         /// <returns>true if password is correct</returns>
-        public virtual bool CheckPassword(string password)
+        public virtual bool IsCorrectPassword(string password)
         {
+            if (string.IsNullOrEmpty(password) && string.IsNullOrEmpty(Password))
+            {
+                /// Currently saved and verified passwords are both empty => return true
+                return true;
+            }
+
             return (Password == EncryptedPassword(password));
         }
 
-        /// <summary>
-        /// The FIRST of TWO possible user authorization method to be used
-        /// when a specific group membership is required (you can use Grp.GID.None).
-        /// If the user is not authorized, the current user remains to be a current user
-        /// (i.e. the access rights were not risen to a higher level).
-        /// If you require different behavior, use Unauthorize() before calling Authorize().
-        /// </summary>
-        /// <param name="userName"></param>
-        /// <param name="password"></param>
-        /// <param name="requiredGrupMembership"></param>
-        /// <returns>true = authorized</returns>
-        public virtual bool Authorize(string userName, string password, Grp.GID requiredGroupMembership)
+        public virtual string ToEncodedStr()
         {
-			if (Entities.User.IsPowerUser(userName, password))
-			{
-				currentUser = this;
-				lastAuthorization = DateTime.Now;
-				return true;
-			}
-
-			if (Name.ToLower() == userName.ToLower())
-            {
-                if (IsMemberOf(requiredGroupMembership) && CheckPassword(password))
-                {
-                    currentUser = this;
-                    lastAuthorization = DateTime.Now;
-                    return true;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return false;
+            return string.Format("{0}~{1}~{2}", UserName, FullName, legalizator);
         }
-
-        /// <summary>
-        /// The SECOND of TWO possible user authorization method to be used when
-        /// no specific group membership is required.
-        /// If the user is not authorized, the current user remains to be a current user
-        /// (i.e. the access rights were not risen to a higher level).
-        /// If you require different behavior, use Unauthorize() before calling Authorize().
-        /// </summary>
-        /// <param name="userName"></param>
-        /// <param name="password"></param>
-        /// <param name="requiredGroupMembership"></param>
-        /// <returns>true = authorized</returns>
-        public virtual bool Authorize(string userName, string password)
-        {
-            return Authorize(userName, password, Grp.GID.None);
-        }
-
-        /// <summary>
-        /// Returns a 'User' with a given username from a database.
-        /// </summary>
-        /// <param name="username">User name for the query</param>
-        /// <returns>reference to a 'User' (if it exists) or null</returns>
-		public static User AuthorizeDummyUser(string username)
-		{
-			User user = new User();
-			user.Name = username;
-			currentUser = user;
-			return user;
-		}
-
-        /// <summary>
-        /// Returns a 'User' with a given username from an ARBITRARY database.
-        /// </summary>
-        /// <param name="username">User name for the query</param>
-        /// <returns>reference to a 'User' (if it exists) or null</returns>
-        public static User LoadUserByName(string username, DBSettings dbSettings)
-        {
-            IList<User> listOfUsers = FluentCommon.CreateSessionFactory(DBKind.Config, dbSettings, false)
-				.OpenSession()
-				.CreateQuery("FROM User WHERE LOWER(Name) = :username")
-				.SetParameter("username", username.ToLower())
-				.List<User>();
-            if (listOfUsers.Count > 0) return listOfUsers[0];
-            return null;
-        }
-
-		/// <summary>
-		/// Returns a 'User' with a given username from the users database.
-		/// </summary>
-		/// <param name="username">User name for the query</param>
-		/// <returns>reference to a 'User' (if it exists) or null</returns>
-		public static User LoadUserByName(string username)
-		{
-			IList<User> listOfUsers = FluentCommon.CreateSession(DBKind.Config)
-				.CreateQuery("FROM User WHERE LOWER(Name) = :username")
-				.SetParameter("username", username.ToLower())
-				.List<User>();
-			if (listOfUsers.Count > 0) return listOfUsers[0];
-			return null;
-		}
-
-        /// <summary>
-        /// returns an IList of all Users
-        /// </summary>
-        public static IList<User> GetAllUsers()
-		{
-            return FluentCommon.CreateSession(DBKind.Config)
-				.CreateQuery("FROM User")
-				.List<User>();
-        }
-
-
-        /// <summary>
-        /// Unauthorize, abandon current users authorization.
-        /// </summary>
-        public static void Unauthorize()
-        {
-            currentUser = null;
-            lastAuthorization = DateTime.Now;
-        }
-
-        /// <summary>
-        /// getHash encrypts a string 
-        /// </summary>
-        /// <param name="text">the string to encrypt</param>
-        /// <returns></returns>
-        public static string getHash(string text)
-        {
-            byte[] bytes = Encoding.Unicode.GetBytes(text);
-            SHA512Managed hashstring = new SHA512Managed();
-            byte[] hash = hashstring.ComputeHash(bytes);
-            string hashString = string.Empty;
-            foreach (byte x in hash)
-            {
-                hashString += String.Format("{0:x2}", x);
-            }
-            return hashString;
-        }
-
-		/// <summary>
-		/// Returns 'true' when authentication data are valid for a power user.
-		/// </summary>
-		/// <param name="userName">User name</param>
-		/// <param name="password">Password</param>
-		/// <returns>true = authenticated, false = refused</returns>
-		public static bool IsPowerUser(string userName, string password)
-		{
-			return (userName.Equals("milan") && password.Equals("napajedla")) ||
-				   (userName.Equals("igor")  && password.Equals("ronko4")) ||
-                   (userName.Equals("janb")  && password.Equals("sen345bnaj21")) ||
-                   (userName.Equals("vlado") && password.Equals("luskovica.430"));
-		}
     }
 }

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 = User.CurrentUser.Name,
-                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(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-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Windows.Forms;
@@ -8,71 +8,43 @@ using FluentNHibernate.Cfg.Db;
 using NHibernate;
 using NHibernate.Cfg;
 using NHibernate.Tool.hbm2ddl;
+using Common;
 using Config.Resources;
 
 namespace Config
 {
-    public static class FluentCommon
+    public class FluentCommon
     {
-		/// <summary>
-		/// Session factories for regular sessions.
-		/// </summary>
-		public static ISessionFactory[] SessionFactories = new ISessionFactory[(int)Entities.DBKind.Count];
-
         /// <summary>
         /// NHibernate session factory (to create the database session 'SessionFactory')
         /// </summary>
         /// <returns>A database session</returns>
-        static ISessionFactory CreateSessionFactory(Entities.DBKind database)
-        {
-			Entities.DBType dbType;
-            string connectionString;
-
-			switch (database)
-			{
-                default:
-				case Entities.DBKind.Config:
-					dbType = Data.CurrentBench.ProceduresDBSettings.DbType;
-					connectionString = Data.CurrentBench.ProceduresDBSettings.ConnectionString;
-                    break;
-				case Entities.DBKind.Results:
-					dbType = Data.CurrentBench.WaterMetersDBSettings.DbType;
-					connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
-                    break;
-			}
-
-            return CreateSessionFactory(database, new DBSettings(dbType, connectionString), false);
-		}
-
-        /// <summary>
-        /// NHibernate session factory (to create the database session 'SessionFactory')
-        /// </summary>
-        /// <returns>A database session</returns>
-		public static ISessionFactory CreateSessionFactory(Entities.DBKind database, DBSettings dbSettings, bool createDB)
+		public static ISessionFactory CreateSessionFactory(DBKind database, DBType dbType, string connectionString, bool createDB)
         {
 			try
 			{
                 FluentConfiguration cfg = Fluently.Configure();
 
-                switch (dbSettings.DbType)
+                switch (dbType)
 				{
 					default:
-					case Entities.DBType.SQLite:
-						cfg = cfg.Database(SQLiteConfiguration.Standard.UsingFile(dbSettings.ConnectionString));
+                    case DBType.MySql:
+                        cfg = cfg.Database(MySQLConfiguration.Standard.ConnectionString(connectionString));
                         break;
-					case Entities.DBType.MySql:
-                        cfg = cfg.Database(MySQLConfiguration.Standard.ConnectionString(dbSettings.ConnectionString));
+                    case DBType.SQLite:
+                        cfg = cfg.Database(SQLiteConfiguration.Standard.UsingFile(connectionString));
                         break;
-				}
+                }
 
                 switch (database)
                 {
                     default:
-					case Entities.DBKind.Config:
-                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
+					case DBKind.Config:
+                    case DBKind.RemoteConfig:
+                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<FluentCommon>());
                         break;
-					case Entities.DBKind.Results:
-                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
+                    case DBKind.Results:
+                        cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<FluentCommon>());
                         break;
                 }
 
@@ -87,8 +59,10 @@ namespace Config
 			}
 			catch (Exception exc)
 			{
-				MessageBox.Show(string.Format("Cannot open database.\r\nReason:\r\n{0}", exc.Message),
-								"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+				MessageBox.Show(string.Format(Strings.Cannot_open_DB_Cause_0, exc.Message),
+								Strings.Error,
+								MessageBoxButtons.OK,
+								MessageBoxIcon.Error);
 				return null;
 			}
         }
@@ -109,46 +83,6 @@ namespace Config
             new SchemaExport(config).Create(true, true);
         }
 
-		/// Create a NHibernate session for the given database
-		public static ISession CreateSession(Entities.DBKind database)
-		{
-			int ix = (int)database;
-			if (ix < 0 || ix >= (int)Entities.DBKind.Count) return null;
-
-			if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
-
-			return SessionFactories[ix].OpenSession();
-		}
-
-		public static void SaveToDb(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(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'.
@@ -156,9 +90,9 @@ namespace Config
         /// <param name="dbType">DBType.SQLite or DBType.MySql</param>
         /// <param name="connectionString">Connection string</param>
         /// <returns>true=success, false=error</returns>
-		public static bool CreateEmptyConfigDB(DBSettings dbSettings)
+		public static bool CreateEmptyConfigDB(DBType dbType, string connectionString)
 		{
-			ISessionFactory sessionFactory = CreateSessionFactory(Entities.DBKind.Config, dbSettings, true);
+			ISessionFactory sessionFactory = CreateSessionFactory(DBKind.Config, dbType, connectionString, true);
 			if (sessionFactory == null) return false;
 
             /// Populate the database
@@ -167,68 +101,50 @@ namespace Config
                 using (var transaction = session.BeginTransaction())
                 {
                     ///
-                    /// Prepare all groups
+					/// Create user 'admin'
                     ///
-                    var testers					= new Entities.Group { Gid = (int)Grp.GID.Testers,				  Name = Strings.Tester };
-                    var testingSpecialists		= new Entities.Group { Gid = (int)Grp.GID.TestingSpecialists,	  Name = Strings.Testing_Specialist };
-                    var headOfLab				= new Entities.Group { Gid = (int)Grp.GID.HeadOfLab,			  Name = Strings.Head_of_Lab };
-                    var maintenanceSpecialists	= new Entities.Group { Gid = (int)Grp.GID.MaintenanceSpecialists, Name = Strings.Maintenance_Specialist };
-                    var metrologists			= new Entities.Group { Gid = (int)Grp.GID.Metrologists,			  Name = Strings.Metrologist };
-                    var calibrationSpecialists	= new Entities.Group { Gid = (int)Grp.GID.CalibrationSpecialists, Name = Strings.Calibration_Specialist };
-                    var administrators			= new Entities.Group { Gid = (int)Grp.GID.Administrators,		  Name = Strings.Administrator };
-
-					/// Create the user 'admin' add his groups
-                    var admin = new Entities.User
+                    var admin = new Config.Entities.User
                     {
-						Name = Data.AdminUsername,
-                        Description = "Administrator",
+						UserName = CurrentUser.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);
+					admin.SetPassword(CurrentUser.AdminPassword);
 
-                    session.SaveOrUpdate(admin);
+                    ///
+                    /// Prepare all groups, add some of them to admin
+                    ///
+                    for (GID gid = 0; gid < GID.NrOfGroups; gid++)
+                    {
+                        Config.Entities.Group group = new Config.Entities.Group(gid);
+                        switch (gid)
+                        {
+                            case GID.Testers:
+                            case GID.TestingSpecialists:
+                            case GID.HeadOfLab:
+                            case GID.MaintenanceSpecialists:
+                            case GID.Metrologists:
+                            case GID.CalibrationSpecialists:
+                            case GID.Administrators:
+#if TURA_IPERL || TURA_IPERL_NEW || TURA_SPECIAL
+                            case GID.TraceabilityManagement:
+//#elif LANG_PL
+#endif
+                            case GID.MetrologicalAuthority:
+                            case GID.WaterMeterAuthority:
 
-					///// Create the control board component
-					//var cmpnt = (new BenchControl.Elde.ControlBoardCfg(new BenchControl.Elde.ControlBoardFactory())).CreateDbEntity();
-					//session.SaveOrUpdate(cmpnt);
+                                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(DBSettings dbSettings)
-        {
-			ISessionFactory sessionFactory = CreateSessionFactory(Entities.DBKind.Results, dbSettings, 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/Grp.cs

@@ -1,101 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using Config.Entities;
-using NHibernate;
-using FluentNHibernate;
-
-namespace Config
-{
-    /// <summary>
-    /// Enum Grp.GID specifies GID-s of user groups.
-    /// An instance of this class represenst a group, which contains a list of its members (users).
-    /// Static private array 'groups' of this class, accesible through indexer, contains all groups.
-    /// </summary>
-    public class Grp
-    {
-        /// <summary>
-        /// GID-s of user groups, each user is member of one or more groups.
-        /// </summary>
-        public enum GID
-        {
-            // The first NrOfGroups items are GroupID-s (0..NrOfGroups-1)
-            Testers = 0,                 
-            TestingSpecialists,
-            HeadOfLab,
-            MaintenanceSpecialists,
-            Metrologists,
-            CalibrationSpecialists,
-            Administrators,             // application / network / database administrator
-            Custom1,
-            Custom2,
-            Custom3,
-            NrOfGroups,                 // Number of groups (this is not a GroupID)
-            None,                       // Not a GroupID, can be used to indicate no group membership is required
-            Invalid = -1,               // Not a GroupID, indicates a variable has not been properly set so far
-        }
-
-        /// <summary>
-        /// Number of groups.
-        /// </summary>
-        public const int Count = (int)GID.NrOfGroups;
-
-        // Static array of all groups.
-        static Grp[] groups;
-
-        /// <summary>
-        /// Static constructor, creates all groups with no members.
-        /// </summary>
-        static Grp()
-        {
-            groups = new Grp[Count];
-            for (int i = 0; i < Count; i++)
-            {
-                groups[i] = new Grp((GID)i);
-            }
-        }
-
-        /// <summary>
-        /// Returns a Group from Id.
-        /// </summary>
-        /// <param name="id">Group Gid</param>
-        /// <returns>Entities.Group object reference</returns>
-        public static Entities.Group FromId(GID gid)
-        {
-            int i = (int)gid;
-
-            if (i >= 0 && i < Count)
-            {
-                return groups[i].group;
-            }
-            else
-            {
-                return null;
-            }
-        }
-
-        ///////////////////// ^ static ^ ///////////////////// v instance v /////////////////////
-
-        /// Public properties
-        public GID Gid { get { return (GID)group.Gid; } }
-        public string Name { get { return group.Name; } set { group.Name = value; } }
-
-        /// Private fields
-        Entities.Group group;
-
-        /// <summary>
-        /// Instance constructor.
-        /// </summary>
-        /// <param name="id"></param>
-        public Grp(GID gid)
-        {
-            group = new Entities.Group();
-            this.group.Gid = (int)gid;
-            this.group.Name = gid.ToString();
-        }
-    }
-}

Config/Mappings/BenchPathMap.cs

@@ -15,10 +15,16 @@ namespace Config.Mappings
 			Map(x => x.Name);
 			Map(x => x.Qfrom);
 			Map(x => x.Qto);
-			Map(x => x.TempIn);
-			Map(x => x.TempOut);
-			Map(x => x.PressIn);
-			Map(x => x.PressOut);
+            Map(x => x.Selector);
+            Map(x => x.TempMtrUp);
+			Map(x => x.TempMtrDown);
+			Map(x => x.PressMtrUp);
+			Map(x => x.PressMtrDown);
+			Map(x => x.PressMtrDelta);
+			//Map(x => x.ElectricMtrUp);
+			//Map(x => x.ElectricMtrDown);
+			//Map(x => x.ElectricMtrDelta);
+			Map(x => x.StopBFValve);
 			Map(x => x.ValvesOpen)
 				.CustomType("StringClob")
 				.CustomSqlType("varchar(8000)");

Config/Mappings/ComponentMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2023 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -13,16 +13,19 @@ namespace Config.Mappings
             Id(x => x.Id);
             Map(x => x.Name);
             Map(x => x.ClassName);
-            Map(x => x.ParentName);
+            Map(x => x.Parent);
             Map(x => x.ItemNr);
-			Map(x => x.Mode);
-			Map(x => x.Logging);
+			Map(x => x.DebugMode);
+			Map(x => x.LogLevel);
 			Map(x => x.Parameters)
 				.CustomType("StringClob")
-				.CustomSqlType("varchar(8000)");
+				.CustomSqlType("varchar(12000)");
 			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/FeedingPathMap.cs

@@ -15,7 +15,9 @@ namespace Config.Mappings
 			Map(x => x.Name);
 			Map(x => x.Qfrom);
 			Map(x => x.Qto);
+            Map(x => x.Selector);
 			Map(x => x.Pump);
+            Map(x => x.RegVPositions);
 			Map(x => x.ValvesOpen)
 				.CustomType("StringClob")
 				.CustomSqlType("varchar(8000)");

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/HeatMetersPathMap.cs

@@ -0,0 +1,35 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+#if HEAT_METERS
+	class HeatMetersPathMap : ClassMap<HeatMetersPath>
+    {
+        public HeatMetersPathMap()
+        {
+            Id(x => x.Id);
+			Map(x => x.ItemNr);
+			Map(x => x.Name);
+
+            Map(x => x.TempWarmFrom);
+            Map(x => x.TempWarmTo);
+            Map(x => x.TempColdFrom);
+            Map(x => x.TempColdTo);
+
+            Map(x => x.TMeterRefWarm1);
+			Map(x => x.TMeterRefWarm2);
+			Map(x => x.TMeterRefCold1);
+			Map(x => x.TMeterRefCold2);
+
+            Map(x => x.TMeterWorkWarm1);
+            Map(x => x.TMeterWorkWarm2);
+            Map(x => x.TMeterWorkCold1);
+            Map(x => x.TMeterWorkCold2);
+        }
+    }
+#endif
+}

Config/Mappings/MeasurementCorrectionMap.cs

@@ -1,16 +1,17 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
 
 namespace Config.Mappings
 {
-	class MeasurementCorrectionMap : ClassMap<MeasurementCorrection>
+	class MeasurementCorrectionMap : ClassMap<Entities.MeasurementCorrection>
 	{
 		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/MetersPathMap.cs

@@ -1,64 +1,38 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
-using Config.Entities;
 
 namespace Config.Mappings
 {
-	class MetersPathMap : ClassMap<MetersPath>
+    class MetersPathMap : ClassMap<Entities.MetersPath>
     {
         public MetersPathMap()
         {
             Id(x => x.Id);
 			Map(x => x.ItemNr);
 			Map(x => x.Name);
-			Map(x => x.Qfrom);
-			Map(x => x.Qto);
-			Map(x => x.Sensor1);
-#pragma warning disable
-			if (Config.Data.WMsCount >= 2) Map(x => x.Sensor2);
-			if (Config.Data.WMsCount >= 3) Map(x => x.Sensor3);
-			if (Config.Data.WMsCount >= 4) Map(x => x.Sensor4);
-			if (Config.Data.WMsCount >= 5) Map(x => x.Sensor5);
-			if (Config.Data.WMsCount >= 6) Map(x => x.Sensor6);
-			if (Config.Data.WMsCount >= 7) Map(x => x.Sensor7);
-			if (Config.Data.WMsCount >= 8) Map(x => x.Sensor8);
-			if (Config.Data.WMsCount >= 9) Map(x => x.Sensor9);
-			if (Config.Data.WMsCount >= 10) Map(x => x.Sensor10);
-			if (Config.Data.WMsCount >= 11) Map(x => x.Sensor11);
-			if (Config.Data.WMsCount >= 12) Map(x => x.Sensor12);
-			if (Config.Data.WMsCount >= 13) Map(x => x.Sensor13);
-			if (Config.Data.WMsCount >= 14) Map(x => x.Sensor14);
-			if (Config.Data.WMsCount >= 15) Map(x => x.Sensor15);
-			if (Config.Data.WMsCount >= 16) Map(x => x.Sensor16);
-			if (Config.Data.WMsCount >= 17) Map(x => x.Sensor17);
-			if (Config.Data.WMsCount >= 18) Map(x => x.Sensor18);
-			if (Config.Data.WMsCount >= 19) Map(x => x.Sensor19);
-			if (Config.Data.WMsCount >= 20) Map(x => x.Sensor20);
-#if IPERLST
-            if (Config.Data.WMsCount >= 21) Map(x => x.Sensor21);
-            if (Config.Data.WMsCount >= 22) Map(x => x.Sensor22);
-            if (Config.Data.WMsCount >= 23) Map(x => x.Sensor23);
-            if (Config.Data.WMsCount >= 24) Map(x => x.Sensor24);
-            if (Config.Data.WMsCount >= 25) Map(x => x.Sensor25);
-            if (Config.Data.WMsCount >= 26) Map(x => x.Sensor26);
-            if (Config.Data.WMsCount >= 27) Map(x => x.Sensor27);
-            if (Config.Data.WMsCount >= 28) Map(x => x.Sensor28);
-            if (Config.Data.WMsCount >= 29) Map(x => x.Sensor29);
-            if (Config.Data.WMsCount >= 30) Map(x => x.Sensor30);
-            if (Config.Data.WMsCount >= 31) Map(x => x.Sensor31);
-            if (Config.Data.WMsCount >= 32) Map(x => x.Sensor32);
-            if (Config.Data.WMsCount >= 33) Map(x => x.Sensor33);
-            if (Config.Data.WMsCount >= 34) Map(x => x.Sensor34);
-            if (Config.Data.WMsCount >= 35) Map(x => x.Sensor35);
-            if (Config.Data.WMsCount >= 36) Map(x => x.Sensor36);
-            if (Config.Data.WMsCount >= 37) Map(x => x.Sensor37);
-            if (Config.Data.WMsCount >= 38) Map(x => x.Sensor38);
-            if (Config.Data.WMsCount >= 39) Map(x => x.Sensor39);
-            if (Config.Data.WMsCount >= 40) Map(x => x.Sensor40);
-#endif
-#pragma warning restore
+
+            Map(x => x.Sensor1);
+            Map(x => x.Sensor2);
+			Map(x => x.Sensor3);
+			Map(x => x.Sensor4);
+			Map(x => x.Sensor5);
+			Map(x => x.Sensor6);
+			Map(x => x.Sensor7);
+			Map(x => x.Sensor8);
+			Map(x => x.Sensor9);
+			Map(x => x.Sensor10);
+			Map(x => x.Sensor11);
+			Map(x => x.Sensor12);
+			Map(x => x.Sensor13);
+			Map(x => x.Sensor14);
+			Map(x => x.Sensor15);
+			Map(x => x.Sensor16);
+			Map(x => x.Sensor17);
+			Map(x => x.Sensor18);
+			Map(x => x.Sensor19);
+			Map(x => x.Sensor20);
 		}
     }
 }

Config/Mappings/OutputPathMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -15,14 +15,15 @@ namespace Config.Mappings
 			Map(x => x.Name);
 			Map(x => x.Qfrom);
 			Map(x => x.Qto);
-			Map(x => x.RegulValve);
+            Map(x => x.Selector);
+            Map(x => x.RegValve);
 			Map(x => x.FlowMeter);
 			Map(x => x.PidCoef);
             Map(x => x.StartValve);
             Map(x => x.Diverter);
-			Map(x => x.TempDiv);
-			Map(x => x.Balance);
-			Map(x => x.EmptyTankValve);
+			Map(x => x.TempMtrDiv);
+			Map(x => x.Scale);
+            Map(x => x.RegVPositions);
 			Map(x => x.ValvesOpen)
 				.CustomType("StringClob")
 				.CustomSqlType("varchar(8000)");

Config/Mappings/PTestMap.cs

@@ -0,0 +1,62 @@
+///
+/// Copyright (c) 2019-2023 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.FlowId);
+            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.Method);
+            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-2023 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -15,43 +14,47 @@ 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);
+            Map(x => x.Qtg);
+            Map(x => x.Qfrom);
 			Map(x => x.Qto);
-			Map(x => x.Volume);
-			Map(x => x.TstTime);
+            Map(x => x.IsFromToInPct);
+            Map(x => x.Volume);
+			Map(x => x.TestTime);
 			Map(x => x.Repeats);
-            Map(x => x.Emptying);
-            Map(x => x.Zeroing);
-			Map(x => x.PumpPower);
+            Map(x => x.DoDraining);
+            Map(x => x.DoDrainingAfter);
+            Map(x => x.TempLimLo);
+			Map(x => x.TempLimHi);
+            Map(x => x.TempControl);
+            Map(x => x.PumpPower);
             Map(x => x.MassRepeats);
             Map(x => x.MassSpread);
-            Map(x => x.MassMethod);
+			Map(x => x.MassMethod)
+                .CustomType<byte>();
             Map(x => x.TimeBeforeFlow);
             Map(x => x.TimeFlow2Mass);
-            Map(x => x.TimePump2StartV)
-				.Column("TimeMass2Start");
+            Map(x => x.TimePump2StartV);
             Map(x => x.TimeStop2Mass);
 			Map(x => x.Method);
 			Map(x => x.ErrLimLo);
 			Map(x => x.ErrLimHi);
 			Map(x => x.Uncertainty);
-			Map(x => x.TolerRed)
-                .Column("TolerRed");	/// ???
-			Map(x => x.RedType);	    /// ???
+			Map(x => x.ShortPulses);
 			Map(x => x.FeedingPath);
 			Map(x => x.BenchPath);
 			Map(x => x.OutputPath);
 			Map(x => x.MetersPath);
-#if HEAT_METERS_SUPPORT
+#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.TransBefore);
+			Map(x => x.TransBetween);
+			Map(x => x.TransAfter);
+
+            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;
 
@@ -10,12 +10,20 @@ namespace Config.Mappings
         public UserMap()
         {
             Id(x => x.Id);
-            Map(x => x.Name);
-            Map(x => x.Password);
-            Map(x => x.Description);
+            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.9.329.0")]
-[assembly: AssemblyFileVersion("2.9.329.0")]
+[assembly: AssemblyVersion("3.1.1464.0")]
+[assembly: AssemblyFileVersion("3.1.1464.0")]

Config/PurchaseResources.cs

@@ -0,0 +1,7 @@
+namespace Config
+{
+    public class PurchaseResources
+    {
+        
+    }
+}