tbf/TBF/Rig/Network/RestAPI/facade/ApiDataLoad.cs

using System;
using System.Collections.Generic;
using log4net;
using Newtonsoft.Json;
using Results.Entities;

namespace TBF.Rig.Network.RestAPI.facade
{
    public class ApiDataLoad
    {
        [JsonIgnore] private Results.BatchResults batchResults;
        [JsonIgnore] private static readonly ILog log = LogManager.GetLogger(typeof(RestAPIAdapter));

        public ApiDataLoad(Results.BatchResults batchResults)
        {
            this.batchResults = batchResults;
        }

        public String getJsonRequestBody()
        {
            try
            {
                List<WaterMeter> watermeterList = new List<WaterMeter>();
                if (batchResults.Batch != null && batchResults.Batch.WaterMeters != null)
                {
                    for (int i = 0; i < batchResults.Batch.WaterMeters.Count; i++)
                    {
                        if (batchResults.Batch.WaterMeters[i] != null && !batchResults.Batch.WaterMeters[i].Disabled)
                        {
                            watermeterList.Add(toFacaseWaterMeter(batchResults.Batch.WaterMeters[i]));
                        }
                    }
                }

                //do json from results
                string jsonRequestBody = JsonConvert.SerializeObject(watermeterList, Formatting.Indented);
                log.Debug("JSON to send in API: " + jsonRequestBody);
                return jsonRequestBody;
            }
            catch (Exception ex)
            {
                log.Error("getJsonRequestBody()", ex);
                Console.WriteLine(ex);
            }

            return "";
        }

        // Assuming toFacaseWaterMeter method exists
        private WaterMeter toFacaseWaterMeter(Results.Entities.WaterMeter meter)
        {
            try
            {
                WaterMeter waterMeter = new WaterMeter();
                // logic to convert WaterMeter data to facase class 
                waterMeter.WaterMeterID = meter.Id;
                waterMeter.Passed = meter.Passed;
                waterMeter.Remark = meter.Remark;
                waterMeter.ArchivePath = meter.ArchivePath;
                waterMeter.EndState = meter.EndState;
                waterMeter.OrderName = meter.PurchaseOrder;
                waterMeter.QFall = meter.QFall;
                waterMeter.QRise = meter.QRise;
                waterMeter.RadioAddress = meter.RadioAddress;
                waterMeter.ResultCode = meter.ResultCode;
                waterMeter.SerialNo = meter.SerialNr;
                waterMeter.WmPosition = meter.WMPosition;
                waterMeter.EndStateAux = meter.EndStateAux;
                waterMeter.SerialNrAux = meter.SerialNrAux;
                waterMeter.YearOfProduction = meter.YearOfProduction;

                //TODO BUMI implemet - Data from purchase
                waterMeter.OrderID = null;
                waterMeter.BoxId = "";

                //convert next objects
                waterMeter.WaterMeterData = toFacaseWaterMeterData(meter.WaterMeterData);
                waterMeter.Batch = toFacadeBatch(meter.Batch);

                waterMeter.TestResultsList = toFacasetoFacaseWaterMeterData(meter);


                return waterMeter; // Update this line as per implementation
            }
            catch (Exception e)
            {
                log.Error("toFacaseWaterMeter()", e);
                return null;
            }
        }

        private Batch toFacadeBatch(Results.Entities.Batch meterBatch)
        {
            try
            {
                Batch facadeBatch = null;
                if (meterBatch != null)
                {
                    facadeBatch = new Batch();

                    facadeBatch.Id = meterBatch.Id;
                    facadeBatch.BatchNr = meterBatch.BatchNr;
                    facadeBatch.TestBenchId = meterBatch.TestBenchId;
                    facadeBatch.ProgramVersion = meterBatch.ProgramVersion;
                    facadeBatch.UserName = meterBatch.UserName;
                    facadeBatch.UserNumber = meterBatch.UserNumber;
                    facadeBatch.ProcedureName = meterBatch.ProcedureName;
                    facadeBatch.ProcedureRevision = meterBatch.ProcedureRevision;
                    facadeBatch.Remark = meterBatch.Remark;
                    facadeBatch.Counter6 = meterBatch.Counter6;
                    facadeBatch.Counter7 = meterBatch.Counter7;
                    facadeBatch.Counter8 = meterBatch.Counter8;
                    facadeBatch.Counter9 = meterBatch.Counter9;
                    facadeBatch.Counter10 = meterBatch.Counter10;
                    facadeBatch.StartTime = meterBatch.StartTime;
                    facadeBatch.EndTime = meterBatch.EndTime;
                    facadeBatch.Dirty = meterBatch.Dirty;
                    facadeBatch.RsltsSent = meterBatch.RsltsSent;
                    facadeBatch.RsltsPrinted = meterBatch.RsltsPrinted;
                }

                return facadeBatch;
            }
            catch (Exception ex)
            {
                log.Error("toFacadeBatch()", ex);
                return null;
            }
        }

        private WaterMeterData toFacaseWaterMeterData(Results.Entities.WaterMeterData meterWaterMeterData)
        {
            try
            {
                WaterMeterData waterMeterData = null;

                if (meterWaterMeterData != null)
                {
                    waterMeterData = new WaterMeterData();

                    waterMeterData.Id = meterWaterMeterData.Id;
                    waterMeterData.ProductName = meterWaterMeterData.ProductName;
                    waterMeterData.Producer = meterWaterMeterData.Producer;
                    waterMeterData.Dn = meterWaterMeterData.DN;
                    waterMeterData.L = meterWaterMeterData.L;
                    waterMeterData.Mounting =
                        meterWaterMeterData.Mounting
                            .ToString(); // Assuming Mounting is an enum or has a valid ToString implementation
                    waterMeterData.Q4Qmax = meterWaterMeterData.Q4_Qmax;
                    waterMeterData.Q3Qn = meterWaterMeterData.Q3_Qn;
                    waterMeterData.Q2Qt = meterWaterMeterData.Q2_Qt;
                    waterMeterData.Q1Qmin = meterWaterMeterData.Q1_Qmin;
                    waterMeterData.MetrologicalClass = meterWaterMeterData.MetrologicalClass;
                    waterMeterData.Certificate = meterWaterMeterData.Certificate;
                    waterMeterData.Compound = meterWaterMeterData.Compound;
                    waterMeterData.Medium = meterWaterMeterData.Medium.ToString();
                    waterMeterData.ApprovalInfo = meterWaterMeterData.ApprovalInfo;
                    waterMeterData.MaxAdmissiblePressure =
                        meterWaterMeterData.MaxAdmissiblePressure
                            .ToString(); // Assuming Register is an enum or has a valid ToString implementation
                    waterMeterData.TemperatureClass = meterWaterMeterData.TemperatureClass.ToString();
                    waterMeterData.ApprovalInfoAux = meterWaterMeterData.ApprovalInfoAux;
                    waterMeterData.PulsesPerLtr = meterWaterMeterData.PulsesPerLtr;
                    waterMeterData.ProducerAux = meterWaterMeterData.ProducerAux;
                    waterMeterData.Q3QnAux = meterWaterMeterData.Q3_Qn_Aux;
                    waterMeterData.MetrologicalClassAux = meterWaterMeterData.MetrologicalClassAux;
                    waterMeterData.PressureLossClass = meterWaterMeterData.PressureLossClass.ToString();
                    waterMeterData.FlowProfileSensitivityClass =
                        meterWaterMeterData.FlowProfileSensitivityClass.ToString();
                }

                return waterMeterData;
            }
            catch (Exception ex)
            {
                log.Error("toFacaseWaterMeterData()", ex);
                return null;
            }
        }

        private List<TestResults> toFacasetoFacaseWaterMeterData(Results.Entities.WaterMeter meter)
        {
            List<TestResults> testResultsList = new List<TestResults>();

            IList<MeterTestRslt> regularMeterTestRslts = meter.RegularMeterTestRslts();
            foreach (MeterTestRslt meterTestRslt in regularMeterTestRslts)
            {
                if (meterTestRslt != null && meterTestRslt.TestDone)
                {
                    TestResults testResults = new TestResults(meterTestRslt);
                    testResultsList.Add(testResults);
                }
            }
            
            return testResultsList;
        }
    }
}