DP44/DataPRO/Modules/DatabaseImporter/DatabaseImport/ISO/TestObject.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;

namespace DatabaseImport.ISO
{
    public class TestObject : IComparable
    {
        private List<TestObjectChannel> _allChannels = new List<TestObjectChannel>();
        public TestObjectChannel[] AllChannels
        {
            get => _allChannels.ToArray();
            set
            {
                _allChannels = new List<TestObjectChannel>(value);
                SortChannels();
            }
        }

        public void SortChannels()
        {
            _allChannels.Sort();
        }

        public TestObjectChannel GetChannel(string channelid)
        {
            return Array.Find(AllChannels, ch => ch.GetId() == channelid || ch.Name == channelid);
        }
        public string SerialNumberConverted { get; set; }

        public string SerialNumber { get; set; }

        public string SerialNumberOrOriginalSerialNumber => Embedded ? OriginalSerialNumber : SerialNumber;

        public string TestObjectType { get; set; }

        public string ParentObject { get; set; }

        public bool SysBuilt { get; set; }
        private List<string> _hardwareIds = new List<string>();
        public string[] HardwareIds
        {
            get => _hardwareIds.ToArray();
            set { _hardwareIds.Clear(); _hardwareIds.AddRange(value); }
        }

        public string Template { get; set; }

        public void SetTemplateOnly(string value) { Template = value; }
        public void SetTemplate(string value, ref ISO13499FileDb db)
        {
            Template = value;
            var template = TestObjectTemplate.GetTemplate(ref db, Template);
            SetTemplate(template);
        }
        public void SetTemplate(TestObjectTemplate template)
        {
            _allChannels.Clear();
            if (null == template) return;
            Template = template.TemplateName;
            AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
        }

        public bool LocalOnly { get; set; }

        public string LastModifiedBy { get; set; }

        public DateTime LastModified { get; set; }
        private TestObject(DataRow dr, ref ISO13499FileDb db)
        {
            OriginalTemplate = "";
            OriginalSerialNumber = "";
            SerialNumberConverted = string.Empty;
            TestObjectData(dr, ref db);
        }
        public bool Embedded { get; set; }

        /// <summary>
        /// original serial number of this group (the serial number will be changed once it's embedded in a test setup)
        /// </summary>
        public string OriginalSerialNumber { get; set; }

        /// <summary>
        /// the original template for this group (the template is also changed once it's embedded in a test setup)
        /// </summary>        
        public string OriginalTemplate { get; set; }
        private void TestObjectData(DataRow dr, ref ISO13499FileDb db)
        {
            SerialNumber = (string)dr["TestObjectName"];
            LocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
            SetTemplate((string)dr["TemplateName"], ref db);
            LastModifiedBy = (string)dr["LastModifiedBy"];
            LastModified = Convert.ToDateTime(dr["LastModified"]);
            SysBuilt = Convert.ToBoolean(dr["SysBuilt"]);
            var o = dr["Embedded"];
            if (!DBNull.Value.Equals(o))
            {
                Embedded = Convert.ToBoolean(o);
            }
            o = dr["OrigSerialNumber"];
            if (!DBNull.Value.Equals(o))
            {
                OriginalSerialNumber = Convert.ToString(o);
            }
            o = dr["OrigTEmplate"];
            if (!DBNull.Value.Equals(o))
            {
                OriginalTemplate = Convert.ToString(o);
            }
            try
            {
                if (!DBNull.Value.Equals(dr["ParentObject"]))
                {
                    ParentObject = (string)dr["ParentObject"];
                }
            }
            catch (Exception) {/* APILogger.Log(ex);*/ }
            try
            {
                using (var cmd = DbOperations.GetSQLCommand(true))
                {
                    try
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectChannelSettingsGet.ToString();
                        cmd.Parameters.Add(
                            new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = SerialNumber });
                        cmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.NVarChar, 255) { Value = null });
                        cmd.Parameters.Add(new SqlParameter("@Setting", SqlDbType.NVarChar, 255) { Value = null });
                        cmd.Parameters.Add(
                            new SqlParameter("@SensorSerialNumber", SqlDbType.NVarChar, 255) { Value = null });
                        //cmd.ExecuteNonQuery();
                        using (var ds = DbOperations.Connection.QueryDataSet(cmd))
                        {
                            if (ds.Tables[0].Rows.Count <= 0) return;
                            foreach (DataRow row in ds.Tables[0].Rows)
                            {
                                try
                                {
                                    var channelId =
                                        (string)row[
                                            DbOperations.TestObjectChannelSettings.Fields.ChannelId.ToString()];
                                    var sensor =
                                        (string)row[
                                            DbOperations.TestObjectChannelSettings.Fields.SerialNumber.ToString()];
                                    var settings =
                                        (string)row[DbOperations.TestObjectChannelSettings.Fields.Setting.ToString()];

                                    if (string.IsNullOrEmpty(channelId) || string.IsNullOrEmpty(sensor) ||
                                        string.IsNullOrEmpty(settings)) continue;

                                    var sensorsettings = GetSettingsFromString(settings, sensor, channelId);
                                    foreach (var setting in sensorsettings)
                                    {
                                        SetSensorSetting(channelId, sensor, setting);
                                    }
                                }
                                catch (Exception)
                                {
                                    //APILogger.Log(ex);
                                }
                            }
                        }
                    }
                    finally
                    {
                        cmd.Connection.Dispose();
                    }
                }
            }
            catch (Exception) { /*APILogger.Log(ex); */}
        }
        public static SensorSetting[] GetSettingsFromString(string s, string sensor, string channelid)
        {
            var tokens = s.Split(',');

            return (from token in tokens select token.Split('=') into subtokens let setting = (SensorSettings)Convert.ToInt32(subtokens[0]) select new SensorSetting(setting, subtokens[1], channelid, sensor)).ToArray();
        }
        public TestObject()
        {
            OriginalTemplate = "";
            OriginalSerialNumber = "";
            SerialNumberConverted = string.Empty;
            _allChannels = new List<TestObjectChannel>();
            _hardwareIds = new List<string>();
            LastModified = DateTime.MinValue;
            LastModifiedBy = "N/A";
            LocalOnly = false;
            SerialNumber = "";
            Template = "";
            ParentObject = "";
        }
        public enum SensorSettings
        {
            Range,
            CFC,
            Polarity,
            Position,
            LimitDuration,
            Duration,
            Delay,
            OutputMode,
            SQMode,
            DIMode,
            DefaultValue,
            ActiveValue
        }
        public class SensorSetting
        {
            public string ChannelId { get; set; }
            public string SerialNumber { get; set; }
            public SensorSettings Setting { get; set; }
            public string Value { get; set; }
            public SensorSetting(SensorSettings setting, string value, string channelId, string serialNumber)
            {
                ChannelId = channelId;
                Value = value;
                Setting = setting;
                SerialNumber = serialNumber;
            }
            public SensorSetting(SensorSetting copy)
            {
                ChannelId = copy.ChannelId;
                Value = copy.Value;
                Setting = copy.Setting;
                SerialNumber = copy.SerialNumber;
            }
        }
        private Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>> _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>>();

        public SensorSetting[] GetSensorSettings(string channelId, string serialNumber)
        {
            if (!_sensorSettings.ContainsKey(channelId)) return new SensorSetting[0];
            return _sensorSettings[channelId].ContainsKey(serialNumber) ? _sensorSettings[channelId][serialNumber].Values.ToArray() : new SensorSetting[0];
        }
        public void SetSensorSetting(string channelId, string serialNumber, SensorSetting setting)
        {
            if (!_sensorSettings.ContainsKey(channelId)) { _sensorSettings[channelId] = new Dictionary<string, Dictionary<SensorSettings, SensorSetting>>(); }
            if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorSettings, SensorSetting>(); }
            _sensorSettings[channelId][serialNumber][setting.Setting] = setting;
        }
        public TestObject(TestObject copy, ref ISO13499FileDb db)
        {
            SerialNumberConverted = string.Empty;
            OriginalSerialNumber = copy.OriginalSerialNumber;
            OriginalTemplate = copy.OriginalTemplate;
            Embedded = copy.Embedded;

            _allChannels = new List<TestObjectChannel>();

            var t = TestObjectTemplate.GetTemplate(ref db, Template);

            copy.SortChannels();
            foreach (var c in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(c, this, t)); }

            for (var i = 0; i < copy.AllChannels.Length && i < _allChannels.Count; i++)
            {
                _allChannels[i].ChannelIdx = i;
            }

            _hardwareIds = new List<string>(copy.HardwareIds);
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            LocalOnly = copy.LocalOnly;
            SerialNumber = copy.SerialNumber;
            Template = copy.Template;
            ParentObject = copy.ParentObject;
            SysBuilt = copy.SysBuilt;
            using (var e = copy._sensorSettings.GetEnumerator())
            {
                _sensorSettings =
                    new Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>>();
                while (e.MoveNext())
                {
                    if (!_sensorSettings.ContainsKey(e.Current.Key))
                    {
                        _sensorSettings[e.Current.Key] =
                            new Dictionary<string, Dictionary<SensorSettings, SensorSetting>>();
                    }
                    using (var e2 = copy._sensorSettings[e.Current.Key].GetEnumerator())
                    {
                        while (e2.MoveNext())
                        {
                            if (!_sensorSettings[e.Current.Key].ContainsKey(e2.Current.Key))
                            {
                                _sensorSettings[e.Current.Key][e2.Current.Key] =
                                    new Dictionary<SensorSettings, SensorSetting>();
                            }
                            using (var e3 = copy._sensorSettings[e.Current.Key][e2.Current.Key].GetEnumerator())
                            {
                                while (e3.MoveNext())
                                {
                                    _sensorSettings[e.Current.Key][e2.Current.Key][e3.Current.Key] =
                                        new SensorSetting(e3.Current.Value);
                                }
                            }
                        }
                    }
                }
            }

        }
        private const char CHANNEL_SEPARATOR = 'x';
        private void GetHardwareAndSensors()
        {
            using (var cmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectHardwareIdsGet.ToString();

                    #region params

                    cmd.Parameters.Add(
                        new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = SerialNumber });

                    #endregion params

                    using (var reader = cmd.ExecuteReader())
                    {
                        var ids = new List<string>();
                        while (reader.Read())
                        {
                            var id = (string)reader["HardwareId"];
                            var tokens = id.Split('_');
                            if (tokens.Length == 3)
                            {
                                var sb = new StringBuilder();
                                sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
                                var index = tokens[2].IndexOf(CHANNEL_SEPARATOR);
                                if (index >= 0)
                                {
                                    sb.Append(tokens[2].Substring(index));
                                }
                                id = sb.ToString();
                            }
                            if (!ids.Contains(id))
                            {
                                ids.Add(id);
                            }
                        }
                        _hardwareIds = ids;
                    }
                }
                finally
                {
                    cmd.Connection.Dispose();
                }
            }
            var channelLookup = AllChannels.ToDictionary(ch => ch.GetId());
            var dasIdToSerialNumber = new Dictionary<int, string>();
            var dasIdToDasType = new Dictionary<int, int>();
            using (var cmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DASGet.ToString();

                    #region params

                    cmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar) { Value = null });
                    cmd.Parameters.Add(new SqlParameter("@position", SqlDbType.NVarChar) { Value = null });

                    #endregion params

                    using (var readerDAS = cmd.ExecuteReader())
                    {
                        while (readerDAS.Read())
                        {
                            var dasId = Convert.ToInt32(readerDAS["DASId"]);
                            var serialNumber = Convert.ToString(readerDAS["SerialNumber"]);
                            var iType = Convert.ToInt32(readerDAS["Type"]);
                            dasIdToDasType[dasId] = iType;
                            dasIdToSerialNumber[dasId] = serialNumber;
                        }
                        readerDAS.Close();
                    }
                }
                finally
                {
                    cmd.Connection.Dispose();
                }
            }
            using (var cmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectSensorsGet.ToString();

                    #region params

                    cmd.Parameters.Add(
                        new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = SerialNumber });

                    #endregion params

                    using (var ds = DbOperations.Connection.QueryDataSet(cmd))
                    {
                        if (null != ds && ds.Tables.Count > 0)
                        {
                            foreach (DataRow dr in ds.Tables[0].Rows)
                            {
                                var id = Convert.ToString(dr[0]);
                                if (!channelLookup.ContainsKey(id))
                                {
                                    continue;
                                }
                                var sensorId = "";
                                var channelIdx = -1;
                                if (!DBNull.Value.Equals(dr["ChannelIdx"]))
                                {
                                    channelIdx = Convert.ToInt32(dr["ChannelIdx"]);
                                }
                                if (!DBNull.Value.Equals(dr["SensorId"]))
                                {
                                    sensorId = Convert.ToString(dr["SensorId"]);
                                }
                                var hardwareId = "";
                                var dasId = Convert.ToInt32(dr["DasId"]);
                                var dasChannelId = Convert.ToInt32(dr["DasChannelId"]);
                                if (dasIdToSerialNumber.ContainsKey(dasId))
                                {
                                    hardwareId = $"{dasIdToSerialNumber[dasId]}_{dasIdToDasType[dasId]}x{dasChannelId}";
                                }
                                channelLookup[id].SensorSerialNumber = sensorId;
                                channelLookup[id].HardwareId = hardwareId;
                                channelLookup[id].ChannelIdx = channelIdx;
                            }
                        }
                    }
                }
                finally
                {
                    cmd.Connection.Dispose();
                }
            }
            SortChannels();
        }
        public static void DeleteAllTestObjects()
        {
            try
            {
                using (var cmd = DbOperations.GetSQLCommand(true))
                {
                    try
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectsDelete.ToString();

                        #region params  

                        cmd.Parameters.Add(new SqlParameter("@TestObjectId", SqlDbType.Int) { Value = 0 });
                        cmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 50) { Value = null });

                        #region Output

                        var errorNumberParam =
                            new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                        cmd.Parameters.Add(errorNumberParam);

                        var errorMessageParam =
                            new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
                            {
                                Direction = ParameterDirection.Output
                            };
                        cmd.Parameters.Add(errorMessageParam);

                        #endregion Output

                        #endregion params  

                        cmd.ExecuteNonQuery();

                        var error = int.Parse(errorNumberParam.Value.ToString());
                        if (error != 0)
                        {
                            var message = int.Parse(errorNumberParam.Value.ToString());
                            var state = int.Parse(errorNumberParam.Value.ToString());
                            //APILogger.Log(
                            //    $"Error:{Convert.ToString(error)}, State:{Convert.ToString(state)} Error: {message}");
                        }
                    }
                    finally
                    {
                        cmd.Connection.Dispose();
                    }
                }
            }
            catch (Exception) { /*APILogger.Log("failed to delete test objects", ex);*/ }
        }
        public static TestObject GetTestObject(string serialNumber, ref ISO13499FileDb db, bool sysBuiltValue)
        {
            TestObject testObject = null;
            try
            {
                using (var cmd = DbOperations.GetSQLCommand(true))
                {
                    try
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectsGet.ToString();
                        cmd.Parameters.Add(
                            new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = serialNumber });
                        cmd.Parameters.Add(new SqlParameter("@TemplateName", SqlDbType.NVarChar, 255) { Value = null });
                        cmd.Parameters.Add(new SqlParameter("@SysBuilt", SqlDbType.Bit) { Value = sysBuiltValue });

                        using (var ds = DbOperations.Connection.QueryDataSet(cmd))
                        {
                            if (null != ds && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                            {
                                testObject = new TestObject(ds.Tables[0].Rows[0], ref db);
                            }
                        }
                    }
                    finally { cmd.Connection.Dispose(); }
                }
            }
            catch (Exception) { /*APILogger.Log("failed to retrieve test objects", ex);*/ }
            testObject?.GetHardwareAndSensors();
            return testObject;
        }
        private static int CompareTestObject(TestObject left, TestObject right)
        {
            if (left == right) { return 0; }
            if (null == left) { return -1; }
            return null == right ? 1 : string.Compare(left.SerialNumber, right.SerialNumber, StringComparison.Ordinal);
        }

        public int CompareTo(object o)
        {
            if (o is TestObject testObject)
            {
                return CompareTestObject(this, testObject);
            }
            throw new ArgumentException($"object {o} is not the same type as this instance (TestObject)");
        }
    }
}