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

using CordonelPreadjustmentUi.Processes.Itinerary;
using Logic.ProductionToProductMapper.Cordonel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
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).ToList();

            var listOfProcessTask = new List<Task>();

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

                    try
                    {
                       
                        var Ok = false;
                        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");




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


                        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(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.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;

        }

    }



}