DP44/Common/DTS.Common.ISO/LabratoryDetails.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using DTS.Common.Storage;
using DTS.Common.Utilities.Logging;
using ISO.Strings;
using DTS.Common.Classes.LabratoryDetails;
using DTS.Common.Interface.TestMetaData;
// ReSharper disable CheckNamespace


namespace DTS.Common.ISO
{
    [Serializable()]
    public class LabratoryDetails : LabratoryDetailsDbRecord //: ISerializableFile
    {
        #region enums

        private enum Fields
        {
            Name,
            LaboratoryName,
            LaboratoryContactName,
            LaboratoryContactPhone,
            LaboratoryContactFax,
            LaboratoryContactEmail,
            LaboratoryTestRefNumber,
            LaboratoryProjectRefNumber,
            LastModified,
            LastModifiedBy,
            LocalOnly,
            Version
        };

        #endregion enums

        #region Properties

        public new string LabratoryContactPhone
        {
            get => base.LabratoryContactPhone;
            set
            {
                if (value != string.Empty)
                {
                    base.LabratoryContactPhone = value;
                }
            }
        }

        public new string LabratoryContactFax
        {
            get => base.LabratoryContactFax;
            set
            {
                if (value != string.Empty)
                {
                    base.LabratoryContactFax = value;
                }
            }
        }

        public new string LabratoryContactEmail
        {
            get => base.LabratoryContactEmail;
            set
            {
                if (value != string.Empty)
                {
                    base.LabratoryContactEmail = value;
                }
            }
        }

        #endregion Properties

        #region XML

        public void WriteXML(ref System.Xml.XmlWriter writer)
        {
            writer.WriteStartElement("LabDetail");

            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();

            foreach (var field in fields)
            {
                writer.WriteStartElement(field.ToString());
                switch (field)
                {
                    case Fields.LaboratoryContactEmail:
                        writer.WriteString(LabratoryContactEmail);
                        break;
                    case Fields.LaboratoryContactFax:
                        writer.WriteString(LabratoryContactFax);
                        break;
                    case Fields.LaboratoryContactName:
                        writer.WriteString(LabratoryContactName);
                        break;
                    case Fields.LaboratoryContactPhone:
                        writer.WriteString(LabratoryContactPhone);
                        break;
                    case Fields.LaboratoryName:
                        writer.WriteString(LabratoryName);
                        break;
                    case Fields.LaboratoryTestRefNumber:
                        writer.WriteString(LabratoryTestRefNumber);
                        break;
                    case Fields.LaboratoryProjectRefNumber:
                        writer.WriteString(LabratoryProjectRefNumber);
                        break;
                    case Fields.LastModified:
                        writer.WriteString(LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture));
                        break;
                    case Fields.LastModifiedBy:
                        writer.WriteString(LastModifiedBy);
                        break;
                    case Fields.LocalOnly:
                        writer.WriteString(LocalOnly.ToString());
                        break;
                    case Fields.Name:
                        writer.WriteString(Name);
                        break;
                    case Fields.Version:
                        writer.WriteString(Version.ToString(System.Globalization.CultureInfo.InvariantCulture));
                        break;
                    default:
                        throw new NotSupportedException("LabratoryDetails::WriteXML unsupported field: " +
                                                        field.ToString());
                }

                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }

        public static LabratoryDetails ReadXML(System.Xml.XmlElement root)
        {
            var l = new LabratoryDetails();
            foreach (var node in root.ChildNodes)
            {
                if (node is System.Xml.XmlElement)
                {
                    ProcessXMLElement(node as System.Xml.XmlElement, ref l);
                }
            }
            return l;
        }

        private static void ProcessXMLElement(System.Xml.XmlElement node, ref LabratoryDetails lab)
        {
            if (Enum.TryParse(node.Name, out Fields field))
            {
                switch (field)
                {
                    case Fields.Version:
                        lab.Version = int.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture);
                        break;
                    case Fields.Name:
                        lab.Name = node.InnerText;
                        break;
                    case Fields.LocalOnly:
                        lab.LocalOnly = Convert.ToBoolean(node.InnerText);
                        break;
                    case Fields.LastModifiedBy:
                        lab.LastModifiedBy = node.InnerText;
                        break;
                    case Fields.LastModified:
                        lab.LastModified = DateTime.Parse(node.InnerText,
                            System.Globalization.CultureInfo.InvariantCulture);
                        break;
                    case Fields.LaboratoryTestRefNumber:
                        lab.LabratoryTestRefNumber = node.InnerText;
                        break;
                    case Fields.LaboratoryProjectRefNumber:
                        lab.LabratoryProjectRefNumber = node.InnerText;
                        break;
                    case Fields.LaboratoryName:
                        lab.LabratoryName = node.InnerText;
                        break;
                    case Fields.LaboratoryContactPhone:
                        lab.LabratoryContactPhone = node.InnerText;
                        break;
                    case Fields.LaboratoryContactName:
                        lab.LabratoryContactName = node.InnerText;
                        break;
                    case Fields.LaboratoryContactFax:
                        lab.LabratoryContactFax = node.InnerText;
                        break;
                    case Fields.LaboratoryContactEmail:
                        lab.LabratoryContactEmail = node.InnerText;
                        break;
                    default:
                        throw new NotSupportedException("LabratoryDetails::ProcessXMLElement unsupported field: " +
                                                        field.ToString());
                }
            }
        }

        #endregion XML

        public static LabratoryDetails GetLabratoryDetails(string name)
        {
            try
            {
                var errorNumber = DbOperations.LabratoryDetailsGet(name, out ILabratoryDetailsDbRecord[] labratoryDetailsDbRecords);

                if (0 == errorNumber && null != labratoryDetailsDbRecords && labratoryDetailsDbRecords.Any())
                {
                    return new LabratoryDetails(labratoryDetailsDbRecords[0]);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to retrieve lab details", name, ex);
            }
            return null;
        }

        public static void DeleteLabratoryDetails()
        {
            try
            {
                var errorNumber = DbOperations.LabratoryDetailsDelete(null, out string errorMessage);

                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to delete labratory details", errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to delete laboratory details", ex);
            }
        }


        public LabratoryDetails()
        {
        }

        public LabratoryDetails(LabratoryDetails copy)
        {
            Name = copy.Name;
            LabratoryName = copy.LabratoryName;
            LabratoryContactName = copy.LabratoryContactName;
            LabratoryContactPhone = copy.LabratoryContactPhone;
            LabratoryContactFax = copy.LabratoryContactFax;
            LabratoryContactEmail = copy.LabratoryContactEmail;
            LabratoryTestRefNumber = copy.LabratoryTestRefNumber;
            LabratoryProjectRefNumber = copy.LabratoryProjectRefNumber;
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            LocalOnly = copy.LocalOnly;
            Version = copy.Version;
        }

        public LabratoryDetails(ILabratoryDetailsDbRecord labratoryDetailsDbRecord)
            : base(labratoryDetailsDbRecord)
        {
        }

        public static LabratoryDetails[] GetAllLabratoryDetails()
        {
            var labs = new List<LabratoryDetails>();
            try
            {
                var errorNumber = DbOperations.LabratoryDetailsGet(null, out ILabratoryDetailsDbRecord[] labratoryDetailsDbRecords);

                if (errorNumber == 0)
                {
                    foreach (var labratoryDetailDbRecord in labratoryDetailsDbRecords)
                    {
                        try
                        {
                            var cd = new LabratoryDetails(labratoryDetailDbRecord);
                            if (!cd.IsInvalidBlank())
                            {
                                labs.Add(cd);
                            }
                        }
                        catch (Exception ex)
                        {
                            APILogger.Log("failed to get labratory details", ex);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to retreive laboratory details", ex);
            }
            return labs.ToArray();
        }

        public void Delete(string user)
        {
            try
            {
                var errorNumber = DbOperations.LabratoryDetailsDelete(Name, out string errorMessage);

                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to delete labratory details", errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("failed to update laboratory", Name, ex);
            }
        }

        public void Commit(string user)
        {
            try
            {
                if (IsInvalidBlank())
                {
                    throw new NullReferenceException(StringResources.LabDetails_NullReferenceName);
                }
                var labratoryDetailsDbRecord = new LabratoryDetailsDbRecord(this);
                labratoryDetailsDbRecord.LastModified = DateTime.Now;
                labratoryDetailsDbRecord.LastModifiedBy = user;
                var errorNumber = DbOperations.LabratoryDetailsUpdateInsert(labratoryDetailsDbRecord, out string errorMessage);


                if (errorNumber == 0) return;
                APILogger.Log("failed to commit laboratory", Name, errorMessage);
            }
            catch (Exception ex)
            {
                APILogger.Log(StringResources.LabDetails_FailedToCommit, Name, ex);
                throw ex;
            }
        }
    }
}