using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using Logic.ProductionToProductMapper.Cordonel;
using Logic.ProductionToProductMapper.Files.Fw;
using Newtonsoft.Json;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Cryptology.Security;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisFile;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisPwd;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
using Xylem.Common.Logic.ProductionOrderCore.FW;
using Xylem.Common.Logic.ProductionOrderCore.OrderData;
using Xylem.Common.Logic.SoftwareAccessHelper;
using Xylem.Common.Utils.DateTimeServer;
using Xylem.ServiceFwUpdate.Common.FwUpdateSafe;

namespace Xylem.ServiceFwUpdate.Common.FwUpdateDb
{
    /// <summary>
    /// Class for DB interfaces.
    /// </summary>
    [Serializable]
    public class FwUpdateDb
    {

        private const Int32 shortTimeoutDbRequest = 2000;
        private const Int32 moderateTimeoutDbRequest = 10000;
        private const Int32 hugeTimeoutDbRequest = 30000;

        /// <summary>
        /// DB connection cannot be established.
        /// </summary>
        public Boolean DbIsConnected
        {
            get; private set;
        }

        /// <summary>
        /// Complete information of all builder operators registered in DB.
        /// </summary>
        public List<UserInformation> DbAllBuilderOperators
        {
            get; private set;
        }

        /// <summary>
        /// Complete information of all update operators registered in DB.
        /// </summary>
        public List<UserInformation> DbAllUpdateOperators
        {
            get; private set;
        }

        /// <summary>
        /// Cordonel SW package.
        /// </summary>
        public List<FilePart> DbFwUpdateSwPackage
        {
            get; private set;
        }

        /// <summary>
        /// Cordonel configuration files.
        /// </summary>
        public List<FilePart> DbFwUpdateConfigFiles
        {
            get; private set;
        }

        /// <summary>
        /// Cordonel FW packages information.
        /// </summary>
        public List<CordonelFwPackageInfo> DbCordonelFwPackagesInfo
        {
            get; private set;
        }

        /// <summary>
        /// Single Cordonel FW package.
        /// </summary>
        public ClusteredFile DbCordonelFwPackage
        {
            get; private set;
        }

        /// <summary>
        /// Cordonel safes.
        /// </summary>
        public List<ClusteredFile> DbCordonelSafes
        {
            get; private set;
        }

        /// <summary>
        /// Complete information of all searched Cordonel customers.
        /// </summary>
        public List<CordonelCustomerInfosDb> DbSearchedCordonelCustomers
        {
            get; private set;
        }

        /// <summary>
        /// All production orders of Cordonels by a specific customer.
        /// </summary>
        public List<CordonelCustomerOrderDb> DbCordonelCustomerOrders
        {
            get; private set;
        }

        /// <summary>
        /// All serial numbers for a specific Cordonel (Customer serial number, Sensus serial number and PCB ID).
        /// </summary>
        public List<CordonelSerialNumbersDb> DbCordonelSerialNumbers
        {
            get; private set;
        }

        /// <summary>
        /// Complete information of fully qualified users registered in DB.
        /// Only these users can be used for en- and decryption as the Pwd Hash and Hw Id
        /// shall be used for this operation.
        /// </summary>
        public List<UserInformation> DbFullQualifiedUpdateOperators
        {
            get; private set;
        }

        /// <summary>
        /// Get the FW-Update SW validation from DB.
        /// </summary>
        /// <param name="programName"></param>
        /// <param name="swLicense"></param>
        /// <remarks date="2021-Mar-22" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        /// <remarks date="2021-Apr-07" author="Thomas Wiedebusch">
        /// - License assigned in DB access.
        /// </remarks>
        public Boolean GetSwLicenseFromDb(String programName, out SoftwareLicense swLicense)
        {
            swLicense = new SoftwareLicense();
            try
            {
                var url = ServiceUrls.GetSoftwareLicenseUrl();
                var requestResponse = LocalWebRequest.GetRequest(url + programName, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;

                swLicense = JsonConvert.DeserializeObject<SoftwareLicense>(requestResponse);
                return true;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }
        /// <summary>
        /// Get the FW-Update SW validation from DB.
        /// </summary>
        /// <param name="swLicense"></param>
        /// <remarks date="2019-Jun-19" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-01" author="Thomas Wiedebusch">
        /// - Modified.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        public Boolean CheckSwLicenseIsValidFromDb(SoftwareLicense swLicense)
        {
            if (swLicense == null)
                return false;
            try
            {
                var url = ServiceUrls.GetSoftwareStartUpAccessUrl();
                url += $"?Program={swLicense.Program}" +
                       $"&Major={swLicense.Major}" +
                       $"&Minor={swLicense.Minor}" +
                       $"&Build={swLicense.Build}";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                var ret = bool.Parse(requestResponse.Trim('"'));
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                return ret;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }
        /// <summary>
        /// Set the FW-Update SW validation to DB
        /// </summary>
        /// <param name="swLicense"></param>
        /// <remarks date="2021-Mar-22" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Roland Drabesch">
        /// - Modified url string.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        public Boolean SetSwLicenseToDb(SoftwareLicense swLicense)
        {
            if (swLicense == null)
                return false;
            try
            {
                var url = ServiceUrls.SetSoftwareLicenseUrl();
                url += $"{swLicense.Program}&Major={swLicense.Major}&Minor={swLicense.Minor}" +
                       $"&Build={swLicense.Build}&ValidTo={swLicense.ValidTo:yyyy-MM-ddTHH:mm:ss}" +
                       $"&Description={swLicense.Description ?? "null"}&ProgramNameIsUnique={swLicense.ProgramNameIsUnique}";
                var requestResponse = LocalWebRequest.PostRequestAsyncAndGetContent(url, moderateTimeoutDbRequest);
                if (requestResponse != null && string.IsNullOrEmpty(requestResponse) &&
                    !JsonConvert.DeserializeObject<Boolean>(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                return true;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Collect programming parameters from DB.
        /// </summary>
        /// <param name="pcbId"></param>
        /// <param name="recoveryRegisters"></param>
        /// <returns>recovery registers</returns>
        /// <remarks date="2021-Feb-01" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2023-10-19" author="Thomas Wiedebusch">
        /// - Sort the registers from DB but keep the PrepareProgramming and FinalizeProgramming in the required sequence.
        /// </remarks>
        /// <remarks date="2023-10-25" author="Thomas Wiedebusch">
        /// - Removed preparation and finalization of register recovery to remove sequencing as this will be done in the
        ///   RegisterRestorer by the FwUpdateSw worker giving the ability to log this in the report.
        /// </remarks>
        /// <remarks date="2024-01-17" author="Thomas Wiedebusch">
        /// - Use common interface for programming parameters for EOL (shipping) and CUST from <see cref="RegisterRestorer"/>.
        /// </remarks>
        public Boolean DownloadCordonelRecoveryRegistersFromDb(String pcbId, List<RecoveryRegisterItem> recoveryRegisters)
        {
            if (StatusReturn.Okay == RegisterRestorer.DownloadProgrammingParametersFromDb(pcbId, recoveryRegisters))
            {
                DbIsConnected = true;
                return true;
            }

            DbIsConnected = false;
            return false;
        }

        /// <summary>
        /// Collect order number, radio address, skeleton key, password hashes and passwords from DB.
        /// </summary>
        /// <param name="pcbId"></param>
        /// <param name="passwordContainer"></param>
        /// <returns>password container</returns>
        /// <remarks date="2021-Feb-01" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-02" author="Thomas Wiedebusch">
        /// - Returns bool.
        /// </remarks>
        /// <remarks date="2021-Feb-03" author="Thomas Wiedebusch">
        /// - Check content of password container.
        /// </remarks>
        /// <remarks date="2021-Feb-04" author="Thomas Wiedebusch">
        /// - Using software access helper class.
        /// </remarks>
        /// <remarks date="2021-Mar-22" author="Thomas Wiedebusch">
        /// - Additional timeout as the password request will redirected from DB Laatzen to DB Ludwigshafen.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2023-Feb-23" author="Thomas Wiedebusch">
        /// - Used the <see cref="MeterPwdHandlerDb"/> as common interface to request the password container,
        ///   if the password container does not exist, it will be generated.
        /// </remarks>
        /// <remarks date="2023-Oct-17" author="Thomas Wiedebusch">
        /// - Used the <see cref="MeterPwdFile.BuildPwdFile"/> as common routine for password hash file generation out of
        ///   the raw text passwords. This routine verifies the password container.
        /// </remarks>
        /// <remarks date="2024-May-17" author="Thomas Wiedebusch">
        /// - Avoid generation of password file if new generated Lvl8 password is not the Lvl8 production password,
        ///   if the password is the skeleton key the password file was never generated so go ahead.
        /// </remarks>
        public Boolean DownloadCordonelPwdFromDb(String pcbId, out PasswordContainer passwordContainer)
        {
            passwordContainer = new PasswordContainer();
            try
            {
                if (!MeterPwdHandlerDb.RequestPwdFileFromDb(pcbId, out var meterPwdDb))
                {
                    DbIsConnected = false;
                    return false;
                }

                if (meterPwdDb == null )
                {
                    DbIsConnected = false;
                    return false;
                }

                // Avoid generation of password file if new generated Lvl8 password is not the Lvl8 production password,
                // if the password is the skeleton key the password file was never generated so go ahead
                if (meterPwdDb.Password != meterPwdDb.Skeleton &&
                    meterPwdDb.Password != Encoding.UTF8.GetString(meterPwdDb.ListOfPasswords[MeterPwdDb.PwdLevel8Idx]))
                {
                    throw new ApplicationException("Production password is neither the SkeletonKey nor the required level 8 " +
                                                   "password from password service! Password file cannot be generated!");
                }

                DbIsConnected = true;
                passwordContainer.PcbId = pcbId;
                passwordContainer.SkeletonKey =
                    Encoding.UTF8.GetString(meterPwdDb.ListOfPasswords[MeterPwdDb.SkeletonKeyIdx]);
                passwordContainer.PasswordLvl8 =
                    Encoding.UTF8.GetString(meterPwdDb.ListOfPasswords[MeterPwdDb.PwdLevel8Idx]);

                // Use the standard constructor as writing to meter is not necessary
                var meterPwdFile = new MeterPwdFile();
                // The BuildPwdFile has an extended validation check
                var retBol =
                    meterPwdFile.BuildPwdFile(meterPwdDb.ListOfPasswords, 1, passwordContainer.SkeletonKey);

                if (!retBol)
                {
                    DbIsConnected = false;
                    return false;
                }

                passwordContainer.EncryptedPasswordFile = new Byte[MeterPwdDb.PwdFileLength];
                passwordContainer.EncryptedPasswordFile = meterPwdFile.HashedPasswordFile;

                var hashList = new List<Byte>();
                foreach (var hash in meterPwdDb.ListOfHashes)
                {
                    hashList.AddRange(hash);
                }

                var pwdControllerPwdFile = hashList.ToArray();
                //passwordContainer.EncryptedPasswordFile = hashList.ToArray();

                // Compare password controller hashed password file with this generated new one
                for (var c = 0; c < MeterPwdDb.PwdFileLength; c++)
                {
                    if (passwordContainer.EncryptedPasswordFile[c] != pwdControllerPwdFile[c])
                        return false;
                }

                // If the password file is written, the "Password" from meterPwdDb is overwritten from Skeleton-key
                // to the "level 8 password" form the LuDB server. The DB password column is the current login password
                // for production. Initially the "Password" is the Skeleton-key which can not be part of the list of
                // Passwords. The level 8 password is the last in the pwContainer list of passwords.
                if (Encoding.UTF8.GetString(meterPwdDb.ListOfPasswords.Last()) != meterPwdDb.Password)
                {
                    if (!MeterPwdHandlerDb.SetPwdFromSkeletonToLvl8inDd(pcbId, meterPwdDb))
                    {
                        DbIsConnected = false;
                        return false;
                    }
                }

                return !string.IsNullOrEmpty(passwordContainer.SkeletonKey) &&
                       !string.IsNullOrEmpty(passwordContainer.PasswordLvl8) &&
                       passwordContainer.EncryptedPasswordFile.Length == MeterPwdDb.PwdFileLength;
            }
            catch (Exception ex)
            {
                DbIsConnected = false;
                throw new ApplicationException(ex.Message + $" - PcbId: {pcbId}");
            }
        }
        /// <summary>
        /// Get the update operators information from DB needed to generate the primary key for encryption.
        /// This is a direct DB access. The read information from DB may be incomplete as the password hash and
        /// hardware id are optional. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Feb-04" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        public Boolean GetAllUpdateOperatorsFromDb()
        {
            if (DbAllUpdateOperators == null)
                DbAllUpdateOperators = new List<UserInformation>();
            if (DbFullQualifiedUpdateOperators == null)
                DbFullQualifiedUpdateOperators = new List<UserInformation>();
            DbAllUpdateOperators.Clear();
            DbFullQualifiedUpdateOperators.Clear();

            try
            {
                var url = ServiceUrls.ListAllFwUpdateUsersServiceUrl();
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbAllUpdateOperators = JsonConvert.DeserializeObject<List<UserInformation>>(requestResponse);
                if (DbAllUpdateOperators == null || DbAllUpdateOperators.Count == 0 || DbFullQualifiedUpdateOperators == null)
                {
                    return false;
                }

                // If the user is fully qualified it will be put to the DbFullQualifiedUsersInfos list.
                foreach (var user in DbAllUpdateOperators.Where(CheckIfUpdateOperatorIsFullyQualified))
                {
                    // Avoid doubling of names if these are already listed
                    if (DbFullQualifiedUpdateOperators.Any(u => u.FullName == user.FullName))
                        continue;
                    DbFullQualifiedUpdateOperators.Add(user);
                }
                return true;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get the Builder Operator information from DB for user validation check. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Apr-14" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean GetAllBuilderOperatorsFromDb()
        {

            if (DbAllBuilderOperators == null)
                DbAllBuilderOperators = new List<UserInformation>();
            DbAllBuilderOperators.Clear();

            try
            {
                var url = ServiceUrls.ListAllFwUpdateBuilderOperatorsServiceUrl();
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbAllBuilderOperators = JsonConvert.DeserializeObject<List<UserInformation>>(requestResponse);
                return DbAllBuilderOperators != null && DbAllBuilderOperators.Count != 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Load the latest FW update SW package from DB. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Oct-26" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean DownloadFwUpdateSwContainerFromDb()
        {
            try
            {
                var url = ServiceUrls.ListAllSwPackages();
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;

                // get a list of all stored FW update SW packages
                var dbCordonelSwPackages = JsonConvert.DeserializeObject<List<ClusteredFile>>(requestResponse);
                if (dbCordonelSwPackages == null || dbCordonelSwPackages.Count == 0)
                {
                    return false;
                }

                // get latest version
                var fileId = dbCordonelSwPackages.Select(package => package.FileId).Prepend(0).Max();
                if (fileId == 0)
                {
                    return false;
                }

                if (DbFwUpdateSwPackage == null)
                    DbFwUpdateSwPackage = new List<FilePart>();
                DbFwUpdateSwPackage.Clear();

                // download content
                url = ServiceUrls.DownloadFileParts();
                url += $"{fileId}&readContent=true";
                requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbFwUpdateSwPackage = JsonConvert.DeserializeObject<List<FilePart>>(requestResponse);
                return DbFwUpdateSwPackage != null && DbFwUpdateSwPackage.Count > 0;

            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Load the latest FW update configuration files from DB. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Oct-26" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean DownloadFwUpdateConfigurationFilesFromDb()
        {
            try
            {
                var url = ServiceUrls.ListAllConfigurationFilePackages();
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;

                // get a list of all stored FW update config file packages
                var dbConfigFilePackages = JsonConvert.DeserializeObject<List<ClusteredFile>>(requestResponse);
                if (dbConfigFilePackages == null || dbConfigFilePackages.Count == 0)
                {
                    return false;
                }

                // get latest version
                var fileId = dbConfigFilePackages.Select(package => package.FileId).Prepend(0).Max();
                if (fileId == 0)
                {
                    return false;
                }

                if (DbFwUpdateConfigFiles == null)
                    DbFwUpdateConfigFiles = new List<FilePart>();
                DbFwUpdateConfigFiles.Clear();

                // download content
                url = ServiceUrls.DownloadFileParts();
                url += $"{fileId}&readContent=true";
                requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbFwUpdateConfigFiles = JsonConvert.DeserializeObject<List<FilePart>>(requestResponse);
                return DbFwUpdateConfigFiles != null && DbFwUpdateConfigFiles.Count > 0;

            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get all Cordonel safe info files from DB. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Apr-27" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean GetAllCordonelSafeInfoFilesFromDb()
        {
            if (DbCordonelSafes == null)
                DbCordonelSafes = new List<ClusteredFile>();
            DbCordonelSafes.Clear();

            try
            {
                var url = ServiceUrls.ListAllFwUpdateSafes();
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbCordonelSafes = JsonConvert.DeserializeObject<List<ClusteredFile>>(requestResponse);
                return DbCordonelSafes != null && DbCordonelSafes.Count != 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get EOL production parameters for power correction from DB. 
        /// </summary>
        /// <param name="pcbId"></param>
        /// <param name="pwrCorr"></param>
        /// <returns>true if successful</returns>
        /// <remarks date="2024-May-07" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean DownloadDbDataAtEol(String pcbId, ref PowerCorrection pwrCorr)
        {
            try
            {
                var url = ServiceUrls.DownloadDbDataAtEolServiceUrl();
                url += pcbId;
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                pwrCorr = JsonConvert.DeserializeObject<PowerCorrection>(requestResponse);

                return true;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Getting all FW-Update Safes information by user id. The download has to be triggered with
        /// the DownloadFileContentFromDB with FilePartId as reference
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="fwUpdSafeContainers"></param>
        /// <returns>true if containers exists</returns>
        /// <remarks date="2021-Mar-25" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        /// <remarks date="2021-Jun-01" author="Thomas Wiedebusch">
        /// - timeout to 3000 ms.
        /// </remarks>
        public Boolean ListAllFwUpdateSafesOfUserFromDb(Int32 userId, out List<FwUpdateSafeDb> fwUpdSafeContainers)
        {
            fwUpdSafeContainers = new List<FwUpdateSafeDb>();
            try
            {
                var url = ServiceUrls.ListAllFwUpdateSafesForUserServiceUrl();
                url += $"{userId}";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                fwUpdSafeContainers = JsonConvert.DeserializeObject<List<FwUpdateSafeDb>>(requestResponse);
                return fwUpdSafeContainers != null && fwUpdSafeContainers.Count > 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get a single Cordonel safe from DB. 
        /// </summary>
        /// <param name="fileId">the file id previously read with <see cref="GetAllCordonelSafeInfoFilesFromDb"/></param>
        /// <param name="safe">the safe</param>
        /// <param name="readContent">reading content if true, else only the file information</param>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Apr-27" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Jun-01" author="Thomas Wiedebusch">
        /// - timeout to 5000 ms.
        /// </remarks>
        public Boolean GetCordonelSafeFromDb(Int32 fileId, out FilePart safe, Boolean readContent = true)
        {
            safe = new FilePart();
            try
            {
                var url = ServiceUrls.DownloadFileParts();
                url += $"{fileId}&readContent={readContent}";
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                safe = JsonConvert.DeserializeObject<FilePart>(requestResponse);
                return safe != null;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get a single Cordonel FW package from DB. 
        /// </summary>
        /// <param name="fileId">the file id previously read with <see cref="GetAllCordonelFwPackagesInfoFromDb"/></param>
        /// <param name="fwPackage">the FW as package</param>
        /// <param name="readContent">reading content if true, else only the file information</param>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Apr-09" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Jun-01" author="Thomas Wiedebusch">
        /// - Timeout increased to 5000 ms.
        /// </remarks>
        public Boolean GetCordonelFwPackageFromDb(Int32 fileId, out List<FilePart> fwPackage, Boolean readContent = true)
        {
            fwPackage = new List<FilePart>();
            try
            {
                var url = ServiceUrls.DownloadFileParts();
                url += $"{fileId}&readContent={readContent}";
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                fwPackage = JsonConvert.DeserializeObject<List<FilePart>>(requestResponse);
                return fwPackage != null && fwPackage.Count > 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get all Cordonel customers from DB. The return can be used to select a specific customer and get
        /// the customer number which is the base for the order search.
        /// </summary>
        /// <param name="searchPattern">specific search pattern for customer name</param>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Mar-31" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2024-Mar-13" author="Thomas Wiedebusch">
        /// - Moved DB access to <see cref="OrderDetailsDb"/>.
        /// </remarks>
        public Boolean GetAllCordonelCustomersFromDb(String searchPattern = Constants.StrWildcard)
        {
            // for the DB interface a specific search pattern will be used, so replace it from the user interface
            // as there is a Constants.StrWildcard the placeholder for "all".
            searchPattern = searchPattern.Replace(Constants.StrWildcard, "%");
            if (DbSearchedCordonelCustomers == null)
                DbSearchedCordonelCustomers = new List<CordonelCustomerInfosDb>();
            DbSearchedCordonelCustomers.Clear();

            DbIsConnected = OrderDetailsDb.GetAllCordonelCustomersFromDb(out var dbCordonelCustomers, searchPattern);

            foreach (var customer in dbCordonelCustomers)
            {
                DbSearchedCordonelCustomers.Add(customer);
            }

            return DbIsConnected;
        }

        /// <summary>
        /// Get all Cordonel customers orders from DB. The return can be used to select a specific order number
        /// and position which is the base for the Cordonel serial number search.
        /// </summary>
        /// <param name="customerNumber"></param>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Mar-31" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2023-Nov-28" author="Thomas Wiedebusch">
        /// - Sort list by customer order numbers.
        /// </remarks>
        /// <remarks date="2024-Mar-13" author="Thomas Wiedebusch">
        /// - Moved DB access to <see cref="OrderDetailsDb"/>.
        /// </remarks>
        public Boolean GetAllCordonelCustomerOrdersFromDb(Int64 customerNumber)
        {
            if (DbCordonelCustomerOrders == null)
                DbCordonelCustomerOrders = new List<CordonelCustomerOrderDb>();
            DbCordonelCustomerOrders.Clear();

            DbIsConnected = OrderDetailsDb.GetAllCordonelCustomerOrdersFromDb(customerNumber, 
                out var  dbCordonelCustomerOrders);

            foreach (var order in dbCordonelCustomerOrders)
            {
                DbCordonelCustomerOrders.Add(order);
            }

            return DbIsConnected;
        }

        /// <summary>
        /// Get all Cordonel serial numbers of a specific order.
        /// </summary>
        /// <param name="orderNumber"></param>
        /// <param name="orderPos"></param>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Mar-31" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2024-Mar-13" author="Thomas Wiedebusch">
        /// - Moved DB access to <see cref="OrderDetailsDb"/>.
        /// </remarks>
        public Boolean GetAllCordonelSerialNumbersFromDb(Int64 orderNumber, Int64 orderPos)
        {
            if (DbCordonelSerialNumbers == null)
                DbCordonelSerialNumbers = new List<CordonelSerialNumbersDb>();
            DbCordonelSerialNumbers.Clear();

            DbIsConnected = OrderDetailsDb.GetAllCordonelSerialNumbersFromDb(orderNumber, orderPos, out var dbSerialNumbers); 

            foreach (var serialNumber in dbSerialNumbers)
            {
                DbCordonelSerialNumbers.Add(serialNumber);
            }

            return DbIsConnected;
        }
        /// <summary>
        /// Get all Cordonel FW packages information from DB.
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2022-Nov-30" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean GetAllCordonelFwPackagesInfoFromDb()
        {
            if (DbCordonelFwPackagesInfo == null)
                DbCordonelFwPackagesInfo = new List<CordonelFwPackageInfo>();
            DbCordonelFwPackagesInfo.Clear();

            try
            {
                var url = ServiceUrls.ListAllCordonelFwPackagesUrl();
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                DbCordonelFwPackagesInfo =
                    JsonConvert.DeserializeObject<List<CordonelFwPackageInfo>>(requestResponse);
                return DbCordonelFwPackagesInfo != null && DbCordonelFwPackagesInfo.Count != 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }
        /// <summary>
        /// Simple command to access the DB and check therefore if it is available. 
        /// </summary>
        /// <returns>true if successful</returns>
        /// <remarks date="2021-Feb-04" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - Timeout extended to 1200 ms.
        /// </remarks>
        public Boolean CheckDbConnection()
        {
            try
            {
                var url = ServiceUrls.GetFwUpdateUserByIdServiceUrl();
                url += "0";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                return true;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Check if user is registered to DB with all contents including Hw Id and pwd hash.
        /// The DbAllUsersInfos has to be loaded or updated in advance, which will be done in the Ctor or on every
        /// registration of a new user or update of Hw Id or User Pwd Hash <see cref="GetAllUpdateOperatorsFromDb"/>.
        /// The first fully specified user will be returned by its user id. This routine can be used to create
        /// the Db
        /// </summary>
        /// <param name="dbCheckFullSpecUpdateOperator">
        /// - user to search for registration in DB with full specification,
        /// - the search parameter is the FullName,
        /// - the first found full qualified DB user will set the user id</param>
        /// <returns>true if user is registered in DB</returns>
        /// <remarks date="2021-Feb-10" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Input full specified user info.
        /// </remarks>
        private Boolean CheckIfUpdateOperatorIsFullyQualified(UserInformation dbCheckFullSpecUpdateOperator)
        {
            // The fully specified user has to be defined by FullName, LogInName, Domain, Hw Id and User Pwd Hash.
            // The user id mustn't be set as this will be returned by the DB search.
            if (dbCheckFullSpecUpdateOperator == null || DbAllUpdateOperators == null ||
                DbAllUpdateOperators.Count == 0 ||
                string.IsNullOrEmpty(dbCheckFullSpecUpdateOperator.FullName) ||
                string.IsNullOrEmpty(dbCheckFullSpecUpdateOperator.LogInName) ||
                string.IsNullOrEmpty(dbCheckFullSpecUpdateOperator.Domain) ||
                string.IsNullOrEmpty(dbCheckFullSpecUpdateOperator.HardwareId) ||
                string.IsNullOrEmpty(dbCheckFullSpecUpdateOperator.PasswordHash))
                return false;

            foreach (var user in DbAllUpdateOperators.Where(user =>
                user.FullName == dbCheckFullSpecUpdateOperator.FullName &&
                user.LogInName == dbCheckFullSpecUpdateOperator.LogInName &&
                user.Domain == dbCheckFullSpecUpdateOperator.Domain &&
                user.HardwareId == dbCheckFullSpecUpdateOperator.HardwareId &&
                user.PasswordHash == dbCheckFullSpecUpdateOperator.PasswordHash))
            {
                dbCheckFullSpecUpdateOperator.Id = user.Id;
                return true;
            }
            return false;
        }

        /// <summary>
        /// Register user to DB. This is a direct DB access. The user hardware id and and password hash are optional.
        /// The dbNewUser will get his user id on registration.
        /// </summary>
        /// <param name="dbNewUser">new user to register to DB</param>
        /// <returns>true if successful and all fields set except pwd hash and hw id</returns>
        /// <remarks date="2021-Feb-08" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Extended to full registration, optional hw id and pwd hash,
        /// - Refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists.
        /// </remarks>
        /// <remarks date="2021-Mar-12" author="Thomas Wiedebusch">
        /// - Set initial validation date.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2021-Mar-30" author="Thomas Wiedebusch">
        /// - Added initial valid date.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        private Boolean RegisterUpdateOperatorToDbAndRefreshLists(UserInformation dbNewUser)
        {
            // The new user has to be defined by FullName, LogInName and Domain
            if (dbNewUser == null || string.IsNullOrEmpty(dbNewUser.FullName) ||
                string.IsNullOrEmpty(dbNewUser.LogInName) || string.IsNullOrEmpty(dbNewUser.Domain))
                return false;

            // Hw Id and Pwd Hash are optional on initial registration
            if (dbNewUser.HardwareId == null)
                dbNewUser.HardwareId = "";
            if (dbNewUser.PasswordHash == null)
                dbNewUser.PasswordHash = "";

            var validDateTime = DateTimeServer.SetValidationDate(FwUpdateConfig.Consts.FwUpdateConfig.ValidDays);
            try
            {
                var url = ServiceUrls.CreateNewFwUpdateUserServiceUrl();
                url += $"FullName={dbNewUser.FullName}" +
                       $"&LoginName={dbNewUser.LogInName}" +
                       $"&Domain={dbNewUser.Domain}" +
                       $"&HardwareId={dbNewUser.HardwareId}" +
                       $"&PasswordHash={dbNewUser.PasswordHash} +" +
                       $"&ValidDate={validDateTime:yyyy-MM-ddTHH:mm:ss}&AccountActive=true";
                var requestResponse = LocalWebRequest.GetRequest(url, 5000);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                // During registration the user id will be set. This is needed to access later the hw id and pwd hash.
                dbNewUser.Id = JsonConvert.DeserializeObject<Int32>(requestResponse);

                // Set validation date and refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists
                return RefreshValidDateToDbAndRefreshUserLists(dbNewUser.Id);
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Set user pwd hash to DB. This is a direct DB access. The user has to be referenced by id.
        /// On every refresh the DbAllUsersInfos and DbFullQualifiedUsersInfos lists will be generated
        /// <see cref="GetAllUpdateOperatorsFromDb"/>.
        /// </summary>
        /// <param name="dbUserId">user id as reference</param>
        /// <param name="dbUserPwdHash">the password hash as string</param>
        /// <remarks date="2021-Feb-04" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Input is user Id and pwd hash as string.
        /// - Refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists.
        /// </remarks>
        /// <remarks date="2021-Mar-12" author="Thomas Wiedebusch">
        /// - Refresh validation date.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        private void RefreshPwdHashToDbAndRefreshUserLists(Int32 dbUserId, String dbUserPwdHash)
        {
            if (dbUserId < 0 || string.IsNullOrEmpty(dbUserPwdHash))
                return;
            try
            {
                var url = ServiceUrls.RefreshFwUpdateUsersPasswordHashServiceUrl();
                url += $"{dbUserId}&PasswordHash={dbUserPwdHash}";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return;
                }

                DbIsConnected = true;
                if (!JsonConvert.DeserializeObject<Boolean>(requestResponse))
                    return;

                // Set validation date and refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists
                RefreshValidDateToDbAndRefreshUserLists(dbUserId);
            }
            catch (Exception)
            {
                DbIsConnected = false;
            }
        }

        /// <summary>
        /// Set user validation to DB. This is a direct DB access. The user has to be referenced by id.
        /// On every refresh the DbAllUsersInfos and DbFullQualifiedUsersInfos lists will be generated.
        /// <see cref="GetAllUpdateOperatorsFromDb"/>.
        /// </summary>
        /// <param name="dbUserId">user id as reference</param>
        /// <remarks date="2021-Mar-12" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Mar-15" author="Thomas Wiedebusch">
        /// - Valid date as string.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        private Boolean RefreshValidDateToDbAndRefreshUserLists(Int32 dbUserId)
        {
            if (dbUserId < 0)
                return false;
            try
            {
                var validDateTime = DateTimeServer.SetValidationDate(FwUpdateConfig.Consts.FwUpdateConfig.ValidDays);
                var url = ServiceUrls.EditFwUpdateUserValidityServiceUrl();
                url += $"{dbUserId}&ValidDate={validDateTime:yyyy-MM-ddTHH:mm:ss}&AccountActive=true";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }
                DbIsConnected = true;

                // Refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists
                return JsonConvert.DeserializeObject<Boolean>(requestResponse) && GetAllUpdateOperatorsFromDb();
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Set user hw id to DB. This is a direct DB access. The user has to be referenced by the user Id.
        /// On every refresh the DbAllUsersInfos and DbFullQualifiedUsersInfos lists will be generated
        /// <see cref="GetAllUpdateOperatorsFromDb"/>.
        /// </summary>
        /// <param name="dbUserId">user id as reference</param>
        /// <param name="dbHwId">the hardware identifier as string</param>
        /// <remarks date="2021-Feb-04" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Input is user Id and Hw Id as string. Refresh 
        /// - Refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists.
        /// </remarks>
        /// <remarks date="2021-Mar-12" author="Thomas Wiedebusch">
        /// - Refresh validation date.
        /// </remarks>
        /// <remarks date="2021-Mar-25" author="Thomas Wiedebusch">
        /// - Set DB connection state.
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        private void RefreshHwIdToDbAndRefreshUserLists(Int32 dbUserId, String dbHwId)
        {
            if (dbUserId < 0 || string.IsNullOrEmpty(dbHwId))
                return;
            try
            {
                var url = ServiceUrls.RefreshFwUpdateUsersHardwareIdServiceUrl();
                url += $"{dbUserId}&HardwareId={dbHwId}";
                var requestResponse = LocalWebRequest.GetRequest(url, moderateTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return;
                }

                DbIsConnected = true;
                if (!JsonConvert.DeserializeObject<Boolean>(requestResponse))
                    return;

                // Set validation date and refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists
                RefreshValidDateToDbAndRefreshUserLists(dbUserId);
            }
            catch (Exception)
            {
                DbIsConnected = false;
            }
        }

        /// <summary>
        /// Get all user infos by full name. The user information needed to be fully registered.
        /// All user infos will be returned. The first user will be taken where the FullName, Domain, LogInName
        /// HW Id and pwd hash matches and the Id is set. The DbFullQualifiedUsersInfos will be set in advance in
        /// the <see cref="GetAllUpdateOperatorsFromDb"/> and has been verified to be fully qualified.
        /// </summary>
        /// <param name="userName">user name to search for</param>
        /// <param name="dbFullQualifiedUser">user to search for registration in DB with full name only, all contents
        /// will be filled with the information out of DbFullQualifiedUsersInfos</param>
        /// <returns>
        /// - true if user is registered in DB and sets all other informational fields,
        /// - false if the essential fields are missed.
        /// </returns>
        /// <remarks date="2021-Feb-10" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Input user name to get at all infos of fully qualified user.
        /// </remarks>
        /// <remarks date="2021-MAr-08" author="Thomas Wiedebusch">
        /// - Input user name to search for,
        /// - UserInformation object will be build here to avoid preset requirements of name.
        /// </remarks>
        public Boolean GetFullQualifiedUserByFullName(String userName, out UserInformation dbFullQualifiedUser)
        {
            // The user has to be defined by FullName only. It will be searched in DbFullQualifiedUsersInfos as this
            // list is already checked for fully qualification.
            dbFullQualifiedUser = new UserInformation();
            if (dbFullQualifiedUser == null || DbFullQualifiedUpdateOperators == null ||
                DbFullQualifiedUpdateOperators.Count == 0 || string.IsNullOrEmpty(userName))
                return false;

            foreach (var user in DbFullQualifiedUpdateOperators.Where(user => user.FullName == userName))
            {
                return CloneUser(dbFullQualifiedUser, user);
            }
            return false;
        }

        /// <summary>
        /// Get all user infos by full name. User needn't to be be fully registered, but domain, logInName
        /// and FullName are essential. All user infos will be returned. The first user will be taken where
        /// the FullName, Domain and LogInName matches and the Id is set.
        /// </summary>
        /// <param name="dbAllRegUserByFullName">user to search for registration in DB with full name only</param>
        /// <returns>
        /// - true if user is registered in DB and sets all other informational fields,
        /// - false if the essential fields are missed.
        /// </returns>
        /// <remarks date="2021-Feb-10" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Input user name to get at least the user id, but all other infos will be returned as well.
        /// </remarks>
        public Boolean GetUserFromAllRegUsersByFullName(UserInformation dbAllRegUserByFullName)
        {
            // The user has to be defined by FullName only. It will be searched in DbAllUsersInfos
            if (dbAllRegUserByFullName == null || DbAllUpdateOperators == null || DbAllUpdateOperators.Count == 0 ||
                string.IsNullOrEmpty(dbAllRegUserByFullName.FullName))
                return false;

            foreach (var user in DbAllUpdateOperators.Where(user => user.FullName == dbAllRegUserByFullName.FullName))
            {
                // Skip all users which do not have set the essential needed elements: Domain, LogInName and FullName.
                if (string.IsNullOrEmpty(user.Domain) || string.IsNullOrEmpty(user.LogInName))
                    continue;

                return CloneUser(dbAllRegUserByFullName, user);
            }
            return false;
        }

        /// <summary>
        /// Clone user with all contents
        /// </summary>
        /// <param name="destinationUser"></param>
        /// <param name="sourceUser"></param>
        /// <returns>true if users are identical</returns>
        /// <remarks date="2021-Feb-12" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public static Boolean CloneUser(UserInformation destinationUser, UserInformation sourceUser)
        {
            if (destinationUser == null || sourceUser == null)
                return false;
            destinationUser.Id = sourceUser.Id;
            destinationUser.FullName = sourceUser.FullName;
            destinationUser.Domain = sourceUser.Domain;
            destinationUser.LogInName = sourceUser.LogInName;
            destinationUser.PasswordHash = sourceUser.PasswordHash;
            destinationUser.HardwareId = sourceUser.HardwareId;
            destinationUser.RegisterDate = sourceUser.RegisterDate;
            destinationUser.ValidDate = sourceUser.ValidDate;
            destinationUser.AccountActive = sourceUser.AccountActive;
            return true;
        }

        /// <summary>
        /// Compare two users with all contents.
        /// </summary>
        /// <param name="user1"></param>
        /// <param name="user2"></param>
        /// <returns>true if users are identical</returns>
        /// <remarks date="2021-Feb-12" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public static Boolean UsersAreIdentical(UserInformation user1, UserInformation user2)
        {
            return user1.Id == user2.Id &&
                   user1.FullName == user2.FullName &&
                   user1.Domain == user2.Domain &&
                   user1.LogInName == user2.LogInName &&
                   user1.PasswordHash == user2.PasswordHash &&
                   user1.HardwareId == user2.HardwareId &&
                   user1.RegisterDate == user2.RegisterDate &&
                   user1.ValidDate == user2.ValidDate &&
                   user1.AccountActive == user2.AccountActive;
        }

        /// <summary>
        /// Register new user or refresh password hash and Hw Id.
        /// </summary>
        /// <param name="newUser">user to search for registration in DB</param>
        /// <returns>true if user is registered in DB</returns>
        /// <remarks date="2021-Feb-11" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Feb-12" author="Thomas Wiedebusch">
        /// - Backup newUserInfo before trying to GetPartialRegisteredUser.. as this overwrites all elements
        ///   and therefor the NEW pwd hash and/or NEW hw id will be lost and couldn't be changed.
        /// </remarks>
        public Boolean UserRegisterOrRefresh(UserInformation newUser)
        {
            if (newUser == null)
                return false;

            // Use a new dbUser for the search to avoid overwriting of newUserInfo. Copy the minimal elements which are
            // needed for a registered users: Domain, LogInName and FullName.
            var dbUser = new UserInformation
            {
                FullName = newUser.FullName,
                Domain = newUser.Domain,
                LogInName = newUser.LogInName
            };
            // This routine returns at least the needed user id for refresh of pwd hash and hw id.
            // This user can be in both lists, fully qualified or partial in all users list.
            if (GetUserFromAllRegUsersByFullName(dbUser))
            {
                // The dbUser has feedback the user id and the newUserInfo contains the info to change.
                newUser.Id = dbUser.Id;

                if (!string.IsNullOrEmpty(newUser.PasswordHash) && dbUser.PasswordHash != newUser.PasswordHash)
                {
                    // The DbAllUsersInfos and DbFullQualifiedUsersInfos will be refreshed.
                    RefreshPwdHashToDbAndRefreshUserLists(newUser.Id, newUser.PasswordHash);
                }

                if (!string.IsNullOrEmpty(newUser.HardwareId) && dbUser.HardwareId != newUser.HardwareId)
                {
                    // The DbAllUsersInfos and DbFullQualifiedUsersInfos will be refreshed.
                    RefreshHwIdToDbAndRefreshUserLists(newUser.Id, newUser.HardwareId);
                }
            }

            // Check if the user is fully qualified! 
            if (CheckIfUpdateOperatorIsFullyQualified(newUser))
            {
                // Set validation date and refresh all DbAllUsersInfos and DbFullQualifiedUsersInfos lists
                RefreshValidDateToDbAndRefreshUserLists(newUser.Id);
                return true;
            }
            // Or if the user is at least initially set without Hw Id and/ or Pwd Hash 
            if (GetUserFromAllRegUsersByFullName(newUser))
                return true;
            // If the user is unknown, it shall be initially registered. The fields pwd hash and hw id are optional,
            // but only fully registered users can be used for en- and decryption. This will also refresh the
            // DbAllUsersInfos and DbFullQualifiedUsersInfos lists.
            return RegisterUpdateOperatorToDbAndRefreshLists(newUser);
        }

        /// <summary>
        /// Refresh actual validation date if FW-Update Safes are existing or create new password hash if not
        /// to invalidate the old FW-Update Safes.
        /// </summary>
        /// <param name="regUser"></param>
        /// <param name="keepActualPwdHash"></param>
        /// <returns>true if refresh succeeded</returns>
        /// <remarks date="2021-Mar-29" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        public Boolean RefreshUserValidation(UserInformation regUser, Boolean keepActualPwdHash)
        {
            if (regUser == null || string.IsNullOrEmpty(regUser.FullName))
                return false;

            // All user information shall be set as the user needs to be fully
            // qualified. This form adds exclusively the FullName of the user,
            // so that the "FW-Update Builder" operator can select a real user name!
            var newUser = new UserInformation
            {
                FullName = regUser.FullName
            };
            // Keep the password hash as an encrypted container exists
            if (keepActualPwdHash)
            {
                return UserRegisterOrRefresh(regUser);
            }

            // create a new password hash to invalidate all previously created password safes
            CryptInformation.GetSysUser(newUser);
            return UserRegisterOrRefresh(newUser);
        }
        /// <summary>
        /// Download FW update safe referenced by container id
        /// </summary>
        /// <param name="containerId"></param>
        /// <returns>true if file content exists</returns>
        /// <remarks date="2021-Apr-28" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        public List<FwUpdateSafeDb> DownloadFwUpdateSafeFromDb(Int32 containerId)
        {
            var fwUpdateSafes = new List<FwUpdateSafeDb>();
            try
            {
                var url = ServiceUrls.DownloadFwUpdateSafeServiceUrl();
                url += $"{containerId}";
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return fwUpdateSafes;
                }

                DbIsConnected = true;
                fwUpdateSafes = JsonConvert.DeserializeObject<List<FwUpdateSafeDb>>(requestResponse);

                return fwUpdateSafes;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return fwUpdateSafes;
            }
        }

        /// <summary>
        /// Download all pcbIds contained in a special FW update safe for information referenced by container id
        /// </summary>
        /// <param name="containerId"></param>
        /// <returns>true if file content exists</returns>
        /// <remarks date="2021-Oct-29" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        public List<String> GetFwUpdateSafePcbIdsFromDb(Int32 containerId)
        {
            var fwUpdateSafesPcbIds = new List<String>();
            try
            {
                var url = ServiceUrls.ListAllPcbIdsFromSafe();
                url += $"{containerId}";
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return fwUpdateSafesPcbIds;
                }

                DbIsConnected = true;
                fwUpdateSafesPcbIds = JsonConvert.DeserializeObject<List<String>>(requestResponse);

                return fwUpdateSafesPcbIds;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return fwUpdateSafesPcbIds;
            }
        }

        /// <summary>
        /// Getting file contents referenced by file part id.
        /// -http://localhost:56011/GetFileContent?FileId=3831
        /// </summary>
        /// <param name="filePartId"></param>
        /// <param name="fileContent"></param>
        /// <returns>true if file content exists</returns>
        /// <remarks date="2021-Mar-25" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        public Boolean DownloadFileContentFromDb(Int32 filePartId, out Byte[] fileContent)
        {
            fileContent = new Byte[] { };
            try
            {
                var url = ServiceUrls.DownloadFileContentServiceUrl();
                url += "{filePartId}";
                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                fileContent = JsonConvert.DeserializeObject<Byte[]>(requestResponse);

                return fileContent != null && fileContent.Length > 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get reports from DB.
        /// It can be searched for:
        /// PCB ID,
        /// User ID,
        /// Order Number,
        /// Read content ( if false, a preview is available only).
        /// Leaving all empty will search all reports.
        /// </summary>
        /// <param name="fwUpdRpt">list of reports</param>
        /// <param name="pcbId">optional pcbId</param>
        /// <param name="userId">optional userId</param>
        /// <param name="orderNr">optional order number</param>
        /// <param name="readContent">if false a preview of the reports will be loaded</param>
        /// <returns>true reports could be loaded</returns>
        /// <remarks date="2021-Apr-30" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Oct-29" author="Thomas Wiedebusch">
        /// - Read content.
        /// </remarks>
        public Boolean DownloadFwUpdateReportsFromDb(out List<FwUpdateReportDb> fwUpdRpt, Int64 pcbId = 0,
            Int32 userId = 0, Int64 orderNr = 0, Boolean readContent = false)
        {
            fwUpdRpt = new List<FwUpdateReportDb>();
            try
            {
                var url = ServiceUrls.DownloadFwUpdateReportServiceUrl();
                if (pcbId > 0)
                {
                    url += $"PcbId={pcbId}";
                    if (userId > 0)
                        url += $"&UserId={userId}";
                    if (orderNr > 0)
                        url += $"&OrderNr={orderNr}";
                }
                else if (userId > 0)
                {
                    url += $"UserId={userId}";
                    if (orderNr > 0)
                        url += $"&OrderNr={orderNr}";
                }
                else if (orderNr > 0)
                {
                    url += $"OrderNr={orderNr}";
                }

                url += $"&readContent={readContent}";

                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                fwUpdRpt = JsonConvert.DeserializeObject<List<FwUpdateReportDb>>(requestResponse);
                return fwUpdRpt != null && fwUpdRpt.Count != 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }
        /// <summary>
        /// Upload the report file to DB.
        /// </summary>
        /// <param name="fwUpdRpt"></param>
        /// <returns>true if file could be uploaded</returns>
        /// <remarks date="2021-Mar-25" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Mar-29" author="Roland Drabesch">
        /// - Changed to FwUpdateReportDb.
        /// </remarks>
        /// <remarks date="2021-Apr-30" author="Roland Drabesch">
        /// - DB interface restructured.
        /// </remarks>
        public Boolean UploadFwUpdateReportToDb(FwUpdateReportDb fwUpdRpt)
        {
            try
            {
                var url = ServiceUrls.UploadFwUpdateReportServiceUrl();

                if (LocalWebRequest.PostRequestAsync(url, hugeTimeoutDbRequest, fwUpdRpt))
                {
                    DbIsConnected = true;
                    return true;
                }

                DbIsConnected = false;
                return false;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Upload the FW-Update Safe as container to DB.
        /// </summary>
        /// <param name="fwUpdateSafeDb"></param>
        /// <param name="pcbIds"></param>
        /// <returns>true if file could be uploaded</returns>
        /// <remarks date="2021-Mar-25" author="Roland Drabesch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-27" author="Roland Drabesch">
        /// - Set container Id, needed to assign PCB IDs.
        /// </remarks>
        public Boolean UploadFwUpdateSafeToDb(FwUpdateSafeDb fwUpdateSafeDb, List<String> pcbIds)
        {
            if (fwUpdateSafeDb == null)
                return false;
            fwUpdateSafeDb.ContainerId = 0;
            try
            {
                var url = ServiceUrls.UploadFwUpdateSafeContainerServiceUrl();
                url += $"?PUserId={fwUpdateSafeDb.UserId}";
                url += $"&PFileName={fwUpdateSafeDb.Name}";
                url += $"&PValidDate={fwUpdateSafeDb.ValidDate:yyyy-MM-ddTHH:mm:ss}";
                url += $"&PBuilderOperatorName={fwUpdateSafeDb.BuilderOperatorName}";

                var success = LocalWebRequest.PostBinaryFileRequestAsync(url, fwUpdateSafeDb.Name, fwUpdateSafeDb.Content, out var requestResponse);

                var containerId = JsonConvert.DeserializeObject<Int32>(requestResponse);
                if (success && !string.IsNullOrEmpty(requestResponse) && containerId > 0)
                {
                    fwUpdateSafeDb.ContainerId = containerId;

                    url = ServiceUrls.AddPcbIdsToSafeServiceUrl();
                    url += containerId;
                    if (LocalWebRequest.PostRequestAsync(url, hugeTimeoutDbRequest, pcbIds))
                    {
                        DbIsConnected = true;
                        return true;
                    }
                }

                DbIsConnected = false;
                return false;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Upload installed FW versions and core revision to DB. 
        /// </summary>
        /// <param name="pcbId"></param>
        /// <param name="apps"></param>
        /// <returns>true if apps could be uploaded</returns>
        /// <remarks date="2021-Feb-12" author="Roland Drabesch">
        /// - Initial
        /// </remarks>
        /// <remarks date="2021-Mar-10" author="Thomas Wiedebusch">
        /// - Changed version from Uint32 to String
        /// </remarks>
        /// <remarks date="2021-Apr-06" author="Thomas Wiedebusch">
        /// - timeout to 1200 ms.
        /// </remarks>
        /// <remarks date="2021-Apr-07" author="Thomas Wiedebusch">
        /// - changed service url.
        /// </remarks>
        public Boolean UploadCordonelAppVersionsToDb(Int64 pcbId, List<CordonelAppVersion> apps)
        {
            try
            {
                var url = ServiceUrls.UploadCordonelAppVersionServiceUrl();
                url += $"{pcbId}&ProgressName={Assembly.GetExecutingAssembly().GetName().Name}";
                url += $"&version={Assembly.GetExecutingAssembly().GetName().Version}";

                if (LocalWebRequest.PostRequestAsync(url, moderateTimeoutDbRequest, apps))
                {
                    DbIsConnected = true;
                    return true;
                }

                DbIsConnected = false;
                return false;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }

        /// <summary>
        /// Get all installed application versions from DB.
        /// </summary>
        /// <param name="pcbId"></param>
        /// <param name="apps"></param>
        /// <returns>true if app list could be loaded</returns>
        /// <remarks date="2021-Apr-07" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        /// <remarks date="2021-Apr-15" author="Thomas Wiedebusch">
        /// - Add request for radio version.
        /// </remarks>
        public Boolean DownloadCordonelAppVersionsFromDb(String pcbId, out List<CordonelAppVersion> apps)
        {
            apps = new List<CordonelAppVersion>();
            try
            {
                var url = ServiceUrls.DownloadCordonelAppVersionServiceUrl();
                url += $"{pcbId}&returnRadioFRQ=true";

                var requestResponse = LocalWebRequest.GetRequest(url, hugeTimeoutDbRequest);
                if (string.IsNullOrEmpty(requestResponse))
                {
                    DbIsConnected = false;
                    return false;
                }

                DbIsConnected = true;
                apps = JsonConvert.DeserializeObject<List<CordonelAppVersion>>(requestResponse);
                return apps != null && apps.Count != 0;
            }
            catch (Exception)
            {
                DbIsConnected = false;
                return false;
            }
        }
    }
}