laatzen/Common/CordonelPreadjustmentUi/Processes/Actions/CompletionProcess.cs

using CordonelPreadjustmentUi.Processes.Itinerary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts;
using Xylem.Common.Logic.SoftwareAccessHelper;
using static CordonelPreadjustmentUi.PreAdjustmentControl;

namespace CordonelPreadjustmentUi.Processes.Actions
{
    public class CompletionProcess : BaseProcess
    {

        public CompletionProcess(string processName, StatusPanelItems panelState, string performMessage, string failedMessage, int? expectedTimeS) : base(processName, panelState, performMessage, failedMessage, expectedTimeS)
        {
        }

        public override List<Task> StartWork()
        {
            return doWorkProcess(base.CurrentProcessProgress);
        }

        private List<Task> doWorkProcess(ProcessProgress pp)
        {
            var MetersToProcess = MeterStateCtls.Where(e => e.IsEnabled || e.Failed).ToList();

            var listOfProcessTask = new List<Task>();
            pp.IsBusy = true;

            MetersToProcess.ForEach(m => m.StopTempWatch());
           
            foreach (var meterctl in MetersToProcess)
            {
                listOfProcessTask.Add(new Task<bool>(() =>
                {
                    var Result = true;
                    pp.DebugMessage($"Performing {ProcessName} procedure", null, "APP");

                    try
                    {
                        meterctl.Meter.ReLogin();
                        var Ok = false;
                        if (!meterctl.Failed)
                        {


                            Ok = WriteRegisterSafe(meterctl.Meter, $"Samplerate", Register.Genesisflow.SampleRate, 10);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                            Ok = WriteRegisterSafe(meterctl.Meter, $"LED mode", Register.Genesisflow.LedMode, (Byte)6);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                            Ok = WriteRegisterSafe(meterctl.Meter, $"Store calibration", Register.Genesisflow.StoreCalibration, 1, false);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                            pp.DebugMessage($"Read out", meterctl.Slot, "CC");
                            Thread.Sleep(1000);


                            try
                            {
                                if (meterctl.Meter.GetRegistersDic().Any(a => a.Key.RegisterName == "GENESISFLOW_DelayedLedOff"))
                                {
                                    meterctl.Meter.WriteRegister("GENESISFLOW_DelayedLedOff", 60 * 60 * 2, true);
                                    meterctl.Meter.WriteLog($"GENESISFLOW_DelayedLedOff to {60 * 60 * 2}S");

                                }
                                else
                                {
                                    meterctl.Meter.WriteLog($"GENESISFLOW_DelayedLedOff is not present");
                                }
                            }
                            catch (Exception ex)
                            {

                                meterctl.Meter.WriteLog($"GENESISFLOW_DelayedLedOff got error {ex.Message}");
                            }
                        }
                        else
                        {
                            Ok = WriteRegisterSafe(meterctl.Meter, $"Samplerate", Register.Genesisflow.SampleRate, 2);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                            Ok = WriteRegisterSafe(meterctl.Meter, $"LED mode", Register.Genesisflow.LedMode, (Byte)0);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                        }



                        var readsOk = new List<bool>();
                        byte[] retByte;
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "MeterSize", Register.Genesisflow.MeterSize, out retByte));
                        meterctl.Meter.calibrationResult.MeterSize = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "CalFactor1", Register.Genesisflow.CalFactor1, out retByte));
                        meterctl.Meter.calibrationResult.CalFactor1 = RegisterConverter.ByteArrayToValue<uint>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "CalFactor2", Register.Genesisflow.CalFactor2, out retByte));
                        meterctl.Meter.calibrationResult.CalFactor2 = RegisterConverter.ByteArrayToValue<uint>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "CalFactor3", Register.Genesisflow.CalFactor3, out retByte));
                        meterctl.Meter.calibrationResult.CalFactor3 = RegisterConverter.ByteArrayToValue<uint>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "ZeroOffset1", Register.Genesisflow.ZeroOffset1, out retByte));
                        meterctl.Meter.calibrationResult.ZeroOffset1 = RegisterConverter.ByteArrayToValue<int>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "ZeroOffset2", Register.Genesisflow.ZeroOffset2, out retByte));
                        meterctl.Meter.calibrationResult.ZeroOffset2 = RegisterConverter.ByteArrayToValue<int>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "ZeroOffset3", Register.Genesisflow.ZeroOffset3, out retByte));
                        meterctl.Meter.calibrationResult.ZeroOffset3 = RegisterConverter.ByteArrayToValue<int>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "FirstHitUpdatePeriod", Register.Genesisflow.FirstHitUpdatePeriod, out retByte));
                        meterctl.Meter.calibrationResult.FirstHitUpdatePeriod = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "FirstHitShift", Register.Genesisflow.FirstHitShift, out retByte));
                        meterctl.Meter.calibrationResult.FirstHitShift = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "FirstHitPercent1", Register.Genesisflow.FirstHitPercent1, out retByte));
                        meterctl.Meter.calibrationResult.FirstHitPercent1 = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "FirstHitPercent2", Register.Genesisflow.FirstHitPercent2, out retByte));
                        meterctl.Meter.calibrationResult.FirstHitPercent2 = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "FirstHitPercent3", Register.Genesisflow.FirstHitPercent3, out retByte));
                        meterctl.Meter.calibrationResult.FirstHitPercent3 = RegisterConverter.ByteArrayToValue<ushort>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "ToFTempOffset1", Register.Genesisflow.ToFTempOffset1, out retByte));
                        meterctl.Meter.calibrationResult.ToFTempOffset1 = RegisterConverter.ByteArrayToValue<int>(retByte);
                        readsOk.Add(ReadRegisterRetry(meterctl.Meter, "ToFTempOffset2", Register.Genesisflow.ToFTempOffset2, out retByte));
                        meterctl.Meter.calibrationResult.ToFTempOffset2 = RegisterConverter.ByteArrayToValue<int>(retByte);
                        readsOk.Add(ReadRegister(meterctl.Meter, "ToFTempOffset3", Register.Genesisflow.ToFTempOffset3, out retByte));
                        meterctl.Meter.calibrationResult.ToFTempOffset3 = RegisterConverter.ByteArrayToValue<int>(retByte);

                        if (readsOk.Any(a => !a))
                        {
                            Ok = false;
                        }
                        if (CheckAbort(Ok, meterctl)) { return Ok; }

                        Exception exPost = new Exception();
                        int code = 0;
                        var tempP = "";

                        if (meterctl.Meter.calibrationResult.AdditionalLogInfos.TryGetValue("Amp. Test Mean value PATH 1", out tempP))
                        {
                            tempP = tempP.Replace(" at ", "").Replace("at ", "");
                            tempP = tempP.Replace(System.Environment.NewLine, ";");

                            meterctl.Meter.calibrationResult.AdditionalLogInfos["Amp. Test Mean value PATH 1"] = tempP;
                        }

                        if (meterctl.Meter.calibrationResult.AdditionalLogInfos.TryGetValue("Amp. Test Mean value PATH 2", out tempP))
                        {
                            tempP = tempP.Replace(" at ", "").Replace("at ", ""); ;
                            tempP = tempP.Replace(System.Environment.NewLine, ";");

                            meterctl.Meter.calibrationResult.AdditionalLogInfos["Amp. Test Mean value PATH 2"] = tempP;
                        }

                        if (meterctl.Meter.calibrationResult.AdditionalLogInfos.TryGetValue("Amp. Test Mean value PATH 3", out tempP))
                        {
                            tempP = tempP.Replace(" at ", "").Replace("at ", ""); ;
                            tempP = tempP.Replace(System.Environment.NewLine, ";");

                            meterctl.Meter.calibrationResult.AdditionalLogInfos["Amp. Test Mean value PATH 3"] = tempP.Trim();
                        }
                        meterctl.Meter.calibrationResult.Succesfull = !meterctl.Failed;
                        meterctl.Meter.WriteLog($"store CalibrationResults on server Succesfull: {meterctl.Meter.calibrationResult.Succesfull} ");
                        var r = LocalWebRequest.PostRequestAsync($"{ServiceUrls.PostGenesisCalibrationResultUrl()}?PcbId={meterctl.Meter.PcbId}", ref code, ref exPost, 8000, meterctl.Meter.calibrationResult);
                        if (!r)
                        {
                            meterctl.Meter.WriteLog($"Could not store CalibrationResults on server CODE {code}EX:{exPost} ");

                            foreach (var item in meterctl.Meter.calibrationResult.AdditionalLogInfos)
                            {
                                meterctl.Meter.WriteLog($"AdditionalLogInfos {item.Key} -> {item.Value}  ");
                            }

                            throw new Exception("Could not store CalibrationResults on server");
                        }
                        if (pp.IsAutomaticMode)
                        {
                            // meterctl.Meter.SetProcessState(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.ZeroFlow);

                        }

                    }
                    catch (Exception e)
                    {
                        pp.DebugMessage($"Error on {ProcessName} procedure", null, "APP");
                        pp.DebugMessage($"{e.Message}", null, "APP");
                    }

                    var meterIndex = (meterctl.Slot).ToString(pp.Setting.Culture);
                    meterctl.Failed = !Result;
                    if (!Result)
                    {
                        if (pp.IsAutomaticMode)
                        {
                            meterctl.Meter.SetProcessState(DisplayCodes.ZeroFlowFailed);
                        }
                        pp.DebugMessage($"{ProcessName} procedure failed", meterctl.Slot, "APP", meterctl.Meter.PcbId);
                        pp.GenerateReturnNote(PredefinedMessages.CompletionFailed(pp.Setting.Culture), meterctl);

                    }
                    else
                    {

                        pp.DebugMessage($"{ProcessName} procedure successful", meterctl.Slot, "APP", meterctl.Meter.PcbId);
                        if (!pp.IsAutomaticMode)
                        {
                            meterctl.Meter.SetProcessState(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.ZeroFlow);
                        }

                    }
                    meterctl.Meter.PushProgress("CordonelPreadjustmentUi", Assembly.GetExecutingAssembly().GetName().Version.ToString());

                    return Result;

                }));

            }


            return listOfProcessTask;

        }

    }



}