noisedestroyers/DP44
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
DP44/Common/DTS.Common.Storage/Migrations.cs
noisedestroyers bc3ac1d4c9 init
2026-04-17 14:55:32 -04:00

13568 lines
699 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using DTS.Common.Enums.Sensors;
using DTS.Common.Utilities.Logging;
using System.IO.Compression;
using System.IO;
using DTS.Common.Classes.Hardware;
using System.Configuration;
using DTS.Common.Enums.Hardware;
using DTS.Common.Enums;
using System.Windows.Forms;
using DbAPI.Errors;
namespace DTS.Common.Storage
{
public partial class DbOperations
{
/// <summary>
/// the process of migrating from version 0 to version 1
/// </summary>
private void MigrateVersion0()
{
//step 1, collect data on all sensor models
var manufacturerAndModelToInitialEU = new Dictionary<string, Dictionary<string, double>>();
var manufacturerAndModelToCalibrationRecord = new Dictionary<string, Dictionary<string, string>>();
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "SELECT InitialEU, Model, Manufacturer, CalibrationRecord from tblSensorModels";
using (var ds = QueryDataSet(cmd))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var manufacturer = Convert.ToString(dr["Manufacturer"]);
var model = Convert.ToString(dr["Model"]);
var initialEU = Convert.ToDouble(dr["InitialEU"]);
var cr = Convert.ToString(dr["CalibrationRecord"]);
if (!manufacturerAndModelToCalibrationRecord.ContainsKey(manufacturer))
{
manufacturerAndModelToCalibrationRecord.Add(manufacturer, new Dictionary<string, string>());
manufacturerAndModelToInitialEU.Add(manufacturer, new Dictionary<string, double>());
}
manufacturerAndModelToCalibrationRecord[manufacturer][model] = cr;
manufacturerAndModelToInitialEU[manufacturer][model] = initialEU;
}
}
}
//note, we'd really like to do this with a bulk operation, but it could be sticky maintaining db independence, I'm guessing we'd have
//to write a bulk operation wrapper
//step 2, modify data in sensor model table. In this case the structure is not changed, just the format of the data
//since initial offsets are stored in a field (calibration), this field just needs to be updated
using (var e1 = manufacturerAndModelToInitialEU.GetEnumerator())
{
while (e1.MoveNext())
{
using (var e2 = e1.Current.Value.GetEnumerator())
{
while (e2.MoveNext())
{
using (var cmd = GetSQLCommand())
{
var manufacturer = e1.Current.Key;
var model = e2.Current.Key;
var eu = manufacturerAndModelToInitialEU[manufacturer][model];
var cr = manufacturerAndModelToCalibrationRecord[manufacturer][model];
double mv = 0;
var modifiedcr = string.Format("{0}{1}{2}{3}{4}{5}{6}",
cr,
System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator,
"EU",
"__SC__",
eu.ToString(System.Globalization.CultureInfo.InvariantCulture),
"__SC__",
mv.ToString(System.Globalization.CultureInfo.InvariantCulture));
cmd.CommandText = "UPDATE tblSensorModels SET CalibrationRecord=@CalibrationRecord WHERE Manufacturer=@Manufacturer AND Model=@Model";
CreateParam(cmd, "@CalibrationRecord", SqlDbType.NVarChar, modifiedcr);
CreateParam(cmd, "@Manufacturer", SqlDbType.NVarChar, manufacturer);
CreateParam(cmd, "@Model", SqlDbType.NVarChar, model);
ExecuteCommand(cmd);
}
}
}
}
}
//step 3 collect the initial EU for all sensors
var serialNumberToInitialEU = new Dictionary<string, double>();
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "SELECT InitialEU, SerialNumber FROM tblSensors";
using (var ds = QueryDataSet(cmd))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var serialNumber = Convert.ToString(dr["SerialNumber"]);
var eu = Convert.ToDouble(dr["InitialEU"]);
serialNumberToInitialEU[serialNumber] = eu;
}
}
}
//step 4 collect all sensor cal history
var serialNumberAndCalibrationDateAndModifyDateToCalibrationRecord = new Dictionary<string, Dictionary<DateTime, DateTime>>();
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "SELECT SerialNumber, CalibrationDate, CalibrationRecords, ModifyDate FROM tblSensorCalibrations";
using (var ds = QueryDataSet(cmd))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var serialNumber = Convert.ToString(dr["SerialNumber"]);
var calibrationDate = Convert.ToDateTime(dr["CalibrationDate"]);
var modifyDate = Convert.ToDateTime(dr["ModifyDate"]);
var calibrationRecords = Convert.ToString(dr["CalibrationRecords"]);
if (!serialNumberAndCalibrationDateAndModifyDateToCalibrationRecord.ContainsKey(serialNumber)) { serialNumberAndCalibrationDateAndModifyDateToCalibrationRecord.Add(serialNumber, new Dictionary<DateTime, DateTime>()); }
serialNumberAndCalibrationDateAndModifyDateToCalibrationRecord[serialNumber][calibrationDate] = modifyDate;
}
}
}
//step 5, alter the calibration table
//the calibration table gets a new column, InitialOffset
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblSensorCalibrations ADD InitialOffset NVARCHAR(50)";
ExecuteCommand(cmd);
}
//step 6, add the new data
using (var e1 = serialNumberAndCalibrationDateAndModifyDateToCalibrationRecord.GetEnumerator())
{
while (e1.MoveNext())
{
using (var e2 = e1.Current.Value.GetEnumerator())
{
while (e2.MoveNext())
{
var serialNumber = e1.Current.Key;
var calDate = e2.Current.Key;
var mv = 0D;
var modifyDate = e2.Current.Value;
var initialOffset = string.Format("EU{0}{1}{2}{3}",
System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator,
serialNumberToInitialEU[serialNumber].ToString(System.Globalization.CultureInfo.InvariantCulture),
System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator,
mv.ToString(System.Globalization.CultureInfo.InvariantCulture));
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "UPDATE tblSensorCalibrations SET InitialOffset=@InitialOffset where SerialNumber=@SerialNumber AND CalibrationDate=@CalibrationDate AND ModifyDate=@ModifyDate";
CreateParam(cmd, "@InitialOffset", SqlDbType.NVarChar, initialOffset);
CreateParam(cmd, "@SerialNumber", SqlDbType.NVarChar, serialNumber);
CreateParam(cmd, "@CalibrationDate", SqlDbType.DateTime, calDate);
CreateParam(cmd, "@ModifyDate", SqlDbType.DateTime, modifyDate);
ExecuteCommand(cmd);
}
}
}
}
}
//finally insert the new version info into the table
InsertIntoVersionsTable(1, 0);
}
/// <summary>
/// updates the version info of the database in the database
/// </summary>
/// <param name="version"></param>
/// <param name="step"></param>
private void InsertIntoVersionsTable(int version, int step)
{
using (var cmd = GetCommand())
{
var sb = new StringBuilder();
var sb2 = new StringBuilder();
sb.AppendFormat("INSERT INTO {0} (", VersionTable.TableName);
var bNeedComma = false;
var fields = Enum.GetValues(typeof(VersionTable.Fields)).Cast<VersionTable.Fields>().ToArray();
sb2.Append("VALUES(");
foreach (var field in fields)
{
if (bNeedComma) { sb.Append(","); sb2.Append(","); }
else { bNeedComma = true; }
sb.Append(field.ToString());
var key = string.Format("@{0}", field.ToString());
sb2.AppendFormat(key);
switch (field)
{
case VersionTable.Fields.Date: CreateParam(cmd, key, SqlDbType.DateTime, DateTime.Now); break;
case VersionTable.Fields.Remarks: CreateParam(cmd, key, SqlDbType.NVarChar, ""); break;
case VersionTable.Fields.UserField: CreateParam(cmd, key, SqlDbType.NVarChar, "SYSTEM"); break;
case VersionTable.Fields.Version: CreateParam(cmd, key, SqlDbType.Int, version); break;
case VersionTable.Fields.Step: CreateParam(cmd, key, SqlDbType.Int, step); break;
default: throw new NotSupportedException("DbOperations::MigrateVersion0 unsupported field: " + field.ToString());
}
}
sb.Append(") ");
sb2.Append(")");
sb.Append(sb2.ToString());
cmd.CommandText = sb.ToString();
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
}
/// <summary>
/// part of the quick sensor check and user migrations
/// http://fogbugz/fogbugz/default.asp?9749
/// http://fogbugz/fogbugz/default.asp?9621
/// note that since we expect to use MS SQL in the future I've created the tables as ideal for MS SQL
/// but since there are differences between SQL and SQLite, I have to split the creation into functions each time
/// </summary>
private void MigrateVersion53()
{
if (_usingMSSQL)
{
try
{
CreateDataPROUsersTableMSSQL();
CreateLastUsedHardwareTablesMSSQL();
CreateUIItemsTablesMSSQL();
CreateTagAssignmentsTableMSSQL();
}
catch (Exception ex)
{
APILogger.Log("Failed to migrateversion53 (suspected migration interrupted on last startup)", ex);
}
}
else
{
try
{
CreateDataPROUsersTableSQLLite();
CreateLastUsedHardwareTablesSQLLite();
CreateUIItemsTableSQLLite();
CreateTagAssignmentsTableSQLLite();
}
catch (Exception ex)
{
APILogger.Log("Failed to migrateversion53 (suspected migration interrupted on last startup)", ex);
}
}
MigrateUsers();
InsertIntoVersionsTable(54, 0);
}
private void MigrateVersion51()
{
using (var sql = GetCommand())
{
try
{
if (_usingMSSQL)
{
sql.CommandText = "ALTER TABLE tblSensors ADD DoNotUse bit NOT NULL CONSTRAINT DF_tblSensors_DoNotUse DEFAULT 0, Broken bit NOT NULL CONSTRAINT DF_tblSensors_Broken DEFAULT 0";
ExecuteCommand(sql);
}
else
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
sb.Append("ALTER TABLE tblSensors ADD DoNotUse BIT default 0;");
sb.Append("ALTER TABLE tblSensors ADD Broken BIT default 0;");
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(52, 0);
}
/// <summary>
/// migrate version 50 (adds lab rack support)
/// </summary>
private void MigrateVersion50()
{
CreateTDASPro_LabRackPrototypeHardware();
using (var sql = GetCommand())
{
try
{
sql.CommandText = "SELECT SerialNumber from tblDAS where SerialNumber like 'LR%'";
using (var ds = Connection.QueryDataSet(sql))
{
var dasToMigrate = new List<string>();
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var o = dr["SerialNumber"];
if (!DBNull.Value.Equals(o))
{
var s = Convert.ToString(o);
if (!dasToMigrate.Contains(s))
{
dasToMigrate.Add(s);
}
}
}
}
if (dasToMigrate.Any())
{
sql.CommandText = "UPDATE tblDAS SET Type=31, MaxModules=6 WHERE Type=3 AND SerialNumber like 'LR%'";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
foreach (var s in dasToMigrate)
{
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = "UPDATE tblDASChannels SET HardwareID=@A WHERE HardwareId=@B";
CreateParam(cmd, "@A", SqlDbType.NVarChar, $"{s}_31");
CreateParam(cmd, "@B", SqlDbType.NVarChar, $"{s}_3");
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
}
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(51, 0);
}
private void MigrateVersion49()
{
if (_usingMSSQL)
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = "ALTER TABLE tblTemplateChannels ALTER COLUMN NameOfTheChannel nvarchar(100) NULL;";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
}
InsertIntoVersionsTable(50, 0);
}
private void MigrateVersion48()
{
using (var sql = GetCommand())
{
try
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
sb.Append("ALTER TABLE tblTestSetups ADD SuppressMissingSensorsWarning BIT;");
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(49, 0);
}
private void MigrateVersion47()
{
CreateSLICE2_SLTPrototypeHardware();
CreateSLICE2_SLDPrototypeHardware();
InsertIntoVersionsTable(48, 0);
}
/// <summary>
/// previous version didn't create identity property for calculated channels table, so the table is recreated (if using MSSQL, identity property doesn't exist in SQLite)
/// </summary>
private void MigrateVersion46()
{
if (_usingMSSQL)
{
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = "DROP TABLE tblCalculatedChannels";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
CreateCalculatedChannelsTable();
}
finally
{
cmd.Connection.Dispose();
}
}
}
InsertIntoVersionsTable(47, 0); //Put this inside BEGIN/COMMIT?
}
private void MigrateVersion45()
{
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetCommand())
{
try
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
if (_usingMSSQL)
{
sb.Append(@"CREATE TABLE [dbo].[tblLabratoryDetailsTemp](
[Name] [nvarchar](255) NOT NULL,
[LabratoryName] [nvarchar](255) NULL,
[LabratoryContactName] [nvarchar](255) NULL,
[LabratoryContactPhone] [nvarchar](255) NULL,
[LabratoryContactFax] [nvarchar](255) NULL,
[LabratoryContactEmail] [nvarchar](255) NULL,
[LabratoryTestRefNumber] [nvarchar](255) NULL,
[LabratoryProjectRefNumber] [nvarchar](255) NULL,
[LastModified] [datetime] NOT NULL,
[LastModifiedBy] [nvarchar](50) NULL,
[LocalOnly] [bit] NULL,
[Version] [int] NULL,
[DbTimeStamp] [timestamp] NULL,
PRIMARY KEY CLUSTERED
(
[Name] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]");
}
else
{
sb.Append("CREATE TABLE ");
sb.Append(LabratoryDetails.Table + "Temp");
sb.Append(" (\"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.Name);
sb.Append("\" NVCHAR(255) PRIMARY KEY, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryName);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryContactName);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryContactPhone);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryContactFax);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryContactEmail);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryTestRefNumber);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LabratoryProjectRefNumber);
sb.Append("\" NVCHAR(255) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LastModified);
sb.Append("\" DATETIME NOT NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LastModifiedBy);
sb.Append("\" NVCHAR(50) NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.LocalOnly);
sb.Append("\" BIT NULL, \"");
sb.Append(LabratoryDetails.LabratoryDetailsFields.Version);
sb.Append("\" INT NULL, ");
sb.Append("[DbTimeStamp] [TimeStamp] NULL");
sb.Append(");");
}
sb.Append("INSERT INTO tblLabratoryDetailsTemp " +
"(Name, LabratoryName, LabratoryContactName, LabratoryContactPhone, LabratoryContactFax, LabratoryContactEmail, LabratoryTestRefNumber, " +
"LastModified, LastModifiedBy, LocalOnly, Version) " +
"SELECT " +
"[Name], " +
"[LabratoryName], " +
"[LabratoryContactName], " +
"[LabratoryContactPhone], " +
"[LabratoryContactFax], " +
"[LabratoryContactEmail], " +
"[LabratoryTestRefNumber], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[LocalOnly], " +
"[Version] " +
"FROM tblLabratoryDetails;");
sb.Append("UPDATE tblLabratoryDetailsTemp SET LabratoryProjectRefNumber = 'NOVALUE';");
sb.Append("DROP TABLE tblLabratoryDetails;");
if (_usingMSSQL)
{
sb.Append(" EXEC sp_rename tblLabratoryDetailsTemp, tblLabratoryDetails;");
}
else
{
sb.Append("ALTER TABLE tblLabratoryDetailsTemp RENAME TO tblLabratoryDetails;");
}
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(46, 0); //Put this inside BEGIN/COMMIT?
}
private void MigrateVersion44()
{
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetCommand())
{
try
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
if (_usingMSSQL)
{
sb.Append(@"CREATE TABLE [tblMMEPossibleChannelsTemp](
[ID] [bigint] IDENTITY(1,1) NOT NULL,
[TYPE] [nvarchar](50) NULL,
[TEST_OBJECT] [nvarchar](50) NULL,
[POSITION] [nvarchar](50) NULL,
[TRANS_MAIN_LOC] [nvarchar](50) NULL,
[FINE_LOC_1] [nvarchar](50) NULL,
[FINE_LOC_2] [nvarchar](50) NULL,
[FINE_LOC_3] [nvarchar](50) NULL,
[PHYSICAL_DIMENSION] [nvarchar](50) NULL,
[DIRECTION] [nvarchar](50) NULL,
[DEFAULT_FILTER_CLASS] [nvarchar](50) NULL,
[TEXT_L1] [nvarchar](100) NULL,
[TEXT_L2] [nvarchar](100) NULL,
[VERSION] [int] NULL,
[DATE] [datetime] NULL,
[REMARKS] [nvarchar](50) NULL,
[EXPIRED] [bit] NULL,
[SORTKEY] [nvarchar](50) NULL,
[PICTURE_SHORTNAME] [nvarchar](50) NULL,
[LAST_CHANGE] [datetime] NULL,
[LAST_CHANGE_TEXT] [nvarchar](50) NULL,
[HISTORY] [nvarchar](50) NULL,
[DbTimeStamp] [timestamp] NULL
CONSTRAINT [PK_tblMMEPossibleChannelsTemp] PRIMARY KEY
(
[ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY];");
sb.Append("SET IDENTITY_INSERT tblMMEPossibleChannelsTemp ON;");
}
else
{
sb.Append("CREATE TABLE ");
sb.Append(MMEPossibleChannels.Table + "Temp");
sb.Append(" (\"");
sb.Append(MMETables.MMEPossibleChannelsFields.ID.ToString());
sb.Append("\" INTEGER PRIMARY KEY, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.TYPE.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.TEST_OBJECT.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.POSITION.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.TRANS_MAIN_LOC.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.FINE_LOC_1.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.FINE_LOC_2.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.FINE_LOC_3.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.PHYSICAL_DIMENSION.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.DIRECTION.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.DEFAULT_FILTER_CLASS.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.TEXT_L1.ToString());
sb.Append("\" NVCHAR(100) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.TEXT_L2.ToString());
sb.Append("\" NVCHAR(100) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.VERSION.ToString());
sb.Append("\" INT NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.DATE.ToString());
sb.Append("\" DATETIME NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.REMARKS.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.EXPIRED.ToString());
sb.Append("\" BIT NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.SORTKEY.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.PICTURE_SHORTNAME.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.LAST_CHANGE.ToString());
sb.Append("\" DATETIME NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.LAST_CHANGE_TEXT.ToString());
sb.Append("\" NVCHAR(50) NOT NULL, \"");
sb.Append(MMETables.MMEPossibleChannelsFields.HISTORY.ToString());
sb.Append("\" NVCHAR(50) NOT NULL,");
sb.Append("[DbTimeStamp] [TimeStamp] NULL");
sb.Append(");");
}
sb.Append("INSERT INTO tblMMEPossibleChannelsTemp " +
"(ID, TYPE, TEST_OBJECT, POSITION, TRANS_MAIN_LOC, FINE_LOC_1, FINE_LOC_2, FINE_LOC_3, PHYSICAL_DIMENSION, DIRECTION, DEFAULT_FILTER_CLASS, TEXT_L1, TEXT_L2, " +
"VERSION, DATE, REMARKS, EXPIRED, SORTKEY, PICTURE_SHORTNAME, LAST_CHANGE, LAST_CHANGE_TEXT, HISTORY) " +
"SELECT " +
"[ID], " +
"[TYPE], " +
"[TEST_OBJECT], " +
"[POSITION], " +
"[TRANS_MAIN_LOC], " +
"[FINE_LOC_1], " +
"[FINE_LOC_2], " +
"[FINE_LOC_3], " +
"[PHYSICAL_DIMENSION], " +
"[DIRECTION], " +
"[DEFAULT_FILTER_CLASS], " +
"[TEXT_L1], " +
"[TEXT_L2], " +
"[VERSION], " +
"[DATE], " +
"[REMARKS], " +
"[EXPIRED], " +
"[SORTKEY], " +
"[PICTURE_SHORTNAME], " +
"[LAST_CHANGE], " +
"[LAST_CHANGE_TEXT], " +
"[HISTORY] " +
"FROM tblMMEPossibleChannels;");
if (_usingMSSQL)
{
sb.Append("SET IDENTITY_INSERT tblMMEPossibleChannelsTemp OFF;");
}
sb.Append("DROP TABLE tblMMEPossibleChannels;");
sb.AppendFormat(_usingMSSQL
? " EXEC sp_rename tblMMEPossibleChannelsTemp, tblMMEPossibleChannels;"
: "ALTER TABLE tblMMEPossibleChannelsTemp RENAME TO tblMMEPossibleChannels;");
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(45, 0); //Put this inside BEGIN/COMMIT?
}
private void MigrateVersion43()
{
using (var sql = GetCommand())
{
try
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
sb.Append("ALTER TABLE tblTestSetups ADD NotAllChannelsRealTime BIT;");
sb.Append("ALTER TABLE tblTestSetups ADD NotAllChannelsViewer BIT;");
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(44, 0);
}
private void MigrateVersion42()
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = "ALTER TABLE tblTestSetups ADD QuitTestWithoutWarning BIT;";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(43, 0);
}
private void MigrateVersion41()
{
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = "ALTER TABLE tblTestSetups ADD ISFFile NVARCHAR (4000)";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
finally
{
cmd.Connection.Dispose();
}
}
InsertIntoVersionsTable(42, 0);
}
private void MigrateVersion40()
{
var tables = new[] { "tblTOMSquibChannels", "tblTOMDigitalChannels", "tblSensors", "tblDigitalInputSetting" };
foreach (var table in tables)
{
using (var cmd = GetCommand())
{
try
{
if (_usingMSSQL)
{
cmd.CommandText = $"ALTER TABLE {table} ADD UserTags VARBINARY(MAX);";
ExecuteCommand(cmd);
}
else
{
cmd.CommandText = $"ALTER TABLE {table} ADD UserTags BLOB";
ExecuteSQLiteCommand(cmd);
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
InsertIntoVersionsTable(41, 0);
}
private void MigrateVersion39()
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = "ALTER TABLE tblTestSetups ADD CheckoutMode BIT;";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(40, 0);
}
/// <summary>
/// Adds UserValue1, UserValue2, UserValue3 to squibs, digital in channels.
/// We had assumed these would simple objects based on how TDC handled them, but we now want to store jcodes and other information with them, so we need more fields
/// </summary>
private void MigrateVersion38()
{
using (var sql = GetCommand())
{
try
{
sql.CommandText =
"ALTER TABLE tblTOMSquibChannels ADD UserValue1 NVARCHAR(255); ALTER TABLE tblTOMSquibChannels ADD UserValue2 NVARCHAR(255); ALTER TABLE tblTOMSquibChannels ADD UserValue3 NVARCHAR(255);";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
using (var sql = GetCommand())
{
try
{
sql.CommandText =
"ALTER TABLE tblDigitalInputSetting ADD UserValue1 NVARCHAR(255); ALTER TABLE tblDigitalInputSetting ADD UserValue2 NVARCHAR(255); ALTER TABLE tblDigitalInputSetting ADD UserValue3 NVARCHAR(255);";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(39, 0);
}
private void MigrateVersion37()
{
CreateSG5_PrototypeHardware();
InsertIntoVersionsTable(38, 0);
}
private void MigrateVersion36()
{
CreateCalculatedChannelsTable();
InsertIntoVersionsTable(37, 0);
}
/// <summary>
/// version 34 adds the SLE and SLS
/// </summary>
private void MigrateVersion34()
{
CreateSLE_PrototypeHardware();
CreateSLICE2_SLSPrototypeHardware();
InsertIntoVersionsTable(35, 0);
}
private void MigrateVersion33()
{
if (_bJustCreatedTriggersTable) { }//were good, the last step created it properly
else
{
//we were in the magical inbetween version before we added the columns.
using (var sql = GetSQLCommand())
{
var sb = new StringBuilder();
sb.Append(BEGIN_STATEMENT);
sb.Append("ALTER TABLE tblLevelTriggers ADD InsideUpperEU FLOAT;");
sb.Append("ALTER TABLE tblLevelTriggers ADD InsideLowerEU FLOAT;");
sb.Append("ALTER TABLE tblLevelTriggers ADD OutsideUpperEU FLOAT;");
sb.Append("ALTER TABLE tblLevelTriggers ADD OutsideLowerEU FLOAT;");
sb.Append("ALTER TABLE tblLevelTriggers ADD TriggerInside BIT;");
sb.Append("ALTER TABLE tblLevelTriggers ADD TriggerOutside BIT;");
sb.Append(COMMIT_STATEMENT);
sql.CommandText = sb.ToString();
Connection.ExecuteCommand(sql);
}
}
InsertIntoVersionsTable(34, 0);
}
private bool _bJustCreatedTriggersTable = false;
private void MigrateVersion32()
{
_bJustCreatedTriggersTable = true;
CreateLevelTriggersTable();
InsertIntoVersionsTable(33, 0);
}
/// <summary>
/// Convert all SLICE Base+ Nano hardware that has Micro Serial number "BA0----" to Base+ Micro type
/// </summary>
private void MigrateVersion22()
{
var sliceBasePlusMicrosToMigrate = new List<string>();
using (var cmd = GetSQLCommand())
{
//=================
//tblDAS updates
//=================
// Collect Serial Numbers for all SLICE Base+ Micro and Change Type to 25
cmd.CommandText = "SELECT * FROM [tblDAS] where [Type] like 16 and [SerialNumber] like 'BA0%'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["SerialNumber"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
sliceBasePlusMicrosToMigrate.Add(o.ToString());
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
cmd.CommandText = "UPDATE [tblDAS] set [Type]=25 where [Type] like 16 and [SerialNumber] like 'BA0%'";
ExecuteCommand(cmd);
}
var oldToNewId = new Dictionary<string, string>();
using (var cmd = GetSQLCommand())
{
foreach (var sbpm in sliceBasePlusMicrosToMigrate)
{
//migrate tblTestObjectHardware
try
{
cmd.CommandText = string.Format("UPDATE [tblTestObjectHardware] set [HardwareId]='" + string.Format("{0}_25", sbpm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", sbpm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrate tblDASChannels
try
{
cmd.CommandText = string.Format("UPDATE [tblDASChannels] set [HardwareId]='" + string.Format("{0}_25", sbpm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", sbpm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrating tblTestObjectsSensors is more difficult as we have to consider channel numbers, etc
//we'll keep a list of unique ones we've found and update all the unique instances at once
cmd.CommandText = "SELECT [HardwareId] from [tblTestObjectSensors] where [HardwareId] like '" + string.Format("{0}_%", sbpm) + "'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["HardwareId"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
var sOriginal = Convert.ToString(o);
if (oldToNewId.ContainsKey(sOriginal)) { continue; }
//the channel number is split off using an x
var tokens = sOriginal.Split('x');
if (2 != tokens.Length) { continue; }
var chNum = Convert.ToInt32(tokens[1]);
tokens = tokens[0].Split('_');
//the id can come in two forms, one with an ip and one without
//the one without an ip is newer, but we might find either form
if (tokens.Length == 3)//BA50637_18_192.168.0.181x5
{
var sNew = string.Format("{0}_25x{1}", sbpm, chNum);
oldToNewId[sOriginal] = sNew;
}
else if (tokens.Length == 2)
{
var sNew = string.Format("{0}_25", sbpm);
oldToNewId[sOriginal] = sNew;
}
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
}
//now finally, update for all unique entries
using (var e = oldToNewId.GetEnumerator())
{
while (e.MoveNext())
{
cmd.CommandText = string.Format("Update [tblTestObjectSensors] set [HardwareId]='" +
e.Current.Value + "' where [HardwareId]='" + e.Current.Key +
"'");
Connection.ExecuteCommand(cmd);
}
}
}
InsertIntoVersionsTable(23, 0);
}
/// <inheritdoc />
/// <summary>
/// helper class, we may have to migrate a lot of test setup groups, so we want to avoid multiple data base hits for reads,
/// so we'll query the information all at once and package it into a convenient little structure
/// </summary>
protected class MigrateVersion25Helper : Tuple<string, string, string, string, DateTime, string>
{
public MigrateVersion25Helper(string testobjectSerialNumber,
string testSetupName,
string templateName,
string groupLastModifiedBy,
DateTime groupLastModified,
string newGroupSerialNumber)
: base(testobjectSerialNumber, testSetupName, templateName, groupLastModifiedBy, groupLastModified, newGroupSerialNumber)
{
}
public string TestSetupName => Item2;
public string TestObjectSerialNumberOriginal => Item1;
public string TemplateName => Item3;
public string GroupLastModifiedBy => Item4;
public DateTime GroupLastModifiedDateTime => Item5;
public string NewGroupSerialNumber => Item6;
}
/// <summary>
/// in this upgrade we need to create unique groups for every static group in a test setup
/// we don't need to do this for dynamic groups as they are already only in one specific test
/// at least, that's my assumption ...
/// we do this upgrade step by adding a GUID in the test setup test objects table, the guid will key to a
/// test object in the test setups table (and the corresponding template) that are just snapshots, right now just snap shots
/// of when the database was migrated but the idea will be that when you add a group to a test setup, we snapshot it on the add step
/// then you can delete or modify the group without affecting the test setup at all
/// the serial number in the template and objects table will be the GUID instead of the original serial number, however
/// we'll still have to hold on to the old serial number and template name just for reference, so we'll add columns for those too
///
/// note that we use string literals in in migration steps because we need to assume the column names are what they are at this point in
/// time in the migration process, so don't trust enumerations or constants, it's a one time upgrade process ...
/// </summary>
private void MigrateVersion25()
{
//step 1, add OriginalSerialNumber, OriginalTemplate and InTestSetup columns to tblTestObjects
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblTestObjects ADD OrigSerialNumber NVARCHAR(255)";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblTestObjects ADD OrigTemplate NVARCHAR(255)";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblTestObjects ADD Embedded BIT";
Connection.ExecuteCommand(cmd);
}
//step 2, add OriginalTemplateName, InTestSetup columns to tblTestObjectTemplates
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblTestObjectTemplates ADD OrigTemplateName NVARCHAR(255)";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblTestObjectTemplates ADD Embedded BIT";
Connection.ExecuteCommand(cmd);
}
//step 3, troll through all test setups, then troll through all static test objects
// for each static test object, snapshot the test objects and templates and update the tblTestSetupObjects,
// tblTestSetupObjectMetaData tables with the new names
var toMigrate = new List<MigrateVersion25Helper>();
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "SELECT A.TestObjectSerialNumber, A.TestSetupName, C.TemplateName, B.LastModifiedBy, B.LastModified FROM tblTestSetupObjects as A inner join tblTestObjects as B on A.TestObjectSerialNumber=B.SerialNumber INNER JOIN tblTestObjectTemplates as C on B.Template=C.TemplateName WHERE B.SysBuilt=0";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var o = dr["TestObjectSerialNumber"];
if (DBNull.Value.Equals(o)) { continue; }
var originalTestObjectSerialNumber = Convert.ToString(o);
o = dr["TestSetupName"];
if (DBNull.Value.Equals(o)) { continue; }
var testSetupName = Convert.ToString(o);
o = dr["TemplateName"];
if (DBNull.Value.Equals(o)) { continue; }
var originalTemplateName = Convert.ToString(o);
o = dr["LastModifiedBy"];
if (DBNull.Value.Equals(o)) { continue; }
var lastModifiedBy = Convert.ToString(o);
o = dr["LastModified"];
if (DBNull.Value.Equals(o)) { continue; }
var lastModified = Convert.ToDateTime(o);
var guid = Guid.NewGuid();
toMigrate.Add(new MigrateVersion25Helper(
originalTestObjectSerialNumber,
testSetupName,
originalTemplateName,
lastModifiedBy,
lastModified,
guid.ToString()));
}
}
}
}
if (toMigrate.Count > 0)
{
//step 3.1, update TestObjectSerialNumber in tblTestSetupObjects with a new, unique one
var idx = 0;
IDbCommand iCmd = null;
foreach (var item in toMigrate)
{
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("UPDATE tblTestSetupObjects SET TestObjectSerialNumber=@{0}_1 WHERE TestSetupName=@{0}_2 AND TestObjectSerialNumber=@{0}_3;", idx);
CreateParam(iCmd, string.Format("{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
CreateParam(iCmd, string.Format("{0}_2", idx), SqlDbType.NVarChar, item.TestSetupName);
CreateParam(iCmd, string.Format("{0}_3", idx), SqlDbType.NVarChar, item.TestObjectSerialNumberOriginal);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.2, update tblTestObjects
idx = 0;
foreach (var item in toMigrate)
{
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTestObjects (SerialNumber, LastModifiedBy, LastModified, Template, LocalOnly, ParentObject, SysBuilt, OrigSerialNumber, OrigTemplate, Embedded) VALUES (@{0}_1, @{0}_2, @{0}_3, @{0}_4, @{0}_5, @{0}_6, @{0}_7, @{0}_8, @{0}_9, @{0}_10);", idx);
//SerialNumber
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//LastModifiedBy
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, item.GroupLastModifiedBy);
//LastModified
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.DateTime, item.GroupLastModifiedDateTime);
//Template
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//LocalOnly
CreateParam(iCmd, string.Format("@{0}_5", idx), SqlDbType.Bit, false); //as of this version we don't use local only ...
//ParentObject
CreateParam(iCmd, string.Format("@{0}_6", idx), SqlDbType.NVarChar, ""); //as of this version we aren't using parent object anymore...
//SysBuilt
CreateParam(iCmd, string.Format("@{0}_7", idx), SqlDbType.Bit, false); //we are only migrating static groups, so sysbuilt must be false
//OrigSerialNumber
CreateParam(iCmd, string.Format("@{0}_8", idx), SqlDbType.NVarChar, item.TestObjectSerialNumberOriginal);
//OrigTemplate
CreateParam(iCmd, string.Format("@{0}_9", idx), SqlDbType.NVarChar, item.TemplateName);
//Embedded
CreateParam(iCmd, string.Format("@{0}_10", idx), SqlDbType.Bit, true); //this one is explicitly a group in a test setup...
idx++;
if (0 == idx % 150)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.3, update tblObjectSensors
//this one is a bit more complicated, we need to do a query for each object, find all the sensors and channel assignments
//we will create new entries however we'll have to parse "UIChannelID"
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT * FROM tblTestObjectSensors where TestObjectId=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TestObjectSerialNumberOriginal);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var uiChannelID = Convert.ToString(dr["UIChannelID"]);
var sensorId = Convert.ToString(dr["SensorId"]);
var hardwareId = Convert.ToString(dr["HardwareId"]);
var channelIdx = -1;
var o = dr["ChannelIdx"];
if (!DBNull.Value.Equals(o))
{
channelIdx = Convert.ToInt32(dr["ChannelIdx"]);
}
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTestObjectSensors (TestObjectId, UIChannelID, SensorId, LocalOnly, HardwareId, ChannelIdx) Values(@{0}_1, @{0}_2, @{0}_3, @{0}_5, @{0}_6, @{0}_7);", idx);
//TestObjectId
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//UIChannelID
var newChannelId = uiChannelID.Replace(item.TestObjectSerialNumberOriginal, item.NewGroupSerialNumber);
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, newChannelId);
//SensorId
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, sensorId);
//ZoneId
//we don't use this, so skip it
//LocalOnly
//we don't use localonly in this db version ...
CreateParam(iCmd, string.Format("@{0}_5", idx), SqlDbType.Bit, false);
//HardwareId
CreateParam(iCmd, string.Format("@{0}_6", idx), SqlDbType.NVarChar, hardwareId);
//ChannelIdx
CreateParam(iCmd, string.Format("@{0}_7", idx), SqlDbType.Int, channelIdx);
idx++;
if (0 == idx % 150)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.4, update tblTestObjectHardware
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT HardwareId FROM tblTestObjectHardware WHERE TestObject=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TestObjectSerialNumberOriginal);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
var hid = Convert.ToString(dr["HardwareId"]);
iCmd.CommandText += string.Format("INSERT INTO tblTestObjectHardware (TestObject, HardwareId, LocalOnly) VALUES (@{0}_1, @{0}_2, @{0}_3);", idx);
//TestObject
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//HardwareId
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, hid);
//LocalOnly
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.Bit, false);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.5, update tblTestObjectChannelSettings
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT ChannelId, Setting, SensorSerial from tblTestObjectChannelSettings where TestObjectSerial=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TestObjectSerialNumberOriginal);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var channelId = Convert.ToString(dr["ChannelId"]);
var setting = Convert.ToString(dr["Setting"]);
var sensorSerial = Convert.ToString(dr["SensorSerial"]);
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTestObjectChannelSettings (TestObjectSerial,ChannelId, Setting, SensorSerial) VALUES (@{0}_1, @{0}_2, @{0}_3, @{0}_4);", idx);
//TestObjectSerial
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//ChannelId
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, channelId);
//Setting
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, setting);
//SensorSerial
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.NVarChar, sensorSerial);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.6, update tblTestGraphs
//unfortunately this one is a bit tricky too, channel names have to be parsed out too
//first build a lookup table of test setup to lookup of original group serial number to new group serial number
var translationTable = new Dictionary<string, Dictionary<string, string>>();
foreach (var itemToMigrate in toMigrate)
{
if (!translationTable.ContainsKey(itemToMigrate.TestSetupName)) { translationTable.Add(itemToMigrate.TestSetupName, new Dictionary<string, string>()); }
translationTable[itemToMigrate.TestSetupName][itemToMigrate.TestObjectSerialNumberOriginal] = itemToMigrate.NewGroupSerialNumber;
}
idx = 0;
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT * FROM tblTestGraphs";
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var templateName = Convert.ToString(dr["TemplateName"]);
if (!translationTable.ContainsKey(templateName)) { continue; }
//okay now parse out the channels field, if it contains any objects which have been migrated we have to migrate the field
var channels = Convert.ToString(dr["Channels"]);
var originalChannels = channels;
//{(S23300 Group_1_6)§(jer_0_1525)}
var lookup = translationTable[templateName];
using (var e = lookup.GetEnumerator())
{
while (e.MoveNext())
{
channels = channels.Replace(string.Format("{0}_", e.Current.Key),
string.Format("{0}_", e.Current.Value));
}
}
if (originalChannels != channels)
{
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
//we need to migrate it!
iCmd.CommandText += string.Format("UPDATE tblTestGraphs Set Channels=@{0}_1 WHERE TemplateName=@{0}_2 AND CHANNELS=@{0}_3;", idx);
//new channels
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, channels);
//templatename
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, templateName);
//old channels
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, originalChannels);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 3.7, update tblTestChannelSettings
//well this one is pretty easy since the last step, we just need to replace test object names with guids
idx = 0;
using (var eTests = translationTable.GetEnumerator())
{
while (eTests.MoveNext())
{
using (var eObjects = eTests.Current.Value.GetEnumerator())
{
while (eObjects.MoveNext())
{
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText +=
string.Format(
"UPDATE tblTestChannelSettings SET TestObjectName=@{0}_1 WHERE TestName=@{0}_2 AND TestObjectName=@{0}_2;",
idx);
//New group Name
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar,
eObjects.Current.Value);
//test setup name
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, eTests.Current.Key);
//original group name
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar,
eObjects.Current.Key);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 4 templates
//step 4.a tblTestObjectTemplates
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT * from tblTestObjectTemplates WHERE TemplateName=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TemplateName);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var icon = Convert.ToString(dr["Icon"]);
var description = Convert.ToString(dr["Description"]);
var bLocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
var version = Convert.ToInt32(dr["Version"]);
var lastModifiedBy = Convert.ToString(dr["LastModifiedBy"]);
var CRC32 = Convert.ToInt32(dr["CRC32"]);
var testObject = Convert.ToString(dr["TestObject"]);
var testObjectType = Convert.ToString(dr["TestObjectType"]);
var lastModified = Convert.ToDateTime(dr["LastModified"]);
var parentTemplate = Convert.ToString(dr["ParentTemplate"]);
var sysbuilt = Convert.ToBoolean(dr["SysBuilt"]);
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTestObjectTemplates (TemplateName,Icon,Description,LocalOnly,Version,LastModifiedBy,CRC32,TestObject,TestObjectType,LastModified,ParentTemplate,SysBuilt,OrigTemplateName,Embedded) VALUES (@{0}_1,@{0}_2,@{0}_3,@{0}_4,@{0}_5,@{0}_6,@{0}_7,@{0}_8,@{0}_9,@{0}_10,@{0}_11,@{0}_12,@{0}_13,@{0}_14);", idx);
//TemplateName,
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//Icon,
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, icon);
//Description,
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, description);
//LocalOnly,
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.Bit, bLocalOnly);
//Version,
CreateParam(iCmd, string.Format("@{0}_5", idx), SqlDbType.Int, version);
//LastModifiedBy,
CreateParam(iCmd, string.Format("@{0}_6", idx), SqlDbType.NVarChar, lastModifiedBy);
//CRC32,
CreateParam(iCmd, string.Format("@{0}_7", idx), SqlDbType.Int, CRC32);
//TestObject,
CreateParam(iCmd, string.Format("@{0}_8", idx), SqlDbType.NVarChar, testObject);
//TestObjectType,
CreateParam(iCmd, string.Format("@{0}_9", idx), SqlDbType.NVarChar, testObjectType);
//LastModified,
CreateParam(iCmd, string.Format("@{0}_10", idx), SqlDbType.DateTime, lastModified);
//ParentTemplate,
CreateParam(iCmd, string.Format("@{0}_11", idx), SqlDbType.NVarChar, parentTemplate);
//SysBuilt,
CreateParam(iCmd, string.Format("@{0}_12", idx), SqlDbType.Bit, sysbuilt);
//OrigTemplateName,
CreateParam(iCmd, string.Format("@{0}_13", idx), SqlDbType.NVarChar, item.TemplateName);
//Embedded
CreateParam(iCmd, string.Format("@{0}_14", idx), SqlDbType.Bit, true);
idx++;
if (0 == idx % 100)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 4.b tblTemplateZones
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCmd = GetSQLCommand())
{
queryCmd.CommandText = "SELECT * FROM tblTemplateZones WHERE TemplateName=@1";
CreateParam(queryCmd, "@1", SqlDbType.NVarChar, item.TemplateName);
using (var ds = QueryDataSet(queryCmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var zoneName = Convert.ToString(dr["ZoneName"]);
var zoneDescription = Convert.ToString(dr["ZoneDescription"]);
var picture = Convert.ToString(dr["Picture"]);
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTemplateZones (TemplateName, ZoneName, ZoneDescription, Picture) VALUES (@{0}_1, @{0}_2, @{0}_3, @{0}_4);", idx);
//TemplateName,
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//ZoneName,
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, zoneName);
//ZoneDescription,
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, zoneDescription);
//Picture
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.NVarChar, picture);
idx++;
if (0 == idx % 500)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 4.c tbltblTemplateRegions
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT * from tblTemplateRegions WHERE TemplateName=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TemplateName);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var regionNumber = Convert.ToInt32(dr["RegionNumber"]);
var regionName = Convert.ToString(dr["RegionName"]);
var regionDescription = Convert.ToString(dr["RegionDescription"]);
var testObject = Convert.ToString(dr["TestObject"]);
var position = Convert.ToString(dr["Position"]);
var mainLocation = Convert.ToString(dr["MainLocation"]);
var fineLocation1 = Convert.ToString(dr["FineLocation1"]);
var fineLocation2 = Convert.ToString(dr["FineLocation2"]);
var fineLocation3 = Convert.ToString(dr["FineLocation3"]);
var physicalDimension = Convert.ToString(dr["PhysicalDimension"]);
var direction = Convert.ToString(dr["Direction"]);
var filterclass = Convert.ToString(dr["FilterClass"]);
var bLocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
var upperLeftX = Convert.ToString("UpperLeftX");
var upperLeftY = Convert.ToString("UpperLeftY");
var lowerRightX = Convert.ToString("LowerRightX");
var lowerRightY = Convert.ToString("LowerRightY");
var zoneName = Convert.ToString("ZoneName");
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT INTO tblTemplateRegions (TemplateName, RegionNumber, RegionName, RegionDescription, TestObject, Position, MainLocation, FineLocation1, FineLocation2, FineLocation3, PhysicalDimension, Direction, FilterClass, LocalOnly, UpperLeftX, UpperLeftY, LowerRightX, LowerRightY, ZoneName) VALUES (@{0}_1, @{0}_2, @{0}_3, @{0}_4, @{0}_5, @{0}_6, @{0}_7, @{0}_8, @{0}_9, @{0}_10, @{0}_11, @{0}_12, @{0}_13, @{0}_14, @{0}_15, @{0}_16, @{0}_17, @{0}_18, @{0}_19);", idx);
//TemplateName,
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//RegionNumber,
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.Int, regionNumber);
//RegionName,
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, regionName);
//RegionDescription,
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.NVarChar, regionDescription);
//TestObject,
CreateParam(iCmd, string.Format("@{0}_5", idx), SqlDbType.NVarChar, testObject);
//Position,
CreateParam(iCmd, string.Format("@{0}_6", idx), SqlDbType.NVarChar, position);
//MainLocation,
CreateParam(iCmd, string.Format("@{0}_7", idx), SqlDbType.NVarChar, mainLocation);
//FineLocation1,
CreateParam(iCmd, string.Format("@{0}_8", idx), SqlDbType.NVarChar, fineLocation1);
//FineLocation2,
CreateParam(iCmd, string.Format("@{0}_9", idx), SqlDbType.NVarChar, fineLocation2);
//FineLocation3,
CreateParam(iCmd, string.Format("@{0}_10", idx), SqlDbType.NVarChar, fineLocation3);
//PhysicalDimension,
CreateParam(iCmd, string.Format("@{0}_11", idx), SqlDbType.NVarChar, physicalDimension);
//Direction,
CreateParam(iCmd, string.Format("@{0}_12", idx), SqlDbType.NVarChar, direction);
//FilterClass,
CreateParam(iCmd, string.Format("@{0}_13", idx), SqlDbType.NVarChar, filterclass);
//LocalOnly,
CreateParam(iCmd, string.Format("@{0}_14", idx), SqlDbType.Bit, bLocalOnly);
//UpperLeftX,
CreateParam(iCmd, string.Format("@{0}_15", idx), SqlDbType.NVarChar, upperLeftX);
//UpperLeftY,
CreateParam(iCmd, string.Format("@{0}_16", idx), SqlDbType.NVarChar, upperLeftY);
//LowerRightX,
CreateParam(iCmd, string.Format("@{0}_17", idx), SqlDbType.NVarChar, lowerRightX);
//LowerRightY,
CreateParam(iCmd, string.Format("@{0}_18", idx), SqlDbType.NVarChar, lowerRightY);
//ZoneName
CreateParam(iCmd, string.Format("@{0}_19", idx), SqlDbType.NVarChar, zoneName);
idx++;
if (0 == idx % 80)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
//step 4.d tblTemplateChannels
idx = 0;
foreach (var item in toMigrate)
{
using (var queryCommand = GetSQLCommand())
{
queryCommand.CommandText = "SELECT * from tblTemplateChannels WHERE TemplateName=@1";
CreateParam(queryCommand, "@1", SqlDbType.NVarChar, item.TemplateName);
using (var ds = QueryDataSet(queryCommand))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var testObjectNumber = Convert.ToString(dr["TestObjectNumber"]);
var nameOfTheChannel = Convert.ToString(dr["NameOfTheChannel"]);
var laboratoryChannelCode = Convert.ToString(dr["LaboratoryChannelCode"]);
var customerChannelCode = Convert.ToString(dr["CustomerChannelCode"]);
var comments1 = Convert.ToString(dr["Comments1"]);
var location = Convert.ToString(dr["Location"]);
var dimension = Convert.ToString(dr["Dimension"]);
var direction = Convert.ToString(dr["Direction"]);
var channelFrequencyClass = Convert.ToString(dr["ChannelFrequencyClass"]);
var unit = Convert.ToString(dr["Unit"]);
var referenceSystem = Convert.ToString(dr["ReferenceSystem"]);
var transducerType = Convert.ToString(dr["TransducerType"]);
var transducerId = Convert.ToString(dr["TransducerId"]);
var prefilterType = Convert.ToString(dr["PreFilterType"]);
var cutoffFrequency = Convert.ToString(dr["CutOffFrequency"]);
var channelAmplitudeClass = Convert.ToString(dr["ChannelAmplitudeClass"]);
var referenceChannel = Convert.ToString(dr["ReferenceChannel"]);
var referenceChannelName = Convert.ToString(dr["ReferenceChannelName"]);
var dataSource = Convert.ToString(dr["DataSource"]);
var dataStatus = Convert.ToString(dr["DataStatus"]);
var samplingInterval = Convert.ToString(dr["SamplingInterval"]);
var bitResolution = Convert.ToString(dr["BitResolution"]);
var timeOfFirstSample = Convert.ToString(dr["TimeOfFirstSample"]);
var numberOfSamples = Convert.ToString(dr["NumberOfSamples"]);
var offsetPostTest = Convert.ToString(dr["OffsetPostTest"]);
var transducerNaturalFrequency = Convert.ToString(dr["TransducerNaturalFrequency"]);
var transducerDampingRatio = Convert.ToString(dr["TransducerDampingRatio"]);
var comments = Convert.ToString(dr["Comments"]);
var firstGlobalMaximumValue = Convert.ToString(dr["FirstGlobalMaximumValue"]);
var timeOfMaximumValue = Convert.ToString(dr["TimeOfMaximumValue"]);
var firstGlobalMinimumValue = Convert.ToString(dr["FirstGlobalMinimumValue"]);
var timeOfMinimumValue = Convert.ToString(dr["TimeOfMinimumValue"]);
var startOffsetInterval = Convert.ToString(dr["StartOffsetInterval"]);
var endOffsetInterval = Convert.ToString(dr["EndOffsetInterval"]);
var bRequired = Convert.ToBoolean(dr["Required"]);
var bLocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
var channelId = Convert.ToInt64(dr["MMEChannelId"]);
var channelType = Convert.ToInt32(dr["MMEChannelType"]);
var displayOrder = Convert.ToInt32(dr["DisplayOrder"]);
if (null == iCmd)
{
iCmd = GetSQLCommand();
iCmd.CommandText = BEGIN_STATEMENT;
}
iCmd.CommandText += string.Format("INSERT into tblTemplateChannels (TestObjectNumber, NameOfTheChannel, LaboratoryChannelCode, CustomerChannelCode, Comments1, Location, Dimension, Direction, ChannelFrequencyClass, Unit, ReferenceSystem, TransducerType, TransducerId, PreFilterType, CutOffFrequency, ChannelAmplitudeClass, ReferenceChannel, ReferenceChannelName, DataSource, DataStatus, SamplingInterval, BitResolution, TimeOfFirstSample, NumberOfSamples, OffsetPostTest, TransducerNaturalFrequency, TransducerDampingRatio, Comments, FirstGlobalMaximumValue, TimeOfMaximumValue, FirstGlobalMinimumValue, TimeOfMinimumValue, StartOffsetInterval, EndOffsetInterval, Required, LocalOnly, MMEChannelId, MMEChannelType, TemplateName, DisplayOrder) VALUES(@{0}_1,@{0}_2,@{0}_3,@{0}_4,@{0}_5,@{0}_6,@{0}_7,@{0}_8,@{0}_9,@{0}_10,@{0}_11,@{0}_12,@{0}_13,@{0}_14,@{0}_15,@{0}_16,@{0}_17,@{0}_18,@{0}_19,@{0}_20,@{0}_21,@{0}_22,@{0}_23,@{0}_24,@{0}_25,@{0}_26,@{0}_27,@{0}_28,@{0}_29,@{0}_30,@{0}_31,@{0}_32,@{0}_33,@{0}_34,@{0}_35,@{0}_36,@{0}_37,@{0}_38,@{0}_39,@{0}_40);", idx);
//TestObjectNumber,
CreateParam(iCmd, string.Format("@{0}_1", idx), SqlDbType.NVarChar, testObjectNumber);
//NameOfTheChannel,
CreateParam(iCmd, string.Format("@{0}_2", idx), SqlDbType.NVarChar, nameOfTheChannel);
//LaboratoryChannelCode,
CreateParam(iCmd, string.Format("@{0}_3", idx), SqlDbType.NVarChar, laboratoryChannelCode);
//CustomerChannelCode,
CreateParam(iCmd, string.Format("@{0}_4", idx), SqlDbType.NVarChar, customerChannelCode);
//Comments1,
CreateParam(iCmd, string.Format("@{0}_5", idx), SqlDbType.NVarChar, comments1);
//Location,
CreateParam(iCmd, string.Format("@{0}_6", idx), SqlDbType.NVarChar, location);
//Dimension,
CreateParam(iCmd, string.Format("@{0}_7", idx), SqlDbType.NVarChar, dimension);
//Direction,
CreateParam(iCmd, string.Format("@{0}_8", idx), SqlDbType.NVarChar, direction);
//ChannelFrequencyClass,
CreateParam(iCmd, string.Format("@{0}_9", idx), SqlDbType.NVarChar, channelFrequencyClass);
//Unit,
CreateParam(iCmd, string.Format("@{0}_10", idx), SqlDbType.NVarChar, unit);
//ReferenceSystem,
CreateParam(iCmd, string.Format("@{0}_11", idx), SqlDbType.NVarChar, referenceSystem);
//TransducerType,
CreateParam(iCmd, string.Format("@{0}_12", idx), SqlDbType.NVarChar, transducerType);
//TransducerId,
CreateParam(iCmd, string.Format("@{0}_13", idx), SqlDbType.NVarChar, transducerId);
//PreFilterType,
CreateParam(iCmd, string.Format("@{0}_14", idx), SqlDbType.NVarChar, prefilterType);
//CutOffFrequency,
CreateParam(iCmd, string.Format("@{0}_15", idx), SqlDbType.NVarChar, cutoffFrequency);
//ChannelAmplitudeClass,
CreateParam(iCmd, string.Format("@{0}_16", idx), SqlDbType.NVarChar, channelAmplitudeClass);
//ReferenceChannel,
CreateParam(iCmd, string.Format("@{0}_17", idx), SqlDbType.NVarChar, referenceChannel);
//ReferenceChannelName,
CreateParam(iCmd, string.Format("@{0}_18", idx), SqlDbType.NVarChar, referenceChannelName);
//DataSource,
CreateParam(iCmd, string.Format("@{0}_19", idx), SqlDbType.NVarChar, dataSource);
//DataStatus,
CreateParam(iCmd, string.Format("@{0}_20", idx), SqlDbType.NVarChar, dataStatus);
//SamplingInterval,
CreateParam(iCmd, string.Format("@{0}_21", idx), SqlDbType.NVarChar, samplingInterval);
//BitResolution,
CreateParam(iCmd, string.Format("@{0}_22", idx), SqlDbType.NVarChar, bitResolution);
//TimeOfFirstSample,
CreateParam(iCmd, string.Format("@{0}_23", idx), SqlDbType.NVarChar, timeOfFirstSample);
//NumberOfSamples,
CreateParam(iCmd, string.Format("@{0}_24", idx), SqlDbType.NVarChar, numberOfSamples);
//OffsetPostTest,
CreateParam(iCmd, string.Format("@{0}_25", idx), SqlDbType.NVarChar, offsetPostTest);
//TransducerNaturalFrequency,
CreateParam(iCmd, string.Format("@{0}_26", idx), SqlDbType.NVarChar, transducerNaturalFrequency);
//TransducerDampingRatio,
CreateParam(iCmd, string.Format("@{0}_27", idx), SqlDbType.NVarChar, transducerDampingRatio);
//Comments,
CreateParam(iCmd, string.Format("@{0}_28", idx), SqlDbType.NVarChar, comments);
//FirstGlobalMaximumValue,
CreateParam(iCmd, string.Format("@{0}_29", idx), SqlDbType.NVarChar, firstGlobalMaximumValue);
//TimeOfMaximumValue,
CreateParam(iCmd, string.Format("@{0}_30", idx), SqlDbType.NVarChar, timeOfMaximumValue);
//FirstGlobalMinimumValue,
CreateParam(iCmd, string.Format("@{0}_31", idx), SqlDbType.NVarChar, firstGlobalMinimumValue);
//TimeOfMinimumValue,
CreateParam(iCmd, string.Format("@{0}_32", idx), SqlDbType.NVarChar, timeOfMinimumValue);
//StartOffsetInterval,
CreateParam(iCmd, string.Format("@{0}_33", idx), SqlDbType.NVarChar, startOffsetInterval);
//EndOffsetInterval,
CreateParam(iCmd, string.Format("@{0}_34", idx), SqlDbType.NVarChar, endOffsetInterval);
//Required,
CreateParam(iCmd, string.Format("@{0}_35", idx), SqlDbType.Bit, bRequired);
//LocalOnly,
CreateParam(iCmd, string.Format("@{0}_36", idx), SqlDbType.Bit, bLocalOnly);
//MMEChannelId,
CreateParam(iCmd, string.Format("@{0}_37", idx), SqlDbType.BigInt, channelId);
//MMEChannelType,
CreateParam(iCmd, string.Format("@{0}_38", idx), SqlDbType.Int, channelType);
//TemplateName,
CreateParam(iCmd, string.Format("@{0}_39", idx), SqlDbType.NVarChar, item.NewGroupSerialNumber);
//DisplayOrder
CreateParam(iCmd, string.Format("@{0}_40", idx), SqlDbType.Int, displayOrder);
idx++;
if (0 == idx % 50)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
iCmd = null;
}
}
}
}
}
}
if (null != iCmd)
{
iCmd.CommandText += COMMIT_STATEMENT;
ExecuteCommand(iCmd);
iCmd.Dispose();
}
}
InsertIntoVersionsTable(26, 0);
}
public void MigrateVersion27()
{
using (var sql = GetSQLCommand())
{
sql.CommandText = "ALTER TABLE tblDAS ADD IsModule BIT";
Connection.ExecuteCommand(sql);
sql.CommandText = "UPDATE tblDAS set IsModule=0";
Connection.ExecuteCommand(sql);
}
InsertIntoVersionsTable(28, 0);
}
/// <summary>
/// all the tables that need to be updated in MigrateVersion28
/// </summary>
private enum Version28Tables
{
tblCustomerDetails, tblDAS, tblDASChannels, tblDigitalInputSetting,
tblLabratoryDetails, tblMMEDirections, tblMMEFilterClasses, tblMMEFineLocations1, tblMMEFineLocations2, tblMMEFineLocations3,
tblMMEMainLocations, tblMMEPhysicalDimensions, tblMMEPositions, tblMMEPossibleChannels, tblMMETestObjects, tblSensorCalibrations,
tblSensorModels, tblSensors, tblSettings, tblTOMDigitalChannels, tblTOMSquibChannels, tblTemplateChannels, tblTemplateRegions,
tblTemplateZones, tblTestChannelSettings, tblTestGraphs, tblTestObjectChannelSettings, tblTestObjectHardware, tblTestObjectSensors,
tblTestObjectTemplates, tblTestObjects, tblTestSetupDASSettings, tblTestSetupHardware, tblTestSetupObjectMetaData, tblTestSetupObjects,
tblTestSetups, tblUsers
};
/// <summary>
/// adds a timestamp to (almost) all tables
/// </summary>
public void MigrateVersion28()
{
var tables = Enum.GetValues(typeof(Version28Tables)).Cast<Version28Tables>().ToArray();
foreach (var table in tables)
{
using (var sql = GetSQLCommand())
{
try
{
sql.CommandText = $"ALTER TABLE [{table.ToString()}] ADD [DbTimeStamp] [TimeStamp] NULL";
Connection.ExecuteCommand(sql);
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
InsertIntoVersionsTable(29, 0);
}
public void MigrateVersion29()
{
//Modify the contents of tblTestSetupObjectMetaData (change any PropName fields from CustomerTestEngineer<x> to TestEngineer<x>)
using (var sql = GetSQLCommand())
{
sql.CommandText = "UPDATE [tblTestSetupObjectMetaData] SET PropName = 'TestEngineerName' WHERE PropName = 'CustomerTestEngineerName'";
Connection.ExecuteCommand(sql);
sql.CommandText = "UPDATE [tblTestSetupObjectMetaData] SET PropName = 'TestEngineerPhone' WHERE PropName = 'CustomerTestEngineerPhone'";
Connection.ExecuteCommand(sql);
sql.CommandText = "UPDATE [tblTestSetupObjectMetaData] SET PropName = 'TestEngineerFax' WHERE PropName = 'CustomerTestEngineerFax'";
Connection.ExecuteCommand(sql);
sql.CommandText = "UPDATE [tblTestSetupObjectMetaData] SET PropName = 'TestEngineerEmail' WHERE PropName = 'CustomerTestEngineerEmail'";
Connection.ExecuteCommand(sql);
}
//Create tblTestEngineerDetails
CreateTestEngineerDetailsTable();
//Fill tblTestEngineerDetails from tblCustomerDetails fields
using (var sql = GetSQLCommand())
{
sql.CommandText = " SELECT " +
"[CustomerTestEngineerName], " +
"[CustomerTestEngineerPhone], " +
"[CustomerTestEngineerFax], " +
"[CustomerTestEngineerEmail], " +
"[LocalOnly], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[Version] " +
"FROM tblCustomerDetails";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
var testEngineerList = new List<string>();
var i = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
//Eliminate duplicate Test Engineers from the Customers table and make sure there actually is a Test Engineer
var testEngineerName = Convert.ToString(dr[0]);
if ((!string.IsNullOrWhiteSpace(testEngineerName)) && (testEngineerName != ("NOVALUE")) && (!testEngineerList.Contains(testEngineerName)))
{
testEngineerList.Add(testEngineerName);
var testEngineerPhone = Convert.ToString(dr[1]);
var testEngineerFax = Convert.ToString(dr[2]);
var testEngineerEmail = Convert.ToString(dr[3]);
var localOnly = Convert.ToBoolean(dr[4]);
var lastModified = Convert.ToDateTime(dr[5]);
var lastModifiedBy = Convert.ToString(dr[6]);
var version = Convert.ToInt32(dr[7]);
var sql2 = GetSQLCommand();
sql2.CommandText = BEGIN_STATEMENT;
i++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblTestEngineerDetails] (");
sb2.Append(" VALUES (");
sb.Append("Name");
sb2.AppendFormat("@Name{0}", i);
CreateParam(sql2, string.Format("@Name{0}", i), SqlDbType.NVarChar, testEngineerName);
sb.Append(",TestEngineerName");
sb2.AppendFormat(",@TestEngineerName{0}", i);
CreateParam(sql2, string.Format("@TestEngineerName{0}", i), SqlDbType.NVarChar, testEngineerName);
sb.Append(",TestEngineerPhone");
sb2.AppendFormat(",@TestEngineerPhone{0}", i);
CreateParam(sql2, string.Format("@TestEngineerPhone{0}", i), SqlDbType.NVarChar, testEngineerPhone);
sb.Append(",TestEngineerFax");
sb2.AppendFormat(",@TestEngineerFax{0}", i);
CreateParam(sql2, string.Format("@TestEngineerFax{0}", i), SqlDbType.NVarChar, testEngineerFax);
sb.Append(",TestEngineerEmail");
sb2.AppendFormat(",@TestEngineerEmail{0}", i);
CreateParam(sql2, string.Format("@TestEngineerEmail{0}", i), SqlDbType.NVarChar, testEngineerEmail);
sb.Append(",LocalOnly");
sb2.AppendFormat(",@LocalOnly{0}", i);
CreateParam(sql2, string.Format("@LocalOnly{0}", i), SqlDbType.Bit, localOnly);
sb.Append(",LastModified");
sb2.AppendFormat(",@LastModified{0}", i);
CreateParam(sql2, string.Format("@LastModified{0}", i), SqlDbType.DateTime, lastModified);
sb.Append(",LastModifiedBy");
sb2.AppendFormat(",@LastModifiedBy{0}", i);
CreateParam(sql2, string.Format("@LastModifiedBy{0}", i), SqlDbType.NVarChar, lastModifiedBy);
sb.Append(",Version)");
sb2.AppendFormat(",@Version{0});", i);
CreateParam(sql2, string.Format("@Version{0}", i), SqlDbType.Int, version);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
sql2.Dispose();
}
}
}
}
}
//Modify tblTestSetups to now contain TestEngineers and UseTestEngineers
//Directly associate Test Engineers to TestSetups based on existing Customers associated with Test Setups
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestSetupsTemp](
[SetupName] [nvarchar](50) NOT NULL PRIMARY KEY,
[SetupDescription] [nvarchar](50) NOT NULL,
[AutomaticTestProgression] [bit] NOT NULL,
[AutomaticProgressionDelayMS] [int] NOT NULL,
[InvertTrigger] [bit] NOT NULL,
[InvertStart] [bit] NOT NULL,
[ViewDiagnostics] [bit] NOT NULL,
[VerifyChannels] [bit] NOT NULL,
[AutoVerifyChannels] [bit] NOT NULL,
[VerifyChannelsDelayMS] [int] NOT NULL,
[RecordingMode] [smallint] NOT NULL,
[SamplesPerSecond] [float] NOT NULL,
[PreTriggerSeconds] [float] NOT NULL,
[PostTriggerSeconds] [float] NOT NULL,
[StrictDiagnostics] [bit] NOT NULL,
[RequireConfirmationOnErrors] [bit] NOT NULL,
[ROIDownload] [bit] NOT NULL,
[ViewROIDownload] [bit] NOT NULL,
[DownloadAll] [bit] NOT NULL,
[ViewRealtime] [bit] NOT NULL,
[RealtimePlotCount] [smallint] NOT NULL,
[RegionsOfInterest] [string] NOT NULL,
[ROIEnd] [float] NOT NULL,
[ViewDownloadAll] [bit] NOT NULL,
[Export] [bit] NOT NULL,
[ExportFormat] [bigint] NOT NULL,
[LabDetails] [nvarchar](50),
[UseLabDetails] [bit] NOT NULL,
[CustomerDetails] [nvarchar](50),
[UseCustomerDetails] [bit] NOT NULL,
[AllowMissingSensors] [bit] NOT NULL,
[AllowSensorIdToBlankChannel] [bit] NOT NULL,
[LocalOnly] [bit] NOT NULL,
[LastModified] [datetime] NOT NULL,
[LastModifiedBy] [nvarchar](50) NOT NULL,
[TurnOffExcitation] [bit] NOT NULL,
[TriggerCheckRealtime] [bit] NOT NULL,
[TriggerCheckStep] [bit] NOT NULL,
[PostTestDiagnostics] [int] NOT NULL,
[ExportFolder] [nvarchar](150) NOT NULL,
[DownloadFolder] [nvarchar](150) NOT NULL,
[CommonStatusLine] [bit] NULL,
[SameAsDownloadFolder] [bit] NULL,
[UploadData] [bit] NULL,
[UploadDataFolder] [nvarchar](150) NOT NULL,
[Settings] [nvarchar](255) NULL,
[WarnOnBatteryFail] [bit] NULL,
[Dirty] [bit] NOT NULL,
[Complete] [bit] NOT NULL,
[ErrorMessage] [nvarchar](255),
[DbTimeStamp] [TimeStamp] NULL,
[TestEngineerDetails] [nvarchar](50),
[UseTestEngineerDetails] [bit] NOT NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = " SELECT " +
"[SetupName], " +
"[SetupDescription], " +
"[AutomaticTestProgression], " +
"[AutomaticProgressionDelayMS], " +
"[InvertTrigger], " +
"[InvertStart], " +
"[ViewDiagnostics], " +
"[VerifyChannels], " +
"[AutoVerifyChannels], " +
"[VerifyChannelsDelayMS], " +
"[RecordingMode], " +
"[SamplesPerSecond], " +
"[PreTriggerSeconds], " +
"[PostTriggerSeconds], " +
"[StrictDiagnostics], " +
"[RequireConfirmationOnErrors], " +
"[ROIDownload], " +
"[ViewROIDownload], " +
"[DownloadAll], " +
"[ViewRealtime], " +
"[RealtimePlotCount], " +
"[RegionsOfInterest], " +
"[ROIEnd], " +
"[ViewDownloadAll], " +
"[Export], " +
"[ExportFormat], " +
"[LabDetails], " +
"[UseLabDetails], " +
"[CustomerDetails], " +
"[UseCustomerDetails], " +
"[AllowMissingSensors], " +
"[AllowSensorIdToBlankChannel], " +
"[LocalOnly], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[TurnOffExcitation], " +
"[TriggerCheckRealtime], " +
"[TriggerCheckStep], " +
"[PostTestDiagnostics], " +
"[ExportFolder], " +
"[DownloadFolder], " +
"[CommonStatusLine], " +
"[SameAsDownloadFolder], " +
"[UploadData], " +
"[UploadDataFolder], " +
"[Settings], " +
"[WarnOnBatteryFail], " +
"[Dirty], " +
"[Complete], " +
"[ErrorMessage] " +
"FROM tblTestSetups";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
var i = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
var setupName = Convert.ToString(dr[0]);
var setupDescription = Convert.ToString(dr[1]);
var automaticTestProgression = Convert.ToBoolean(dr[2]);
var automaticProgressionDelayMS = Convert.ToInt32(dr[3]);
var invertTrigger = Convert.ToBoolean(dr[4]);
var invertStart = Convert.ToBoolean(dr[5]);
var viewDiagnostics = Convert.ToBoolean(dr[6]);
var verifyChannels = Convert.ToBoolean(dr[7]);
var autoVerifyChannels = Convert.ToBoolean(dr[8]);
var verifyChannelsDelayMS = Convert.ToInt32(dr[9]);
var recordingMode = Convert.ToInt16(dr[10]);
var samplesPerSecond = Convert.ToSingle(dr[11]);
var preTriggerSeconds = Convert.ToSingle(dr[12]);
var postTriggerSeconds = Convert.ToSingle(dr[13]);
var strictDiagnostics = Convert.ToBoolean(dr[14]);
var requireConfirmationOnErrors = Convert.ToBoolean(dr[15]);
var roiDownload = Convert.ToBoolean(dr[16]);
var viewROIDownload = Convert.ToBoolean(dr[17]);
var downloadAll = Convert.ToBoolean(dr[18]);
var viewRealtime = Convert.ToBoolean(dr[19]);
var realtimePlotCount = Convert.ToInt16(dr[20]);
var regionsOfInterest = Convert.ToString(dr[21]);
var roiEnd = Convert.ToSingle(dr[22]);
var viewDownloadAll = Convert.ToBoolean(dr[23]);
var export = Convert.ToBoolean(dr[24]);
var exportFormat = Convert.ToInt32(dr[25]);
var labDetails = Convert.ToString(dr[26]);
var useLabDetails = Convert.ToBoolean(dr[27]);
var customerDetails = Convert.ToString(dr[28]);
var useCustomerDetails = Convert.ToBoolean(dr[29]);
var allowMissingSensors = Convert.ToBoolean(dr[30]);
var allowSensorIdToBlankChannel = Convert.ToBoolean(dr[31]);
var localOnly = Convert.ToBoolean(dr[32]);
var lastModified = Convert.ToDateTime(dr[33]);
var lastModifiedBy = Convert.ToString(dr[34]);
var turnOffExcitation = Convert.ToBoolean(dr[35]);
var triggerCheckRealtime = Convert.ToBoolean(dr[36]);
var triggerCheckStep = Convert.ToBoolean(dr[37]);
var postTestDiagnostics = Convert.ToInt32(dr[38]);
var exportFolder = Convert.ToString(dr[39]);
var downloadFolder = Convert.ToString(dr[40]);
var commonStatusLine = Convert.ToBoolean(dr[41]);
var sameAsDownloadFolder = Convert.ToBoolean(dr[42]);
var uploadData = Convert.ToBoolean(dr[43]);
var uploadDataFolder = Convert.ToString(dr[44]);
var settings = Convert.ToString(dr[45]);
var warnOnBatteryFail = false; if (!DBNull.Value.Equals(dr[46])) { warnOnBatteryFail = Convert.ToBoolean(dr[46]); }
var dirty = false; if (!DBNull.Value.Equals(dr[47])) { dirty = Convert.ToBoolean(dr[47]); }
var complete = false; if (!DBNull.Value.Equals(dr[48])) { complete = Convert.ToBoolean(dr[48]); }
var errorMessage = string.Empty; if (!DBNull.Value.Equals(dr[49])) { errorMessage = Convert.ToString(dr[49]); }
var testEngineerDetails = string.Empty;
//If there's a Customer, get the Test Engineer Name
if (!string.IsNullOrWhiteSpace(customerDetails))
{
var sql3 = GetSQLCommand();
CreateParam(sql3, string.Format("@{0}", TestSetups.Fields.CustomerDetails.ToString()), SqlDbType.NVarChar, customerDetails);
sql3.CommandText = "SELECT [CustomerTestEngineerName] FROM [tblCustomerDetails] WHERE [Name] = @customerDetails";
Connection.ExecuteCommand(sql3);
using (var ds3 = Connection.QueryDataSet(sql3))
{
if (null != ds3 && null != ds3.Tables && ds3.Tables.Count > 0)
{
foreach (DataRow dr3 in ds3.Tables[0].Rows)
{
testEngineerDetails = Convert.ToString(dr3[0]);
}
}
}
}
var useTestEngineerDetails = !string.IsNullOrWhiteSpace(testEngineerDetails) && useCustomerDetails;
var sql2 = GetSQLCommand();
sql2.CommandText = BEGIN_STATEMENT;
i++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblTestSetupsTemp] (");
sb2.Append(" VALUES (");
sb.Append("SetupName");
sb2.AppendFormat("@SetupName{0}", i);
CreateParam(sql2, string.Format("@SetupName{0}", i), SqlDbType.NVarChar, setupName);
sb.Append(",SetupDescription");
sb2.AppendFormat(",@SetupDescription{0}", i);
CreateParam(sql2, string.Format("@SetupDescription{0}", i), SqlDbType.NVarChar, setupDescription);
sb.Append(",AutomaticTestProgression");
sb2.AppendFormat(",@AutomaticTestProgression{0}", i);
CreateParam(sql2, string.Format("@AutomaticTestProgression{0}", i), SqlDbType.Bit, automaticTestProgression);
sb.Append(",AutomaticProgressionDelayMS");
sb2.AppendFormat(",@AutomaticProgressionDelayMS{0}", i);
CreateParam(sql2, string.Format("@AutomaticProgressionDelayMS{0}", i), SqlDbType.Int, automaticProgressionDelayMS);
sb.Append(",InvertTrigger");
sb2.AppendFormat(",@InvertTrigger{0}", i);
CreateParam(sql2, string.Format("@InvertTrigger{0}", i), SqlDbType.Bit, invertTrigger);
sb.Append(",InvertStart");
sb2.AppendFormat(",@InvertStart{0}", i);
CreateParam(sql2, string.Format("@InvertStart{0}", i), SqlDbType.Bit, invertStart);
sb.Append(",ViewDiagnostics");
sb2.AppendFormat(",@ViewDiagnostics{0}", i);
CreateParam(sql2, string.Format("@ViewDiagnostics{0}", i), SqlDbType.Bit, viewDiagnostics);
sb.Append(",VerifyChannels");
sb2.AppendFormat(",@VerifyChannels{0}", i);
CreateParam(sql2, string.Format("@VerifyChannels{0}", i), SqlDbType.Bit, verifyChannels);
sb.Append(",AutoVerifyChannels");
sb2.AppendFormat(",@AutoVerifyChannels{0}", i);
CreateParam(sql2, string.Format("@AutoVerifyChannels{0}", i), SqlDbType.Bit, autoVerifyChannels);
sb.Append(",VerifyChannelsDelayMS");
sb2.AppendFormat(",@VerifyChannelsDelayMS{0}", i);
CreateParam(sql2, string.Format("@VerifyChannelsDelayMS{0}", i), SqlDbType.Int, verifyChannelsDelayMS);
sb.Append(",RecordingMode");
sb2.AppendFormat(",@RecordingMode{0}", i);
CreateParam(sql2, string.Format("@RecordingMode{0}", i), SqlDbType.SmallInt, recordingMode);
sb.Append(",SamplesPerSecond");
sb2.AppendFormat(",@SamplesPerSecond{0}", i);
CreateParam(sql2, string.Format("@SamplesPerSecond{0}", i), SqlDbType.Float, samplesPerSecond);
sb.Append(",PreTriggerSeconds");
sb2.AppendFormat(",@PreTriggerSeconds{0}", i);
CreateParam(sql2, string.Format("@PreTriggerSeconds{0}", i), SqlDbType.Float, preTriggerSeconds);
sb.Append(",PostTriggerSeconds");
sb2.AppendFormat(",@PostTriggerSeconds{0}", i);
CreateParam(sql2, string.Format("@PostTriggerSeconds{0}", i), SqlDbType.Float, postTriggerSeconds);
sb.Append(",StrictDiagnostics");
sb2.AppendFormat(",@StrictDiagnostics{0}", i);
CreateParam(sql2, string.Format("@StrictDiagnostics{0}", i), SqlDbType.Bit, strictDiagnostics);
sb.Append(",RequireConfirmationOnErrors");
sb2.AppendFormat(",@RequireConfirmationOnErrors{0}", i);
CreateParam(sql2, string.Format("@RequireConfirmationOnErrors{0}", i), SqlDbType.Bit, requireConfirmationOnErrors);
sb.Append(",ROIDownload");
sb2.AppendFormat(",@ROIDownload{0}", i);
CreateParam(sql2, string.Format("@ROIDownload{0}", i), SqlDbType.Bit, roiDownload);
sb.Append(",ViewROIDownload");
sb2.AppendFormat(",@ViewROIDownload{0}", i);
CreateParam(sql2, string.Format("@ViewROIDownload{0}", i), SqlDbType.Bit, viewROIDownload);
sb.Append(",DownloadAll");
sb2.AppendFormat(",@DownloadAll{0}", i);
CreateParam(sql2, string.Format("@DownloadAll{0}", i), SqlDbType.Bit, downloadAll);
sb.Append(",ViewRealtime");
sb2.AppendFormat(",@ViewRealtime{0}", i);
CreateParam(sql2, string.Format("@ViewRealtime{0}", i), SqlDbType.Bit, viewRealtime);
sb.Append(",RealtimePlotCount");
sb2.AppendFormat(",@RealtimePlotCount{0}", i);
CreateParam(sql2, string.Format("@RealtimePlotCount{0}", i), SqlDbType.SmallInt, realtimePlotCount);
sb.Append(",RegionsOfInterest");
sb2.AppendFormat(",@RegionsOfInterest{0}", i);
CreateParam(sql2, string.Format("@RegionsOfInterest{0}", i), SqlDbType.NVarChar, regionsOfInterest);
sb.Append(",ROIEnd");
sb2.AppendFormat(",@ROIEnd{0}", i);
CreateParam(sql2, string.Format("@ROIEnd{0}", i), SqlDbType.Float, roiEnd);
sb.Append(",ViewDownloadAll");
sb2.AppendFormat(",@ViewDownloadAll{0}", i);
CreateParam(sql2, string.Format("@ViewDownloadAll{0}", i), SqlDbType.Bit, viewDownloadAll);
sb.Append(",Export");
sb2.AppendFormat(",@Export{0}", i);
CreateParam(sql2, string.Format("@Export{0}", i), SqlDbType.Bit, export);
sb.Append(",ExportFormat");
sb2.AppendFormat(",@ExportFormat{0}", i);
CreateParam(sql2, string.Format("@ExportFormat{0}", i), SqlDbType.SmallInt, exportFormat);
sb.Append(",LabDetails");
sb2.AppendFormat(",@LabDetails{0}", i);
CreateParam(sql2, string.Format("@LabDetails{0}", i), SqlDbType.NVarChar, labDetails);
sb.Append(",UseLabDetails");
sb2.AppendFormat(",@UseLabDetails{0}", i);
CreateParam(sql2, string.Format("@UseLabDetails{0}", i), SqlDbType.Bit, useLabDetails);
sb.Append(",CustomerDetails");
sb2.AppendFormat(",@CustomerDetails{0}", i);
CreateParam(sql2, string.Format("@CustomerDetails{0}", i), SqlDbType.NVarChar, customerDetails);
sb.Append(",UseCustomerDetails");
sb2.AppendFormat(",@UseCustomerDetails{0}", i);
CreateParam(sql2, string.Format("@UseCustomerDetails{0}", i), SqlDbType.Bit, useCustomerDetails);
sb.Append(",AllowMissingSensors");
sb2.AppendFormat(",@AllowMissingSensors{0}", i);
CreateParam(sql2, string.Format("@AllowMissingSensors{0}", i), SqlDbType.Bit, allowMissingSensors);
sb.Append(",AllowSensorIdToBlankChannel");
sb2.AppendFormat(",@AllowSensorIdToBlankChannel{0}", i);
CreateParam(sql2, string.Format("@AllowSensorIdToBlankChannel{0}", i), SqlDbType.Bit, allowSensorIdToBlankChannel);
sb.Append(",LocalOnly");
sb2.AppendFormat(",@LocalOnly{0}", i);
CreateParam(sql2, string.Format("@LocalOnly{0}", i), SqlDbType.Bit, localOnly);
sb.Append(",LastModified");
sb2.AppendFormat(",@LastModified{0}", i);
CreateParam(sql2, string.Format("@LastModified{0}", i), SqlDbType.DateTime, lastModified);
sb.Append(",LastModifiedBy");
sb2.AppendFormat(",@LastModifiedBy{0}", i);
CreateParam(sql2, string.Format("@LastModifiedBy{0}", i), SqlDbType.NVarChar, lastModifiedBy);
sb.Append(",TurnOffExcitation");
sb2.AppendFormat(",@TurnOffExcitation{0}", i);
CreateParam(sql2, string.Format("@TurnOffExcitation{0}", i), SqlDbType.Bit, turnOffExcitation);
sb.Append(",TriggerCheckRealtime");
sb2.AppendFormat(",@TriggerCheckRealtime{0}", i);
CreateParam(sql2, string.Format("@TriggerCheckRealtime{0}", i), SqlDbType.Bit, triggerCheckRealtime);
sb.Append(",TriggerCheckStep");
sb2.AppendFormat(",@TriggerCheckStep{0}", i);
CreateParam(sql2, string.Format("@TriggerCheckStep{0}", i), SqlDbType.Bit, triggerCheckStep);
sb.Append(",PostTestDiagnostics");
sb2.AppendFormat(",@PostTestDiagnostics{0}", i);
CreateParam(sql2, string.Format("@PostTestDiagnostics{0}", i), SqlDbType.Int, postTestDiagnostics);
sb.Append(",ExportFolder");
sb2.AppendFormat(",@ExportFolder{0}", i);
CreateParam(sql2, string.Format("@ExportFolder{0}", i), SqlDbType.NVarChar, exportFolder);
sb.Append(",DownloadFolder");
sb2.AppendFormat(",@DownloadFolder{0}", i);
CreateParam(sql2, string.Format("@DownloadFolder{0}", i), SqlDbType.NVarChar, downloadFolder);
sb.Append(",CommonStatusLine");
sb2.AppendFormat(",@CommonStatusLine{0}", i);
CreateParam(sql2, string.Format("@CommonStatusLine{0}", i), SqlDbType.Bit, commonStatusLine);
sb.Append(",SameAsDownloadFolder");
sb2.AppendFormat(",@SameAsDownloadFolder{0}", i);
CreateParam(sql2, string.Format("@SameAsDownloadFolder{0}", i), SqlDbType.Bit, sameAsDownloadFolder);
sb.Append(",UploadData");
sb2.AppendFormat(",@UploadData{0}", i);
CreateParam(sql2, string.Format("@UploadData{0}", i), SqlDbType.Bit, uploadData);
sb.Append(",UploadDataFolder");
sb2.AppendFormat(",@UploadDataFolder{0}", i);
CreateParam(sql2, string.Format("@UploadDataFolder{0}", i), SqlDbType.NVarChar, uploadDataFolder);
sb.Append(",Settings");
sb2.AppendFormat(",@Settings{0}", i);
CreateParam(sql2, string.Format("@Settings{0}", i), SqlDbType.NVarChar, settings);
sb.Append(",WarnOnBatteryFail");
sb2.AppendFormat(",@WarnOnBatteryFail{0}", i);
CreateParam(sql2, string.Format("@WarnOnBatteryFail{0}", i), SqlDbType.Bit, warnOnBatteryFail);
sb.Append(",Dirty");
sb2.AppendFormat(",@Dirty{0}", i);
CreateParam(sql2, string.Format("@Dirty{0}", i), SqlDbType.Bit, dirty);
sb.Append(",Complete");
sb2.AppendFormat(",@Complete{0}", i);
CreateParam(sql2, string.Format("@Complete{0}", i), SqlDbType.Bit, complete);
sb.Append(",ErrorMessage");
sb2.AppendFormat(",@ErrorMessage{0}", i);
CreateParam(sql2, string.Format("@ErrorMessage{0}", i), SqlDbType.NVarChar, errorMessage);
sb.Append(",TestEngineerDetails");
sb2.AppendFormat(",@TestEngineerDetails{0}", i);
CreateParam(sql2, string.Format("@TestEngineerDetails{0}", i), SqlDbType.NVarChar, testEngineerDetails);
sb.Append(",UseTestEngineerDetails)");
sb2.AppendFormat(",@UseTestEngineerDetails{0});", i);
CreateParam(sql2, string.Format("@UseTestEngineerDetails{0}", i), SqlDbType.Bit, useTestEngineerDetails);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
sql2.Dispose();
}
}
}
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblTestSetupsTemp, tblTestSetups";
}
else
{
sql.CommandText = "ALTER TABLE tblTestSetupsTemp RENAME TO tblTestSetups";
}
Connection.ExecuteCommand(sql);
}
//Remove unused fields from tblCustomerDetails
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblCustomerDetailsTemp](
[Name] [nvarchar](255) NOT NULL PRIMARY KEY,
[CustomerName] [nvarchar](255) NULL,
[CustomerTestRefNumber] [nvarchar] (255) NULL,
[ProjectRefNumber] [nvarchar] (255) NULL,
[CustomerOrderNumber] [nvarchar] (255) NULL,
[CustomerCostUnit] [nvarchar] (255) NULL,
[LocalOnly] [bit] NULL,
[LastModified] [datetime] NULL,
[LastModifiedBy] [nvarchar] (50) NULL,
[Version] [int] NULL,
[DBTimeStamp] [TimeStamp] NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = " SELECT " +
"[Name], " +
"[CustomerName], " +
"[CustomerTestRefNumber], " +
"[ProjectRefNumber], " +
"[CustomerOrderNumber], " +
"[CustomerCostUnit], " +
"[LocalOnly], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[Version] " +
"FROM tblCustomerDetails";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
var i = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
var name = Convert.ToString(dr[0]);
var customerName = Convert.ToString(dr[1]);
var customerTestRefNumber = Convert.ToString(dr[2]);
var projectRefNumber = Convert.ToString(dr[3]);
var customerOrderNumber = Convert.ToString(dr[4]);
var customerCostUnit = Convert.ToString(dr[5]);
var localOnly = Convert.ToBoolean(dr[6]);
var lastModified = Convert.ToDateTime(dr[7]);
var lastModifiedBy = Convert.ToString(dr[8]);
var version = Convert.ToInt32(dr[9]);
var sql2 = GetSQLCommand();
sql2.CommandText = BEGIN_STATEMENT;
i++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblCustomerDetailsTemp] (");
sb2.Append(" VALUES (");
sb.Append("Name");
sb2.AppendFormat("@Name{0}", i);
CreateParam(sql2, string.Format("@Name{0}", i), SqlDbType.NVarChar, name);
sb.Append(",CustomerName");
sb2.AppendFormat(",@CustomerName{0}", i);
CreateParam(sql2, string.Format("@CustomerName{0}", i), SqlDbType.NVarChar, customerName);
sb.Append(",CustomerTestRefNumber");
sb2.AppendFormat(",@CustomerTestRefNumber{0}", i);
CreateParam(sql2, string.Format("@CustomerTestRefNumber{0}", i), SqlDbType.NVarChar, customerTestRefNumber);
sb.Append(",ProjectRefNumber");
sb2.AppendFormat(",@ProjectRefNumber{0}", i);
CreateParam(sql2, string.Format("@ProjectRefNumber{0}", i), SqlDbType.NVarChar, projectRefNumber);
sb.Append(",CustomerOrderNumber");
sb2.AppendFormat(",@CustomerOrderNumber{0}", i);
CreateParam(sql2, string.Format("@CustomerOrderNumber{0}", i), SqlDbType.NVarChar, customerOrderNumber);
sb.Append(",CustomerCostUnit");
sb2.AppendFormat(",@CustomerCostUnit{0}", i);
CreateParam(sql2, string.Format("@CustomerCostUnit{0}", i), SqlDbType.NVarChar, customerCostUnit);
sb.Append(",LocalOnly");
sb2.AppendFormat(",@LocalOnly{0}", i);
CreateParam(sql2, string.Format("@LocalOnly{0}", i), SqlDbType.Bit, localOnly);
sb.Append(",LastModified");
sb2.AppendFormat(",@LastModified{0}", i);
CreateParam(sql2, string.Format("@LastModified{0}", i), SqlDbType.DateTime, lastModified);
sb.Append(",LastModifiedBy");
sb2.AppendFormat(",@LastModifiedBy{0}", i);
CreateParam(sql2, string.Format("@LastModifiedBy{0}", i), SqlDbType.NVarChar, lastModifiedBy);
sb.Append(",Version)");
sb2.AppendFormat(", @Version{0});", i);
CreateParam(sql2, string.Format("@Version{0}", i), SqlDbType.Int, version);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
sql2.Dispose();
}
}
}
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblCustomerDetailsTemp, tblCustomerDetails";
}
else
{
sql.CommandText = "ALTER TABLE tblCustomerDetailsTemp RENAME TO tblCustomerDetails";
}
Connection.ExecuteCommand(sql);
}
InsertIntoVersionsTable(30, 0);
}
public void MigrateVersion30()
{
//Modify tblTestEngineerDetails to now contain Name
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestEngineerDetailsTemp](
[Name] [nvarchar](255) NOT NULL PRIMARY KEY,
[TestEngineerName] [nvarchar](255) NULL,
[TestEngineerPhone] [nvarchar](255) NULL,
[TestEngineerFax] [nvarchar](255) NULL,
[TestEngineerEmail] [nvarchar](255) NULL,
[LocalOnly] [bit] NULL,
[LastModified] [datetime] NULL,
[LastModifiedBy] [nvarchar](50) NULL,
[Version] [int] NULL,
[DbTimeStamp] [TimeStamp] NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = " SELECT " +
"[TestEngineerName], " +
"[TestEngineerPhone], " +
"[TestEngineerFax], " +
"[TestEngineerEmail], " +
"[LocalOnly], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[Version] " +
"FROM tblTestEngineerDetails";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
var i = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
var testEngineerName = Convert.ToString(dr[0]);
var testEngineerPhone = Convert.ToString(dr[1]);
var testEngineerFax = Convert.ToString(dr[2]);
var testEngineerEmail = Convert.ToString(dr[3]);
var localOnly = Convert.ToBoolean(dr[4]);
var lastModified = Convert.ToDateTime(dr[5]);
var lastModifiedBy = Convert.ToString(dr[6]);
var version = Convert.ToInt32(dr[7]);
var sql2 = GetSQLCommand();
sql2.CommandText = BEGIN_STATEMENT;
i++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblTestEngineerDetailsTemp] (");
sb2.Append(" VALUES (");
sb.Append("Name");
sb2.AppendFormat("@Name{0}", i);
CreateParam(sql2, string.Format("@Name{0}", i), SqlDbType.NVarChar, testEngineerName);
sb.Append(",TestEngineerName");
sb2.AppendFormat(",@TestEngineerName{0}", i);
CreateParam(sql2, string.Format("@TestEngineerName{0}", i), SqlDbType.NVarChar, testEngineerName);
sb.Append(",TestEngineerPhone");
sb2.AppendFormat(",@TestEngineerPhone{0}", i);
CreateParam(sql2, string.Format("@TestEngineerPhone{0}", i), SqlDbType.NVarChar, testEngineerPhone);
sb.Append(",TestEngineerFax");
sb2.AppendFormat(",@TestEngineerFax{0}", i);
CreateParam(sql2, string.Format("@TestEngineerFax{0}", i), SqlDbType.NVarChar, testEngineerFax);
sb.Append(",TestEngineerEmail");
sb2.AppendFormat(",@TestEngineerEmail{0}", i);
CreateParam(sql2, string.Format("@TestEngineerEmail{0}", i), SqlDbType.NVarChar, testEngineerEmail);
sb.Append(",LocalOnly");
sb2.AppendFormat(",@LocalOnly{0}", i);
CreateParam(sql2, string.Format("@LocalOnly{0}", i), SqlDbType.Bit, localOnly);
sb.Append(",LastModified");
sb2.AppendFormat(",@LastModified{0}", i);
CreateParam(sql2, string.Format("@LastModified{0}", i), SqlDbType.DateTime, lastModified);
sb.Append(",LastModifiedBy");
sb2.AppendFormat(",@LastModifiedBy{0}", i);
CreateParam(sql2, string.Format("@LastModifiedBy{0}", i), SqlDbType.NVarChar, lastModifiedBy);
sb.Append(",Version)");
sb2.AppendFormat(",@Version{0});", i);
CreateParam(sql2, string.Format("@Version{0}", i), SqlDbType.Int, version);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
sql2.Dispose();
}
}
}
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblTestEngineerDetailsTemp, tblTestEngineerDetails";
}
else
{
sql.CommandText = "ALTER TABLE tblTestEngineerDetailsTemp RENAME TO tblTestEngineerDetails";
}
Connection.ExecuteCommand(sql);
}
//Add a TEName PropName to each Test Setup in tblTestSetupObjectMetaData
using (var sql = GetSQLCommand())
{
sql.CommandText = " SELECT " +
"[SetupName] " +
"FROM tblTestSetups";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var testSetupName = Convert.ToString(dr[0]);
using (var sql3 = GetSQLCommand())
{
CreateParam(sql3, "@SetupName", SqlDbType.NVarChar, testSetupName);
CreateParam(sql3, "@TestEngineerName", SqlDbType.NVarChar, "TestEngineerName");
sql3.CommandText = " SELECT " +
"[TestObject], " +
"[PropValue], " +
"[Optional], " +
"[Version] " +
"FROM tblTestSetupObjectMetaData " +
"WHERE (([SetupName] = @SetupName) AND ([PropName] = @TestEngineerName))";
Connection.ExecuteCommand(sql3);
using (var ds3 = Connection.QueryDataSet(sql3))
{
if (null != ds3 && null != ds3.Tables && ds3.Tables.Count > 0)
{
var i3 = 0;
foreach (DataRow dr3 in ds3.Tables[0].Rows)
{
char testObject;
if (_usingMSSQL)
{
testObject = Convert.ToChar(dr3[0]); //In SQL Server, this is returned as a Char
}
else
{
try
{
testObject = (char)Convert.ToInt32(dr3[0]); //In SQLite, this is returned as the ASCII integer representation
}
catch (SystemException)
{
testObject = Convert.ToChar(dr3[0]); //Maybe this is a SQLite db that was converted from SQL Server, so this is returned as a Char
}
}
var propValue = Convert.ToString(dr3[1]);
var optional = Convert.ToBoolean(dr3[2]);
var version = Convert.ToDouble(dr3[3]);
using (var sql2 = GetSQLCommand())
{
sql2.CommandText = BEGIN_STATEMENT;
i3++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblTestSetupObjectMetaData] (");
sb2.Append(" VALUES (");
sb.Append("SetupName");
sb2.AppendFormat("@SetupName{0}", i3);
CreateParam(sql2, string.Format("@SetupName{0}", i3), SqlDbType.NVarChar, testSetupName);
sb.Append(",TestObject");
sb2.AppendFormat(",@TestObject{0}", i3);
CreateParam(sql2, string.Format("@TestObject{0}", i3), SqlDbType.Char, testObject);
sb.Append(",PropName");
sb2.AppendFormat(",@PropName{0}", i3);
CreateParam(sql2, string.Format("@PropName{0}", i3), SqlDbType.NVarChar, "TEName");
sb.Append(",PropValue");
sb2.AppendFormat(",@PropValue{0}", i3);
CreateParam(sql2, string.Format("@PropValue{0}", i3), SqlDbType.NVarChar, propValue);
sb.Append(",Optional");
sb2.AppendFormat(",@Optional{0}", i3);
CreateParam(sql2, string.Format("@Optional{0}", i3), SqlDbType.Bit, optional);
sb.Append(",Version)");
sb2.AppendFormat(",@Version{0});", i3);
CreateParam(sql2, string.Format("@Version{0}", i3), SqlDbType.Float, version);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
}
}
}
}
}
}
}
}
}
InsertIntoVersionsTable(31, 0);
}
public void MigrateVersion31()
{
try
{
CreateTagsTable();
//step 1, add Tags columns to tblTestSetups and tblUsers
using (var cmd = GetSQLCommand())
{
if (_usingMSSQL)
{
cmd.CommandText = "ALTER TABLE tblTestSetups ADD UserTags VARBINARY(MAX)";
}
else { cmd.CommandText = "ALTER TABLE tblTestSetups ADD UserTags BLOB"; }
Connection.ExecuteCommand(cmd);
if (_usingMSSQL)
{
cmd.CommandText = "ALTER TABLE tblUsers ADD UserTags VARBINARY(MAX)";
}
else { cmd.CommandText = "ALTER TABLE tblUsers ADD UserTags BLOB"; }
Connection.ExecuteCommand(cmd);
}
}
catch (Exception)
{
//ignore
}
InsertIntoVersionsTable(32, 0);
}
public void MigrateVersion35()
{
//step 1, add OriginalSerialNumber, OriginalTemplate and InTestSetup columns to tblTestObjects
try
{
using (var cmd = GetCommand())
{
cmd.CommandText = "ALTER TABLE tblTestSetups ADD DoAutoArm BIT";
if (_usingMSSQL)
{
Connection.ExecuteCommand(cmd);
}
else
{
Connection.ExecuteSQLiteCommand(cmd);
}
}
}
catch (Exception)
{
//ignore
}
InsertIntoVersionsTable(36, 0);
}
/// <summary>
/// In this upgrade we are increasing the width of the ExportFormat field in order to accomadate more export types. Currently the bitwise
/// feild is limited to 16 bits. I'm increasing this to 64bits
/// </summary>
public void MigrateVersion26()
{
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestSetupsTemp](
[SetupName] [nvarchar](50) NOT NULL PRIMARY KEY,
[SetupDescription] [nvarchar](50) NOT NULL,
[AutomaticTestProgression] [bit] NOT NULL,
[AutomaticProgressionDelayMS] [int] NOT NULL,
[InvertTrigger] [bit] NOT NULL,
[InvertStart] [bit] NOT NULL,
[ViewDiagnostics] [bit] NOT NULL,
[VerifyChannels] [bit] NOT NULL,
[AutoVerifyChannels] [bit] NOT NULL,
[VerifyChannelsDelayMS] [int] NOT NULL,
[RecordingMode] [smallint] NOT NULL,
[SamplesPerSecond] [float] NOT NULL,
[PreTriggerSeconds] [float] NOT NULL,
[PostTriggerSeconds] [float] NOT NULL,
[StrictDiagnostics] [bit] NOT NULL,
[RequireConfirmationOnErrors] [bit] NOT NULL,
[ROIDownload] [bit] NOT NULL,
[ViewROIDownload] [bit] NOT NULL,
[DownloadAll] [bit] NOT NULL,
[ViewRealtime] [bit] NOT NULL,
[RealtimePlotCount] [smallint] NOT NULL,
[ROIStart] [float] NOT NULL,
[ROIEnd] [float] NOT NULL,
[ViewDownloadAll] [bit] NOT NULL,
[Export] [bit] NOT NULL,
[ExportFormat] [bigint] NOT NULL,
[LabDetails] [nvarchar](50),
[UseLabDetails] [bit] NOT NULL,
[CustomerDetails] [nvarchar](50),
[UseCustomerDetails] [bit] NOT NULL,
[AllowMissingSensors] [bit] NOT NULL,
[AllowSensorIdToBlankChannel] [bit] NOT NULL,
[LocalOnly] [bit] NOT NULL,
[LastModified] [datetime] NOT NULL,
[LastModifiedBy] [nvarchar](50) NOT NULL,
[TurnOffExcitation] [bit] NOT NULL,
[TriggerCheckRealtime] [bit] NOT NULL,
[TriggerCheckStep] [bit] NOT NULL,
[PostTestDiagnostics] [int] NOT NULL,
[ExportFolder] [nvarchar](150) NOT NULL,
[DownloadFolder] [nvarchar](150) NOT NULL,
[CommonStatusLine] [bit] NULL,
[SameAsDownloadFolder] [bit] NULL,
[UploadData] [bit] NULL,
[UploadDataFolder] [nvarchar](150) NOT NULL,
[Settings] [nvarchar](255) NULL,
[WarnOnBatteryFail] [bit] NULL,
[Dirty] [bit] NOT NULL,
[Complete] [bit] NOT NULL,
[ErrorMessage] [nvarchar](255))";
Connection.ExecuteCommand(sql);
sql.CommandText = " SELECT " +
"[SetupName], " +
"[SetupDescription], " +
"[AutomaticTestProgression], " +
"[AutomaticProgressionDelayMS], " +
"[InvertTrigger], " +
"[InvertStart], " +
"[ViewDiagnostics], " +
"[VerifyChannels], " +
"[AutoVerifyChannels], " +
"[VerifyChannelsDelayMS], " +
"[RecordingMode], " +
"[SamplesPerSecond], " +
"[PreTriggerSeconds], " +
"[PostTriggerSeconds], " +
"[StrictDiagnostics], " +
"[RequireConfirmationOnErrors], " +
"[ROIDownload], " +
"[ViewROIDownload], " +
"[DownloadAll], " +
"[ViewRealtime], " +
"[RealtimePlotCount], " +
"[RegionsOfInterest], " +
"[ROIEnd], " +
"[ViewDownloadAll], " +
"[Export], " +
"[ExportFormat], " +
"[LabDetails], " +
"[UseLabDetails], " +
"[CustomerDetails], " +
"[UseCustomerDetails], " +
"[AllowMissingSensors], " +
"[AllowSensorIdToBlankChannel], " +
"[LocalOnly], " +
"[LastModified], " +
"[LastModifiedBy], " +
"[TurnOffExcitation], " +
"[TriggerCheckRealtime], " +
"[TriggerCheckStep], " +
"[PostTestDiagnostics], " +
"[ExportFolder], " +
"[DownloadFolder], " +
"[CommonStatusLine], " +
"[SameAsDownloadFolder], " +
"[UploadData], " +
"[UploadDataFolder], " +
"[Settings], " +
"[WarnOnBatteryFail], " +
"[Dirty], " +
"[Complete], " +
"[ErrorMessage] " +
"FROM tblTestSetups";
Connection.ExecuteCommand(sql);
using (var ds = Connection.QueryDataSet(sql))
{
if (null != ds && null != ds.Tables && ds.Tables.Count > 0)
{
var i = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
var setupName = Convert.ToString(dr[0]);
var setupDescription = Convert.ToString(dr[1]);
var automaticTestProgression = Convert.ToBoolean(dr[2]);
var automaticProgressionDelayMS = Convert.ToInt32(dr[3]);
var invertTrigger = Convert.ToBoolean(dr[4]);
var invertStart = Convert.ToBoolean(dr[5]);
var viewDiagnostics = Convert.ToBoolean(dr[6]);
var verifyChannels = Convert.ToBoolean(dr[7]);
var autoVerifyChannels = Convert.ToBoolean(dr[8]);
var verifyChannelsDelayMS = Convert.ToInt32(dr[9]);
int recordingMode = Convert.ToInt16(dr[10]);
var samplesPerSecond = Convert.ToSingle(dr[11]);
var preTriggerSeconds = Convert.ToSingle(dr[12]);
var postTriggerSeconds = Convert.ToSingle(dr[13]);
var strictDiagnostics = Convert.ToBoolean(dr[14]);
var requireConfirmationOnErrors = Convert.ToBoolean(dr[15]);
var roiDownload = Convert.ToBoolean(dr[16]);
var viewROIDownload = Convert.ToBoolean(dr[17]);
var downloadAll = Convert.ToBoolean(dr[18]);
var viewRealtime = Convert.ToBoolean(dr[19]);
int realtimePlotCount = Convert.ToInt16(dr[20]);
var regionsOfInterest = Convert.ToString(dr[21]);
var roiEnd = Convert.ToSingle(dr[22]);
var viewDownloadAll = Convert.ToBoolean(dr[23]);
var export = Convert.ToBoolean(dr[24]);
int exportFormat = Convert.ToInt16(dr[25]);
var labDetails = Convert.ToString(dr[26]);
var useLabDetails = Convert.ToBoolean(dr[27]);
var customerDetails = Convert.ToString(dr[28]);
var useCustomerDetails = Convert.ToBoolean(dr[29]);
var allowMissingSensors = Convert.ToBoolean(dr[30]);
var allowSensorIdToBlankChannel = Convert.ToBoolean(dr[31]);
var localOnly = Convert.ToBoolean(dr[32]);
var lastModified = Convert.ToDateTime(dr[33]);
var lastModifiedBy = Convert.ToString(dr[34]);
var turnOffExcitation = Convert.ToBoolean(dr[35]);
var triggerCheckRealtime = Convert.ToBoolean(dr[36]);
var triggerCheckStep = Convert.ToBoolean(dr[37]);
var postTestDiagnostics = Convert.ToInt32(dr[38]);
var exportFolder = Convert.ToString(dr[39]);
var downloadFolder = Convert.ToString(dr[40]);
var commonStatusLine = Convert.ToBoolean(dr[41]);
var sameAsDownloadFolder = Convert.ToBoolean(dr[42]);
var uploadData = Convert.ToBoolean(dr[43]);
var uploadDataFolder = Convert.ToString(dr[44]);
var settings = Convert.ToString(dr[45]);
var warnOnBatteryFail = false; if (!DBNull.Value.Equals(dr[46])) { warnOnBatteryFail = Convert.ToBoolean(dr[46]); }
var dirty = false; if (!DBNull.Value.Equals(dr[47])) { dirty = Convert.ToBoolean(dr[47]); }
var complete = false; if (!DBNull.Value.Equals(dr[48])) { complete = Convert.ToBoolean(dr[48]); }
var errorMessage = string.Empty; if (!DBNull.Value.Equals(dr[49])) { errorMessage = Convert.ToString(dr[49]); }
var sql2 = GetSQLCommand();
sql2.CommandText = BEGIN_STATEMENT;
i++;
var sb = new StringBuilder(100);
var sb2 = new StringBuilder(100);
sb.Append("INSERT INTO [tblTestSetupsTemp] (");
sb2.Append(" VALUES (");
sb.Append("SetupName");
sb2.AppendFormat("@SetupName{0}", i);
CreateParam(sql2, string.Format("@SetupName{0}", i), SqlDbType.NVarChar, setupName);
sb.Append(",SetupDescription");
sb2.AppendFormat(",@SetupDescription{0}", i);
CreateParam(sql2, string.Format("@SetupDescription{0}", i), SqlDbType.NVarChar, setupDescription);
sb.Append(",AutomaticTestProgression");
sb2.AppendFormat(",@AutomaticTestProgression{0}", i);
CreateParam(sql2, string.Format("@AutomaticTestProgression{0}", i), SqlDbType.Bit, automaticTestProgression);
sb.Append(",AutomaticProgressionDelayMS");
sb2.AppendFormat(",@AutomaticProgressionDelayMS{0}", i);
CreateParam(sql2, string.Format("@AutomaticProgressionDelayMS{0}", i), SqlDbType.Int, automaticProgressionDelayMS);
sb.Append(",InvertTrigger");
sb2.AppendFormat(",@InvertTrigger{0}", i);
CreateParam(sql2, string.Format("@InvertTrigger{0}", i), SqlDbType.Bit, invertTrigger);
sb.Append(",InvertStart");
sb2.AppendFormat(",@InvertStart{0}", i);
CreateParam(sql2, string.Format("@InvertStart{0}", i), SqlDbType.Bit, invertStart);
sb.Append(",ViewDiagnostics");
sb2.AppendFormat(",@ViewDiagnostics{0}", i);
CreateParam(sql2, string.Format("@ViewDiagnostics{0}", i), SqlDbType.Bit, viewDiagnostics);
sb.Append(",VerifyChannels");
sb2.AppendFormat(",@VerifyChannels{0}", i);
CreateParam(sql2, string.Format("@VerifyChannels{0}", i), SqlDbType.Bit, verifyChannels);
sb.Append(",AutoVerifyChannels");
sb2.AppendFormat(",@AutoVerifyChannels{0}", i);
CreateParam(sql2, string.Format("@AutoVerifyChannels{0}", i), SqlDbType.Bit, autoVerifyChannels);
sb.Append(",VerifyChannelsDelayMS");
sb2.AppendFormat(",@VerifyChannelsDelayMS{0}", i);
CreateParam(sql2, string.Format("@VerifyChannelsDelayMS{0}", i), SqlDbType.Int, verifyChannelsDelayMS);
sb.Append(",RecordingMode");
sb2.AppendFormat(",@RecordingMode{0}", i);
CreateParam(sql2, string.Format("@RecordingMode{0}", i), SqlDbType.SmallInt, recordingMode);
sb.Append(",SamplesPerSecond");
sb2.AppendFormat(",@SamplesPerSecond{0}", i);
CreateParam(sql2, string.Format("@SamplesPerSecond{0}", i), SqlDbType.Float, samplesPerSecond);
sb.Append(",PreTriggerSeconds");
sb2.AppendFormat(",@PreTriggerSeconds{0}", i);
CreateParam(sql2, string.Format("@PreTriggerSeconds{0}", i), SqlDbType.Float, preTriggerSeconds);
sb.Append(",PostTriggerSeconds");
sb2.AppendFormat(",@PostTriggerSeconds{0}", i);
CreateParam(sql2, string.Format("@PostTriggerSeconds{0}", i), SqlDbType.Float, postTriggerSeconds);
sb.Append(",StrictDiagnostics");
sb2.AppendFormat(",@StrictDiagnostics{0}", i);
CreateParam(sql2, string.Format("@StrictDiagnostics{0}", i), SqlDbType.Bit, strictDiagnostics);
sb.Append(",RequireConfirmationOnErrors");
sb2.AppendFormat(",@RequireConfirmationOnErrors{0}", i);
CreateParam(sql2, string.Format("@RequireConfirmationOnErrors{0}", i), SqlDbType.Bit, requireConfirmationOnErrors);
sb.Append(",ROIDownload");
sb2.AppendFormat(",@ROIDownload{0}", i);
CreateParam(sql2, string.Format("@ROIDownload{0}", i), SqlDbType.Bit, roiDownload);
sb.Append(",ViewROIDownload");
sb2.AppendFormat(",@ViewROIDownload{0}", i);
CreateParam(sql2, string.Format("@ViewROIDownload{0}", i), SqlDbType.Bit, viewROIDownload);
sb.Append(",DownloadAll");
sb2.AppendFormat(",@DownloadAll{0}", i);
CreateParam(sql2, string.Format("@DownloadAll{0}", i), SqlDbType.Bit, downloadAll);
sb.Append(",ViewRealtime");
sb2.AppendFormat(",@ViewRealtime{0}", i);
CreateParam(sql2, string.Format("@ViewRealtime{0}", i), SqlDbType.Bit, viewRealtime);
sb.Append(",RealtimePlotCount");
sb2.AppendFormat(",@RealtimePlotCount{0}", i);
CreateParam(sql2, string.Format("@RealtimePlotCount{0}", i), SqlDbType.SmallInt, realtimePlotCount);
sb.Append(",RegionsOfInterest");
sb2.AppendFormat(",@RegionsOfInterest{0}", i);
CreateParam(sql2, string.Format("@RegionsOfInterest{0}", i), SqlDbType.NVarChar, regionsOfInterest);
sb.Append(",ROIEnd");
sb2.AppendFormat(",@ROIEnd{0}", i);
CreateParam(sql2, string.Format("@ROIEnd{0}", i), SqlDbType.Float, roiEnd);
sb.Append(",ViewDownloadAll");
sb2.AppendFormat(",@ViewDownloadAll{0}", i);
CreateParam(sql2, string.Format("@ViewDownloadAll{0}", i), SqlDbType.Bit, viewDownloadAll);
sb.Append(",Export");
sb2.AppendFormat(",@Export{0}", i);
CreateParam(sql2, string.Format("@Export{0}", i), SqlDbType.Bit, export);
sb.Append(",ExportFormat");
sb2.AppendFormat(",@ExportFormat{0}", i);
CreateParam(sql2, string.Format("@ExportFormat{0}", i), SqlDbType.SmallInt, exportFormat);
sb.Append(",LabDetails");
sb2.AppendFormat(",@LabDetails{0}", i);
CreateParam(sql2, string.Format("@LabDetails{0}", i), SqlDbType.NVarChar, labDetails);
sb.Append(",UseLabDetails");
sb2.AppendFormat(",@UseLabDetails{0}", i);
CreateParam(sql2, string.Format("@UseLabDetails{0}", i), SqlDbType.Bit, useLabDetails);
sb.Append(",CustomerDetails");
sb2.AppendFormat(",@CustomerDetails{0}", i);
CreateParam(sql2, string.Format("@CustomerDetails{0}", i), SqlDbType.NVarChar, customerDetails);
sb.Append(",UseCustomerDetails");
sb2.AppendFormat(",@UseCustomerDetails{0}", i);
CreateParam(sql2, string.Format("@UseCustomerDetails{0}", i), SqlDbType.Bit, useCustomerDetails);
sb.Append(",AllowMissingSensors");
sb2.AppendFormat(",@AllowMissingSensors{0}", i);
CreateParam(sql2, string.Format("@AllowMissingSensors{0}", i), SqlDbType.Bit, allowMissingSensors);
sb.Append(",AllowSensorIdToBlankChannel");
sb2.AppendFormat(",@AllowSensorIdToBlankChannel{0}", i);
CreateParam(sql2, string.Format("@AllowSensorIdToBlankChannel{0}", i), SqlDbType.Bit, allowSensorIdToBlankChannel);
sb.Append(",LocalOnly");
sb2.AppendFormat(",@LocalOnly{0}", i);
CreateParam(sql2, string.Format("@LocalOnly{0}", i), SqlDbType.Bit, localOnly);
sb.Append(",LastModified");
sb2.AppendFormat(",@LastModified{0}", i);
CreateParam(sql2, string.Format("@LastModified{0}", i), SqlDbType.DateTime, lastModified);
sb.Append(",LastModifiedBy");
sb2.AppendFormat(",@LastModifiedBy{0}", i);
CreateParam(sql2, string.Format("@LastModifiedBy{0}", i), SqlDbType.NVarChar, lastModifiedBy);
sb.Append(",TurnOffExcitation");
sb2.AppendFormat(",@TurnOffExcitation{0}", i);
CreateParam(sql2, string.Format("@TurnOffExcitation{0}", i), SqlDbType.Bit, turnOffExcitation);
sb.Append(",TriggerCheckRealtime");
sb2.AppendFormat(",@TriggerCheckRealtime{0}", i);
CreateParam(sql2, string.Format("@TriggerCheckRealtime{0}", i), SqlDbType.Bit, triggerCheckRealtime);
sb.Append(",TriggerCheckStep");
sb2.AppendFormat(",@TriggerCheckStep{0}", i);
CreateParam(sql2, string.Format("@TriggerCheckStep{0}", i), SqlDbType.Bit, triggerCheckStep);
sb.Append(",PostTestDiagnostics");
sb2.AppendFormat(",@PostTestDiagnostics{0}", i);
CreateParam(sql2, string.Format("@PostTestDiagnostics{0}", i), SqlDbType.Int, postTestDiagnostics);
sb.Append(",ExportFolder");
sb2.AppendFormat(",@ExportFolder{0}", i);
CreateParam(sql2, string.Format("@ExportFolder{0}", i), SqlDbType.NVarChar, exportFolder);
sb.Append(",DownloadFolder");
sb2.AppendFormat(",@DownloadFolder{0}", i);
CreateParam(sql2, string.Format("@DownloadFolder{0}", i), SqlDbType.NVarChar, downloadFolder);
sb.Append(",CommonStatusLine");
sb2.AppendFormat(",@CommonStatusLine{0}", i);
CreateParam(sql2, string.Format("@CommonStatusLine{0}", i), SqlDbType.Bit, commonStatusLine);
sb.Append(",SameAsDownloadFolder");
sb2.AppendFormat(",@SameAsDownloadFolder{0}", i);
CreateParam(sql2, string.Format("@SameAsDownloadFolder{0}", i), SqlDbType.Bit, sameAsDownloadFolder);
sb.Append(",UploadData");
sb2.AppendFormat(",@UploadData{0}", i);
CreateParam(sql2, string.Format("@UploadData{0}", i), SqlDbType.Bit, uploadData);
sb.Append(",UploadDataFolder");
sb2.AppendFormat(",@UploadDataFolder{0}", i);
CreateParam(sql2, string.Format("@UploadDataFolder{0}", i), SqlDbType.NVarChar, uploadDataFolder);
sb.Append(",Settings");
sb2.AppendFormat(",@Settings{0}", i);
CreateParam(sql2, string.Format("@Settings{0}", i), SqlDbType.NVarChar, settings);
sb.Append(",WarnOnBatteryFail");
sb2.AppendFormat(",@WarnOnBatteryFail{0}", i);
CreateParam(sql2, string.Format("@WarnOnBatteryFail{0}", i), SqlDbType.Bit, warnOnBatteryFail);
sb.Append(",Dirty");
sb2.AppendFormat(",@Dirty{0}", i);
CreateParam(sql2, string.Format("@Dirty{0}", i), SqlDbType.Bit, dirty);
sb.Append(",Complete");
sb2.AppendFormat(",@Complete{0}", i);
CreateParam(sql2, string.Format("@Complete{0}", i), SqlDbType.Bit, complete);
sb.Append(",ErrorMessage)");
sb2.AppendFormat(", @ErrorMessage{0});", i);
CreateParam(sql2, string.Format("@ErrorMessage{0}", i), SqlDbType.NVarChar, errorMessage);
sb.Append(sb2.ToString());
sql2.CommandText += sb.ToString();
sql2.CommandText += COMMIT_STATEMENT;
Connection.ExecuteCommand(sql2);
sql2.Dispose();
}
}
}
sql.CommandText = "DROP TABLE tblTestSetups";
Connection.ExecuteCommand(sql);
if (_usingMSSQL)
{
_cmd.CommandText = "ALTER TABLE tblTestSetups ADD UserTags VARBINARY(MAX)";
}
else { _cmd.CommandText = "ALTER TABLE tblTestSetups ADD UserTags BLOB"; }
Connection.ExecuteCommand(sql);
}
InsertIntoVersionsTable(27, 0);
}
private void MigrateVersion11()
{
try
{
CreateSettingsTable();
}
catch (Exception)
{
//ignore
}
InsertIntoVersionsTable(12, 0);
}
/// <summary>
/// the process of migrating from version 1 to version 2
/// </summary>
private void MigrateVersion1()
{
//all that needs to be done here is add a new table
CreateDigitalInputsTableV1();
//finally insert the new version info into the table
InsertIntoVersionsTable(2, 0);
}
private void MigrateVersion2()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblDigitalInputSetting ADD LastModified DateTime";
ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblDigitalInputSetting ADD LastModifiedBy NVARCHAR(50)";
ExecuteCommand(cmd);
}
InsertIntoVersionsTable(3, 0);
}
private void MigrateVersion3()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = string.Format("ALTER TABLE tblDASChannels ADD {0} INT", DAS.DASChannelFields.SupportedDigitalInputModes.ToString());
ExecuteCommand(cmd);
cmd.CommandText = string.Format("ALTER TABLE tblDASChannels ADD {0} INT", DAS.DASChannelFields.SupportedDigitalOutputModes.ToString());
ExecuteCommand(cmd);
cmd.CommandText = string.Format("ALTER TABLE tblDASChannels ADD {0} INT", DAS.DASChannelFields.SupportedSquibFireModes.ToString());
ExecuteCommand(cmd);
}
InsertIntoVersionsTable(4, 0);
}
private void MigrateVersion4()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = string.Format("ALTER TABLE tblTestSetups Add {0} NVARCHAR(255)", TestSetups.Fields.Settings.ToString());
ExecuteCommand(cmd);
}
InsertIntoVersionsTable(5, 0);
}
private void MigrateVersion6()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = string.Format("ALTER TABLE tblDASChannels ADD {0} NVARCHAR (16)", DAS.DASChannelFields.ModuleSerialNumber.ToString());
ExecuteCommand(cmd);
}
if (_bMigratedVersion5)
{
CreateSlice2_BasePrototypeHardware();
CreateTDASPro_4MRackPrototypeHardware();
CreateTDASPro_8MRackPrototypeHardware();
CreateTDAS_G5PrototypeHardware();
CreateSLICE_15PrototypeHardware();
CreateSLICE_1PrototypeHardware();
CreateSLICE_MicroPrototypeHardware();
CreateSLICE_NanoPrototypeHardware();
CreateECM_PrototypeHardware();
CreateSDB_PrototypeHardware();
}
CreateSLICE2_DIMPrototypeHardware();
CreateSLICE2_SIMPrototypeHardware();
InsertIntoVersionsTable(7, 0);
}
private void MigrateVersion7()
{
CreateSLICE2_TOMPrototypeHardware();
InsertIntoVersionsTable(8, 0);
}
private void MigrateVersion8()
{
UpdateCalibrationRecords();
InsertIntoVersionsTable(9, 0);
}
internal class MigrateVersion9Data : IComparable<MigrateVersion9Data>
{
public int ChannelIdx { get; set; }
public string HardwareId { get; set; }
public string ModuleSerialNumber { get; set; }
public int ModuleArrayIndex { get; set; }
public int CompareTo(MigrateVersion9Data right)
{
if (right == this) { return 0; }
return ChannelIdx.CompareTo(right.ChannelIdx);
}
}
private void MigrateVersion9()
{
using (var cmd = GetSQLCommand())
{
//note we don't use the string constants here because the names of columns and tables can change in the version
//but as of version 9, they are fixed in place.
cmd.CommandText = "ALTER TABLE tblDASChannels ADD ModuleArrayIndex INT NULL";
ExecuteCommand(cmd);
}
var rowsToMigrate = new Dictionary<string, List<MigrateVersion9Data>>();
using (var cmd = GetSQLCommand())
{
cmd.CommandText = @"SELECT * FROM tblDASChannels";
using (var ds = QueryDataSet(cmd))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
var channelIdx = Convert.ToInt32(row["ChannelIdx"]);
var hardwareId = Convert.ToString(row["HardwareId"]);
var moduleSerialNumber = Convert.ToString(row["ModuleSerialNumber"]);
var toMigrate = new MigrateVersion9Data() { ChannelIdx = channelIdx, HardwareId = hardwareId, ModuleSerialNumber = moduleSerialNumber };
if (!rowsToMigrate.ContainsKey(hardwareId))
{
rowsToMigrate.Add(hardwareId, new List<MigrateVersion9Data>());
}
rowsToMigrate[hardwareId].Add(toMigrate);
}
}
}
var e = rowsToMigrate.GetEnumerator();
while (e.MoveNext())
{
var list = e.Current.Value;
list.Sort();
var currentModuleArrayIndex = 0;
string currentSerialNumber = null;
var hid = list[0].HardwareId;
var index = hid.LastIndexOf('_');
var sType = hid.Substring(index + 1);
var firstModuleSerialNumber = list[0].ModuleSerialNumber;
currentSerialNumber = firstModuleSerialNumber;
//now unfortunately ... older databases may not have serial numbers filled in
//in addition ... the prototypes used to build things will not have serial numbers filled in
//we have to handle these two cases
//however if the first module in fact has a module serial number, then we can just go through and increment every new
//serial number
if (string.IsNullOrWhiteSpace(firstModuleSerialNumber))
{
switch (sType)
{
case "0":// SLICE_Base=0,
case "8":// SLICE2_Base=8,
case "16":// SLICE1_5_Base = 16,
case "17":// SLICE_Micro_Base = 17,
case "18":// SLICE_NANO_Base = 18,
case "19":// SLICE2_SIM=19,
case "20":// SLICE2_DIM=20,
{
//new module every 3 channels
for (var i = 0; i < list.Count; i++)
{
if (i > 0 && 0 == i % 3)
{
currentModuleArrayIndex++;
}
list[i].ModuleArrayIndex = currentModuleArrayIndex;
}
}
break;
case "12":// G5=12,
{
//new module every 8 channels
for (var i = 0; i < list.Count; i++)
{
if (i > 0 && 0 == i % 8)
{
currentModuleArrayIndex++;
}
list[i].ModuleArrayIndex = currentModuleArrayIndex;
}
}
break;
case "13":// Ribeye=13,
case "14":// RibeyeLED=14,
//there might be something we can do for ribeye, but I have no idea what currently
break;
case "21":// SLICE2_TOM=21
{
//we just consider everything _one_ module, since they can't be broken apart anyhow
foreach (var ch in list)
{
ch.ModuleArrayIndex = 0;
}
}
break;
default:
{
//nothing we can do with these ones, they are either no DAS and are modules which we
//should never see here, or in the case of the rack are empty
foreach (var ch in list) //probably none, but just to check ...
{
ch.ModuleArrayIndex = 0;
}
}
break;
}
}
else//we have module serial numbers, so do it the easy way
{
foreach (var ch in list)
{
if (ch.ModuleSerialNumber != currentSerialNumber)
{
currentModuleArrayIndex++;
currentSerialNumber = ch.ModuleSerialNumber;
}
ch.ModuleArrayIndex = currentModuleArrayIndex;
}
}
}
//now finally update the table
var e2 = rowsToMigrate.GetEnumerator();
while (e2.MoveNext())
{
var list = e2.Current.Value;
foreach (var ch in list)
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "UPDATE tblDASChannels SET ModuleArrayIndex=@ModuleArrayIndex where HardwareId=@HardwareId AND ChannelIdx=@ChannelIdx";
CreateParam(cmd, "@ModuleArrayIndex", SqlDbType.Int, ch.ModuleArrayIndex);
CreateParam(cmd, "@HardwareId", SqlDbType.NVarChar, ch.HardwareId);
CreateParam(cmd, "@ChannelIdx", SqlDbType.Int, ch.ChannelIdx);
ExecuteCommand(cmd);
}
}
}
InsertIntoVersionsTable(10, 0);
}
private void MigrateVersion10()
{
UpdateCalibrationandDisplayUnits();
InsertIntoVersionsTable(11, 0);
}
private void UpdateCalibrationandDisplayUnits()
{
using (var cmdQRY = GetSQLCommand())
{
//Get all Calibrations
cmdQRY.CommandText = "SELECT * from tblSensorCalibrations";
using (var ds = QueryDataSet(cmdQRY))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var serialNumber = Convert.ToString(dr[SensorDB.SensorCalibrationFields.SerialNumber.ToString()]);
var calDate = Convert.ToDateTime(dr[SensorDB.SensorCalibrationFields.CalibrationDate.ToString()]);
var modifyDate = Convert.ToDateTime(dr[SensorDB.SensorCalibrationFields.ModifyDate.ToString()]);
var cr = Convert.ToString(dr[SensorDB.SensorCalibrationFields.CalibrationRecords.ToString()]);
var excitationRecords = cr.Split(new string[] { "__x__" }, StringSplitOptions.None);
for (var i = 0; i < excitationRecords.Length; i++)
{
// split record into fields
var calRecordFields = excitationRecords[i].Split(',');
using (var cmdQRY2 = GetSQLCommand())
{
//Get matching sensor data
cmdQRY2.CommandText = "SELECT * FROM tblSensors where SerialNumber=@SerialNumber";
CreateParam(cmdQRY2, "@SerialNumber", SqlDbType.NVarChar, serialNumber);
using (var ds2 = QueryDataSet(cmdQRY2))
{
var dr2 = ds2.Tables[0].Rows[0];
var displayUnit = Convert.ToString(dr2[SensorDB.SensorDataFields.MeasurementUnit.ToString()]);
// compare calibration EU to sensor data EU
if (!string.Equals(calRecordFields[(int)SensorDB.SensorCalibrationRecordFields.EngineeringUnits], displayUnit, StringComparison.OrdinalIgnoreCase))
{
// It's Different. Let's set it to the sensor data EU
calRecordFields[(int)SensorDB.SensorCalibrationRecordFields.EngineeringUnits] = displayUnit;
}
}
}
//Stuff back in record string
excitationRecords[i] = string.Join(",", calRecordFields);
}
cr = string.Join("__x__", excitationRecords);
// execute change
using (var cmdEX = GetSQLCommand())
{
cmdEX.CommandText = "UPDATE tblSensorCalibrations SET CalibrationRecords=@CalibrationRecords where SerialNumber=@SerialNumber AND CalibrationDate=@CalibrationDate AND ModifyDate=@ModifyDate";
CreateParam(cmdEX, "@SerialNumber", SqlDbType.NVarChar, serialNumber);
CreateParam(cmdEX, "@CalibrationDate", SqlDbType.DateTime, calDate);
CreateParam(cmdEX, "@ModifyDate", SqlDbType.DateTime, modifyDate);
CreateParam(cmdEX, "@CalibrationRecords", SqlDbType.NVarChar, cr);
ExecuteCommand(cmdEX);
}
}
}
}
}
private bool _bMigratedVersion5 = false;
private void MigrateVersion5()
{
_bMigratedVersion5 = true;
InsertIntoVersionsTable(6, 0);
}
public void MigrateVersion12()
{
CreateTDAS_G5IPortPrototypeHardware();
InsertIntoVersionsTable(13, 0);
}
public void MigrateVersion13()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblTOMDigitalChannels ADD [DurationMSFloat] [float]";
ExecuteCommand(cmd);
}
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "SELECT * from tblTOMDigitalChannels";
using (var ds = QueryDataSet(cmd))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var oldDurationMS = Convert.ToDouble(dr[DigitalOutputSettings.Fields.DurationMS.ToString()]);
var channelDescription = Convert.ToString(dr[DigitalOutputSettings.Fields.ChannelDescription.ToString()]);
// execute change
using (var cmdUpdate = GetSQLCommand())
{
cmdUpdate.CommandText = "UPDATE tblTOMDigitalChannels SET DurationMSFloat=@DurationMS where ChannelDescription=@ChannelDescription";
CreateParam(cmdUpdate, "@DurationMS", SqlDbType.Float, oldDurationMS);
CreateParam(cmdUpdate, "@ChannelDescription", SqlDbType.NVarChar, channelDescription);
ExecuteCommand(cmdUpdate);
}
}
}
}
InsertIntoVersionsTable(14, 0);
}
/// <summary>
/// migration step for databases originally prior to SLICE PRO SIM/DIM updates
/// </summary>
public void MigrateVersion14()
{
var simMigrated = new List<string>();
var dimsToPanicAbout = new List<string>();
using (var cmd = GetSQLCommand())
{
//SPS becomes type 19, was type 8
//first, find all SIMS that need to change
//we don't expect dims, but keep an eye out for them.
cmd.CommandText = "SELECT * FROM [tblDAS] where [Type]=8";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var o = dr["SerialNumber"];
if (null == o || DBNull.Value.Equals(o)) { continue; }
var serial = Convert.ToString(o);
if (serial.ToUpper().StartsWith("SPD") || serial.ToUpper().StartsWith("SLD"))
{
if (!dimsToPanicAbout.Contains(serial)) { dimsToPanicAbout.Add(serial); }
}
else
{
if (!simMigrated.Contains(serial))
{
simMigrated.Add(serial);
}
}
}
}
}
if (dimsToPanicAbout.Count > 0 && simMigrated.Count > 0)
{
log.WriteEntry("DIMs found in DB, exiting");
Environment.Exit(1);
}
else
{
cmd.CommandText = "UPDATE [tblDAS] set [Type]=19 where [Type]=8";
Connection.ExecuteCommand(cmd);
}
}
var oldToNewID = new Dictionary<string, string>();
using (var cmd = GetSQLCommand())
{
foreach (var s in simMigrated)
{
//migrate tblTestObjectHardware
try
{
cmd.CommandText = string.Format("UPDATE [tblTestObjectHardware] set [HardwareId]='" + string.Format("{0}_19", s) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", s) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrate tblDASChannels
try
{
cmd.CommandText = string.Format("UPDATE [tblDASChannels] set [HardwareId]='" + string.Format("{0}_19", s) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", s) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrating tblTestObjectsSensors is more difficult as we have to consider channel numbers, etc
//we'll keep a list of unique ones we've found and update all the unique instances at once
cmd.CommandText = "SELECT [HardwareId] from [tblTestObjectSensors] where [HardwareId] like '" + string.Format("{0}_%", s) + "'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["HardwareId"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
var sOriginal = Convert.ToString(o);
if (oldToNewID.ContainsKey(sOriginal)) { continue; }
//the channel number is split off using an x
var tokens = sOriginal.Split('x');
if (2 != tokens.Length) { continue; }
var chNum = Convert.ToInt32(tokens[1]);
tokens = tokens[0].Split('_');
//the id can come in two forms, one with an ip and one without
//the one without an ip is newer, but we might find either form
if (tokens.Length == 3)//BA50637_18_192.168.0.181x5
{
var sNew = string.Format("{0}_19x{1}", s, chNum);
oldToNewID[sOriginal] = sNew;
}
else if (tokens.Length == 2)
{
var sNew = string.Format("{0}_19", s);
oldToNewID[sOriginal] = sNew;
}
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
}
//now finally, update for all unique entries
using (var e = oldToNewID.GetEnumerator())
{
while (e.MoveNext())
{
cmd.CommandText = string.Format("Update [tblTestObjectSensors] set [HardwareId]='" +
e.Current.Value + "' where [HardwareId]='" + e.Current.Key +
"'");
Connection.ExecuteCommand(cmd);
}
}
}
InsertIntoVersionsTable(15, 0);
}
public void MigrateVersion15()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblDigitalInputSetting ADD SensorId NVARCHAR(50)";
ExecuteCommand(cmd);
}
InsertIntoVersionsTable(16, 0);
}
public void MigrateVersion16()
{
var ECMsToMigrate = new List<string>();
using (var cmd = GetSQLCommand())
{
//=================
//tblDAS updates
//=================
// Change Type on ECM Prototype
cmd.CommandText = "UPDATE [tblDAS] set [Type]=24 where [Type] like 2 and [Position] like 'Prototype'";
ExecuteCommand(cmd);
// Collect Serial Numbers for all ECMs and Change Type to 24
cmd.CommandText = "SELECT * FROM [tblDAS] where [Type] like 2 and [SerialNumber] like 'SPE%'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["SerialNumber"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
ECMsToMigrate.Add(o.ToString());
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
cmd.CommandText = "UPDATE [tblDAS] set [Type]=24 where [Type] like 2 and [SerialNumber] like 'SPE%'";
ExecuteCommand(cmd);
}
var oldToNewID = new Dictionary<string, string>();
using (var cmd = GetSQLCommand())
{
foreach (var ecm in ECMsToMigrate)
{
//migrate tblTestObjectHardware
try
{
cmd.CommandText = string.Format("UPDATE [tblTestObjectHardware] set [HardwareId]='" + string.Format("{0}_24", ecm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", ecm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrate tblDASChannels
try
{
cmd.CommandText = string.Format("UPDATE [tblDASChannels] set [HardwareId]='" + string.Format("{0}_24", ecm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", ecm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrating tblTestObjectsSensors is more difficult as we have to consider channel numbers, etc
//we'll keep a list of unique ones we've found and update all the unique instances at once
cmd.CommandText = "SELECT [HardwareId] from [tblTestObjectSensors] where [HardwareId] like '" + string.Format("{0}_%", ecm) + "'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["HardwareId"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
var sOriginal = Convert.ToString(o);
if (oldToNewID.ContainsKey(sOriginal)) { continue; }
//the channel number is split off using an x
var tokens = sOriginal.Split('x');
if (2 != tokens.Length) { continue; }
var chNum = Convert.ToInt32(tokens[1]);
tokens = tokens[0].Split('_');
//the id can come in two forms, one with an ip and one without
//the one without an ip is newer, but we might find either form
if (tokens.Length == 3)//BA50637_18_192.168.0.181x5
{
var sNew = string.Format("{0}_24x{1}", ecm, chNum);
oldToNewID[sOriginal] = sNew;
}
else if (tokens.Length == 2)
{
var sNew = string.Format("{0}_24", ecm);
oldToNewID[sOriginal] = sNew;
}
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
}
//now finally, update for all unique entries
using (var e = oldToNewID.GetEnumerator())
{
while (e.MoveNext())
{
cmd.CommandText = string.Format("Update [tblTestObjectSensors] set [HardwareId]='" +
e.Current.Value + "' where [HardwareId]='" + e.Current.Key +
"'");
Connection.ExecuteCommand(cmd);
}
}
}
CreateSDB_PrototypeHardware();
InsertIntoVersionsTable(17, 0);
}
public void MigrateVersion17()
{
//we create a temporary table, designed as we want, drop the old table, then rename the table
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestObjectChannelSettingsTemp](
[TestObjectSerial] [nvarchar](255) NOT NULL,
[ChannelId] [nvarchar](255) NOT NULL,
[Setting] [nvarchar](255) NULL,
[SensorSerial] [nvarchar](255) NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = "INSERT INTO tblTestObjectChannelSettingsTemp SELECT * FROM tblTestObjectChannelSettings";
Connection.ExecuteCommand(sql);
sql.CommandText = "DROP TABLE tblTestObjectChannelSettings";
Connection.ExecuteCommand(sql);
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblTestObjectChannelSettingsTemp, tblTestObjectChannelSettings";
}
else
{
sql.CommandText = "ALTER TABLE tblTestObjectChannelSettingsTemp RENAME TO tblTestObjectChannelSettings";
}
Connection.ExecuteCommand(sql);
}
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestChannelSettingsTemp](
[TestName] [nvarchar](255) NOT NULL,
[TestObjectName] [nvarchar](255) NOT NULL,
[ChannelId] [nvarchar](255) NOT NULL,
[Setting] [nvarchar](255) NULL,
[SensorSerial] [nvarchar](255) NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = "INSERT INTO tblTestChannelSettingsTemp SELECT * FROM tblTestChannelSettings";
Connection.ExecuteCommand(sql);
sql.CommandText = "DROP TABLE tblTestChannelSettings";
Connection.ExecuteCommand(sql);
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblTestChannelSettingsTemp, tblTestChannelSettings";
}
else
{
sql.CommandText = "ALTER TABLE tblTestChannelSettingsTemp RENAME TO tblTestChannelSettings";
}
Connection.ExecuteCommand(sql);
}
using (var sql = GetSQLCommand())
{
sql.CommandText = @"CREATE TABLE [tblTestSetupObjectMetaDataTemp](
[SetupName] [nvarchar](255) NOT NULL,
[TestObject] [char](1) NOT NULL,
[PropName] [nvarchar](255) NOT NULL,
[PropValue] [nvarchar](255) NOT NULL,
[Optional] [bit] NOT NULL,
[Version] [float] NOT NULL)";
Connection.ExecuteCommand(sql);
sql.CommandText = "INSERT INTO tblTestSetupObjectMetaDataTemp SELECT * FROM tblTestSetupObjectMetaData";
Connection.ExecuteCommand(sql);
sql.CommandText = "DROP TABLE tblTestSetupObjectMetaData";
Connection.ExecuteCommand(sql);
if (_usingMSSQL)
{
sql.CommandText = "sp_rename tblTestSetupObjectMetaDataTemp, tblTestSetupObjectMetaData";
}
else
{
sql.CommandText = "ALTER TABLE tblTestSetupObjectMetaDataTemp RENAME TO tblTestSetupObjectMetaData";
}
Connection.ExecuteCommand(sql);
}
InsertIntoVersionsTable(18, 0);
}
private void MigrateVersion21()
{
using (var cmd = GetSQLCommand())
{
cmd.CommandText = "ALTER TABLE tblTestSetups ADD Dirty BIT";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblTestSetups ADD Complete BIT";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "ALTER TABLE tblTestSetups ADD ErrorMessage [nvarchar](255)";
Connection.ExecuteCommand(cmd);
}
InsertIntoVersionsTable(22, 0);
}
/// <summary>
/// expands the length of iso customer/lab fields
/// 6346 Increase field length for customer details columns in database to 255 [Zendesk #1147]
/// </summary>
private void MigrateVersion20()
{
using (var cmd = GetSQLCommand())
{
var sql = @"CREATE TABLE [tblCustomerDetailsTEMP](
[Name] [nvarchar](255) NOT NULL PRIMARY KEY,
[CustomerName] [nvarchar](255) NULL,
[CustomerTestRefNumber] [nvarchar](255) NULL,
[ProjectRefNumber] [nvarchar](255) NULL,
[CustomerOrderNumber] [nvarchar](255) NULL,
[CustomerCostUnit] [nvarchar](255) NULL,
[CustomerTestEngineerName] [nvarchar](255) NULL,
[CustomerTestEngineerPhone] [nvarchar](255) NULL,
[CustomerTestEngineerFax] [nvarchar](255) NULL,
[CustomerTestEngineerEmail] [nvarchar](255) NULL,
[LocalOnly] [bit] NULL,
[LastModified] [datetime] NULL,
[LastModifiedBy] [nvarchar](50) NULL,
[Version] [int] NULL
)";
cmd.CommandText = sql;
Connection.ExecuteCommand(cmd);
cmd.CommandText = "INSERT INTO tblCustomerDetailsTEMP SELECT * FROM tblCustomerDetails";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "DROP TABLE tblCustomerDetails";
Connection.ExecuteCommand(cmd);
if (_usingMSSQL)
{
cmd.CommandText = "sp_rename tblCustomerDetailsTEMP, tblCustomerDetails";
}
else
{
cmd.CommandText = "ALTER TABLE tblCustomerDetailsTEMP RENAME TO tblCustomerDetails";
}
Connection.ExecuteCommand(cmd);
}
using (var cmd = GetSQLCommand())
{
var sql = @"CREATE TABLE [tblLabratoryDetailsTEMP](
[Name] [nvarchar](255) NOT NULL PRIMARY KEY,
[LabratoryName] [nvarchar](255) NULL,
[LabratoryContactName] [nvarchar](255) NULL,
[LabratoryContactPhone] [nvarchar](255) NULL,
[LabratoryContactFax] [nvarchar](255) NULL,
[LabratoryContactEmail] [nvarchar](255) NULL,
[LabratoryTestRefNumber] [nvarchar](255) NULL,
[LastModified] [datetime] NOT NULL,
[LastModifiedBy] [nvarchar](50) NULL,
[LocalOnly] [bit] NULL,
[Version] [int] NULL
)";
cmd.CommandText = sql;
Connection.ExecuteCommand(cmd);
cmd.CommandText = "INSERT INTO tblLabratoryDetailsTEMP SELECT * FROM tblLabratoryDetails";
Connection.ExecuteCommand(cmd);
cmd.CommandText = "DROP TABLE tblLabratoryDetails";
Connection.ExecuteCommand(cmd);
if (_usingMSSQL)
{
cmd.CommandText = "sp_rename tblLabratoryDetailsTEMP, tblLabratoryDetails";
}
else
{
cmd.CommandText = "ALTER TABLE tblLabratoryDetailsTEMP RENAME TO tblLabratoryDetails";
}
Connection.ExecuteCommand(cmd);
}
InsertIntoVersionsTable(21, 0);
}
/// <summary>
/// adds warnonbatteryfail to test setups
/// </summary>
public void MigrateVersion18()
{
using (var sql = GetSQLCommand())
{
sql.CommandText = "ALTER TABLE tblTestSetups ADD WarnOnBatteryFail BIT";
Connection.ExecuteCommand(sql);
}
InsertIntoVersionsTable(19, 0);
}
private void MigrateVersion19()
{
CreateSLICE_15MicroPrototypeHardware();
InsertIntoVersionsTable(20, 0);
}
/// <summary>
/// adds a testsetuphardware table
/// </summary>
private void MigrateVersion24()
{
CreateTestSetupHardwareTable();
InsertIntoVersionsTable(25, 0);
}
/// <summary>
/// Change all iPorts to InDummy
/// </summary>
public void MigrateVersion23()
{
var G5_IPortsToMigrate = new List<string>();
using (var cmd = GetSQLCommand())
{
//=================
//tblDAS updates
//=================
// Collect Serial Numbers for all G5 iPorts and Change Type to 23
cmd.CommandText = "SELECT * FROM [tblDAS] where [Type] like 22 and [SerialNumber] not like '%Prototype%'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["SerialNumber"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
G5_IPortsToMigrate.Add(o.ToString());
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
cmd.CommandText = "UPDATE [tblDAS] set [Type]=23 where [Type] like 22 and [SerialNumber] not like '%Prototype%'";
ExecuteCommand(cmd);
}
var oldToNewID = new Dictionary<string, string>();
using (var cmd = GetSQLCommand())
{
foreach (var sbpm in G5_IPortsToMigrate)
{
//migrate tblTestObjectHardware
try
{
cmd.CommandText = string.Format("UPDATE [tblTestObjectHardware] set [HardwareId]='" + string.Format("{0}_23", sbpm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", sbpm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrate tblDASChannels
try
{
cmd.CommandText = string.Format("UPDATE [tblDASChannels] set [HardwareId]='" + string.Format("{0}_23", sbpm) + "' WHERE [HardwareId] like '" + string.Format("%{0}_%", sbpm) + "'");
Connection.ExecuteCommand(cmd);
}
catch (Exception ex) { APILogger.Log(ex); }
//migrating tblTestObjectsSensors is more difficult as we have to consider channel numbers, etc
//we'll keep a list of unique ones we've found and update all the unique instances at once
cmd.CommandText = "SELECT [HardwareId] from [tblTestObjectSensors] where [HardwareId] like '" + string.Format("{0}_%", sbpm) + "'";
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
try
{
var o = dr["HardwareId"];
if (null == o || DBNull.Value.Equals(o))
{
continue;
}
var sOriginal = Convert.ToString(o);
if (oldToNewID.ContainsKey(sOriginal)) { continue; }
//the channel number is split off using an x
var tokens = sOriginal.Split('x');
if (2 != tokens.Length) { continue; }
var chNum = Convert.ToInt32(tokens[1]);
tokens = tokens[0].Split('_');
//the id can come in two forms, one with an ip and one without
//the one without an ip is newer, but we might find either form
if (tokens.Length == 3)//BA50637_18_192.168.0.181x5
{
var sNew = string.Format("{0}_23x{1}", sbpm, chNum);
oldToNewID[sOriginal] = sNew;
}
else if (tokens.Length == 2)
{
var sNew = string.Format("{0}_23", sbpm);
oldToNewID[sOriginal] = sNew;
}
}
catch (Exception ex) { APILogger.Log(ex); }
}
}
}
}
//now finally, update for all unique entries
using (var e = oldToNewID.GetEnumerator())
{
while (e.MoveNext())
{
cmd.CommandText = string.Format("Update [tblTestObjectSensors] set [HardwareId]='" +
e.Current.Value + "' where [HardwareId]='" + e.Current.Key +
"'");
Connection.ExecuteCommand(cmd);
}
}
}
CreateTDAS_G5InDummyPrototypeHardware();
InsertIntoVersionsTable(24, 0);
}
public delegate void SetStatusDelegate(string status, bool output = false);
/// <summary>
/// checks the current db version and upgrades and migrates data, if possible
/// </summary>
public MigrationResult UpgradeVersionsIfNeeded(int versionDesired, SetStatusDelegate SetStatus, string dbName,
string _previousDir, string _targetDir, string registryDataPROExe, string applicationSettings)
{
var result = MigrationResult.OK;
if (DbVersion > CURRENT_DB_VERSION)
{
throw new NotSupportedException("DB Version not supported by this version of the DataPRO client");
}
if (DbVersion < CURRENT_DB_VERSION)
{
try
{
log.Source = "DataPROInstaller";
while (DbVersion < versionDesired)
{
switch (DbVersion)
{
case 0:
MigrateVersion0();
DbVersion = 1;
break;
case 1:
MigrateVersion1();
DbVersion = 2;
break;
case 2:
MigrateVersion2();
DbVersion = 3;
break;
case 3:
MigrateVersion3();
DbVersion = 4;
break;
case 4:
MigrateVersion4();
DbVersion = 5;
break;
case 5:
MigrateVersion5();
DbVersion = 6;
break;
case 6:
MigrateVersion6();
DbVersion = 7;
break;
case 7:
MigrateVersion7();
DbVersion = 8;
break;
case 8:
MigrateVersion8();
DbVersion = 9;
break;
case 9:
MigrateVersion9();
DbVersion = 10;
break;
case 10:
MigrateVersion10();
DbVersion = 11;
break;
case 11:
MigrateVersion11();
DbVersion = 12;
break;
case 12:
MigrateVersion12();
DbVersion = 13;
break;
case 13:
MigrateVersion13();
DbVersion = 14;
break;
case 14:
MigrateVersion14();
DbVersion = 15;
break;
case 15:
MigrateVersion15();
DbVersion = 16;
break;
case 16:
MigrateVersion16();
DbVersion = 17;
break;
case 17:
MigrateVersion17();
DbVersion = 18;
break;
case 18:
MigrateVersion18();
DbVersion = 19;
break;
case 19:
MigrateVersion19();
DbVersion = 20;
break;
case 20:
MigrateVersion20();
DbVersion = 21;
break;
case 21:
MigrateVersion21();
DbVersion = 22;
break;
case 22:
MigrateVersion22();
DbVersion = 23;
break;
case 23:
MigrateVersion23();
DbVersion = 24;
break;
case 24:
MigrateVersion24();
DbVersion = 25;
break;
case 25:
MigrateVersion25();
DbVersion = 26;
break;
case 26:
MigrateVersion26();
DbVersion = 27;
break;
case 27:
MigrateVersion27();
DbVersion = 28;
break;
case 28:
MigrateVersion28();
DbVersion = 29;
break;
case 29:
MigrateVersion29();
DbVersion = 30;
break;
case 30:
MigrateVersion30();
DbVersion = 31;
break;
case 31:
MigrateVersion31();
DbVersion = 32;
break;
case 32:
MigrateVersion32();
DbVersion = 33;
break;
case 33:
MigrateVersion33();
DbVersion = 34;
break;
case 34:
MigrateVersion34();
DbVersion = 35;
break;
case 35:
MigrateVersion35();
DbVersion = 36;
break;
case 36:
MigrateVersion36();
DbVersion = 37;
break;
case 37:
MigrateVersion37();
DbVersion = 38;
break;
case 38:
MigrateVersion38();
DbVersion = 39;
break;
case 39:
MigrateVersion39();
DbVersion = 40;
break;
case 40:
MigrateVersion40();
DbVersion = 41;
break;
case 41:
MigrateVersion41();
DbVersion = 42;
break;
case 42:
MigrateVersion42();
DbVersion = 43;
break;
case 43:
MigrateVersion43();
DbVersion = 44;
break;
case 44:
MigrateVersion44();
DbVersion = 45;
break;
case 45:
MigrateVersion45();
DbVersion = 46;
break;
case 46:
MigrateVersion46();
DbVersion = 47;
break;
case 47:
MigrateVersion47();
DbVersion = 48;
break;
case 48:
MigrateVersion48();
DbVersion = 49;
break;
case 49:
MigrateVersion49();
DbVersion = 50;
break;
case 50:
MigrateVersion50();
DbVersion = 51;
break;
case 51:
MigrateVersion51();
DbVersion = 52;
break;
case 52:
MigrateVersion52();
DbVersion = 53;
break;
case 53:
MigrateVersion53();
DbVersion = 54;
break;
case 54:
MigrateVersion54();
DbVersion = 55;
break;
case 55:
MigrateVersion55();
DbVersion = 56;
break;
case 56:
MigrateVersion56();
DbVersion = 57;
break;
case 57:
MigrateVersion57();
DbVersion = 58;
break;
case 58:
MigrateVersion58();
DbVersion = 59;
break;
case 59:
MigrateVersion59();
DbVersion = 60;
break;
case 60:
MigrateVersion60();
DbVersion = 61;
break;
//Above this are cases that the installer may encounter when migrating a pre-1.9 database
//Below this are cases that only apply to 1.9 and beyond
case 61:
if (MigrateVersion61()) { DbVersion = 62; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 62:
if (MigrateVersion62()) { DbVersion = 63; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 63:
if (MigrateVersion63()) { DbVersion = 64; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 64:
if (MigrateVersion64()) { DbVersion = 65; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 65:
if (MigrateVersion65()) { DbVersion = 66; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 66:
if (MigrateVersion66()) { DbVersion = 67; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 67:
if (MigrateVersion67()) { DbVersion = 68; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 68:
if (MigrateVersion68()) { DbVersion = 69; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 69:
if (MigrateVersion69()) { DbVersion = 70; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
// When migrating from 1.10 and earlier, we don't need to run any of the other migration steps because the DataPRO database that was installed already has the
// changes that they add; they are only needed when migrating from 2.0 or later because the 2.0 or later database was copied over the installed database.
// per JPL: after successfully running MigrateVersion70, DbVersion should be set to the latest version so that other migration steps do not run.
case 70:
if (MigrateVersion70(SetStatus, dbName)) { DbVersion = CURRENT_DB_VERSION; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 71:
if (MigrateVersion71()) { DbVersion = 72; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 72:
if (MigrateVersion72(SetStatus)) { DbVersion = 73; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 73:
if (MigrateVersion73()) { DbVersion = 74; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 74:
if (MigrateVersion74()) { DbVersion = 75; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 75:
if (MigrateVersion75()) { DbVersion = 76; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 76:
if (MigrateVersion76()) { DbVersion = 77; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 77:
if (MigrateVersion77()) { DbVersion = 78; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 78:
if (MigrateVersion78()) { DbVersion = 79; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 79:
if (MigrateVersion79()) { DbVersion = 80; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 80:
if (MigrateVersion80()) { DbVersion = 81; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 81:
if (MigrateVersion81()) { DbVersion = 82; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 82:
if (MigrateVersion82()) { DbVersion = 83; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 83:
if (MigrateVersion83(SetStatus, _targetDir, registryDataPROExe, applicationSettings)) { DbVersion = 84; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 84:
if (MigrateVersion84()) { DbVersion = 85; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 85:
if (MigrateVersion85()) { DbVersion = 86; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 86:
if (MigrateVersion86()) { DbVersion = 87; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 87:
if (MigrateVersion87(SetStatus, _previousDir, registryDataPROExe, applicationSettings, out result)) { DbVersion = 88; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 88:
if (MigrateVersion88(SetStatus, _previousDir, registryDataPROExe, applicationSettings)) { DbVersion = 89; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 89:
if (MigrateVersion89(SetStatus, _previousDir, registryDataPROExe, applicationSettings)) { DbVersion = 90; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 90:
if (MigrateVersion90()) { DbVersion = 91; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 91:
if (MigrateVersion91(SetStatus, _previousDir, registryDataPROExe, applicationSettings)) { DbVersion = 92; } else { throw new Exception("An error occurred while migrating database version " + DbVersion); }
break;
case 92:
if (MigrateVersion92()) { DbVersion = 93; }
else { throw new Exception($"An error occurred while migrating database version {DbVersion}"); }
break;
case 93:
if (MigrateVersion93()) { DbVersion = 94; }
else { throw new Exception($"An error occurred while migrating database version {DbVersion}"); }
break;
case 94:
if (MigrateVersion94()) { DbVersion = 95; }
else { throw new Exception($"An error occurred while migrating database version {DbVersion}"); }
break;
case 95:
if (MigrateVersion95()) { DbVersion = 96; }
else { throw new Exception($"An error occurred while migrating database version {DbVersion}"); }
break;
case 96:
if (MigrateVersion96()) { DbVersion = 97; }
else { throw new Exception($"An error occurred while migrating database version {DbVersion}"); }
break;
case 97:
if (MigrateVersion97(SetStatus)) { DbVersion = 98; }
else { throw new System.Data.VersionNotFoundException($"An error occurred while migrating database version {DbVersion}"); }
break;
case 98:
if (MigrateVersion98()) { DbVersion = 99; }
else { throw new System.Data.VersionNotFoundException($"An error occurred while migrating database version {DbVersion}"); }
break;
case 99:
if (MigrateVersion99(_targetDir)) { DbVersion = 100; }
else { throw new System.Data.VersionNotFoundException($"An error occurred while migrating database version {DbVersion}"); }
break;
default:
throw new NotSupportedException(
"DbOperations::UpgradeVersionsIfNeeded unknown db version: " + DbVersion);
}
}
}
catch (Exception ex)
{
throw new Exception("An error occurred while migrating database version " + DbVersion + ": " + ex.Message);
}
}
SetTransactionLogging(false);
return result;
}
public void Initialize(InitializationTypes initializationType, string targetDir)
{
try
{
log.Source = "DataPROInstaller";
var transactionName = string.Empty;
var scriptNames = new List<string>();
switch (initializationType)
{
case InitializationTypes.Aero:
transactionName = "TRANSACTION_AERO";
scriptNames.Add("dbo.Add_AeroRemarks.sql");
scriptNames.Add("dbo.TurnOffISOCodes.sql");
scriptNames.Add("dbo.SystemSettings_HideGraphsStep.sql");
scriptNames.Add("dbo.SystemSettings_HideISOExport.sql");
scriptNames.Add("dbo.SystemSettings_HideGroups.sql");
scriptNames.Add("dbo.SystemSettings_UseUTCTimeCSVExport.sql");
scriptNames.Add("dbo.SystemSettings_EnableClockSource.sql");
break;
case InitializationTypes.Crash:
transactionName = "TRANSACTION_CRASH";
scriptNames.Add("dbo.Add_CrashRemarks.sql");
break;
case InitializationTypes.TSRAIR:
transactionName = "TRANSACTION_TSRAIR";
scriptNames.Add("dbo.Add_TSRAIRRemarks.sql");
scriptNames.Add("dbo.Settings_TriggerCheckQuickmode.sql");
scriptNames.Add("dbo.TurnOffISOCodes.sql");
scriptNames.Add("dbo.SystemSettings_HideISOExport.sql");
scriptNames.Add("dbo.SystemSettings_UseUTCTimeCSVExport.sql");
scriptNames.Add("dbo.SystemSettings_EnableClockSource.sql");
break;
}
if (!InitializeDb(Convert.ToInt32(initializationType), transactionName, scriptNames, targetDir))
{
throw new Exception($"An error occurred while initializing database for {transactionName}");
}
}
catch (Exception ex)
{
throw new Exception("An error occurred while initializing database version " + DbVersion + ": " + ex.Message);
}
SetTransactionLogging(false);
}
private bool InitializeDb(int initializationTypeInt, string transactionName, List<string> scriptNames, string targetDir)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry($"Issuing BEGIN {transactionName}");
Transaction(cmd, "BEGIN", initializationTypeInt);
var initializationType = string.Empty;
switch (transactionName)
{
case "TRANSACTION_AERO":
initializationType = "AeroUser";
break;
case "TRANSACTION_CRASH":
initializationType = "CrashUser";
break;
case "TRANSACTION_TSRAIR":
initializationType = "TSRAIRUser";
break;
}
foreach (var scriptName in scriptNames)
{
ExecuteScript(scriptName, cmd, ScriptTypes.Initialization, initializationType);
}
log.WriteEntry($"Issuing COMMIT {transactionName}");
Transaction(cmd, "COMMIT", initializationTypeInt);
if (transactionName == "TRANSACTION_AERO")
{
//FB 44771 Temporarily disable until fix is ready
//return ImportInitializationSensors(targetDir);
}
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", initializationTypeInt);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool ImportInitializationSensors(string targetDir)
{
var success = false;
try
{
log.WriteEntry("Importing sensors");
//Run DataPRO with arguments so that sensors can be imported as part of the initialization of the database
var resultString = BatchCommandProcessor(targetDir);
log.WriteEntry($"resultString in ImportInitializationSensors = {resultString}");
if (resultString.Length == 0)
{
success = true;
}
else
{
MessageBox.Show(resultString, "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button2, MessageBoxOptions.DefaultDesktopOnly);
}
}
catch (Exception ex)
{
log.WriteEntry($"Error while importing initialization sensors: {ex.Message}");
success = false;
}
log.WriteEntry($"success = {success}");
return success;
}
private string BatchCommandProcessor(string targetDir)
{
var resultString = string.Empty;
const string SQLServerScriptsFolder = "SQL Server Scripts";
const string ImportSensorsBatchFileName = "ImportSensors.bat";
const string ImportsFolder = "DBInitializationImports";
const string AeroSensors = "Aero_DB_Phase_2_Complete_CAL_DATES_DataPROSensorDatabase.csv";
var batchFileName = Path.Combine(targetDir, SQLServerScriptsFolder, ImportSensorsBatchFileName);
log.WriteEntry($"batchFileName={batchFileName}");
var sensorImportFileName = Path.Combine(targetDir, ImportsFolder, AeroSensors);
log.WriteEntry($"sensorImportFileName={sensorImportFileName}");
_sb.Clear();
var process = new System.Diagnostics.Process()
{
StartInfo =
{
FileName = batchFileName,
Arguments = targetDir + " " + "\"" + sensorImportFileName + "\"",
LoadUserProfile = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
}
};
//* Set ONLY ONE handler here.
process.OutputDataReceived += new System.Diagnostics.DataReceivedEventHandler(OutputHandler);
//* Start process
process.Start();
//* Read one element asynchronously
process.BeginErrorReadLine();
//* Read the other one synchronously
var output = process.StandardOutput.ReadToEnd();
Console.WriteLine(output);
process.WaitForExit();
if (_sb.Length > 0)
{
resultString = _sb.ToString();
}
log.WriteEntry($"resultString in BatchCommandProcessor = {resultString}");
return resultString;
}
private static StringBuilder _sb = new StringBuilder();
static void OutputHandler(object sendingProcess, System.Diagnostics.DataReceivedEventArgs outLine)
{
if (outLine.Data != null)
{
if (string.IsNullOrWhiteSpace(outLine.Data))
{
_sb.Append(Environment.NewLine);
}
_sb.Append(outLine.Data);
}
}
private bool MigrateVersion81()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION82");
Transaction(cmd, "BEGIN", 82);
ExecuteScript("dbo.Create_sp_GroupAndTestGet81.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION82");
Transaction(cmd, "COMMIT", 82);
InsertIntoSqlVersionsTable(cmd, 82, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION82");
Transaction(cmd, "ROLLBACK", 82);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion69()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION70");
Transaction(cmd, "BEGIN", 70);
ExecuteScript("sp_DBImportSensorModel.StoredProcedure_70.sql", cmd);
ExecuteScript("sp_SensorModelsInsert.StoredProcedure_70.sql", cmd);
ExecuteScript("sp_SensorModelsUpdate.StoredProcedure_70.sql", cmd);
ExecuteScript("sp_SensorModelsUpdateInsert.StoredProcedure_70.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION70");
Transaction(cmd, "COMMIT", 70);
InsertIntoSqlVersionsTable(cmd, 70, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION70");
Transaction(cmd, "ROLLBACK", 70);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion68()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION68");
Transaction(cmd, "BEGIN", 68);
ExecuteScript("sp_TestSetupLockUpdate.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION68");
Transaction(cmd, "COMMIT", 68);
InsertIntoSqlVersionsTable(cmd, 69, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 68);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void Transaction(SqlCommand sqlcmd, string type, int version)
{
sqlcmd.CommandType = CommandType.Text;
sqlcmd.CommandText = type + " TRANSACTION MIGRATION" + version.ToString();
sqlcmd.ExecuteNonQuery();
}
private void ExecuteScriptCommand(SqlCommand sqlcmd, string commandString, string initializationType = null)
{
if (commandString.Trim() != "")
{
sqlcmd.CommandText = commandString;
if (initializationType != null)
{
sqlcmd.Parameters.Add(new SqlParameter("@InitializationType", SqlDbType.NVarChar, 255) { Value = initializationType });
}
sqlcmd.ExecuteNonQuery();
sqlcmd.Parameters.Clear();
}
}
private System.Diagnostics.EventLog log = new System.Diagnostics.EventLog();
private bool MigrateVersion64()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION65");
Transaction(cmd, "BEGIN", 65);
log.WriteEntry("Executing script: sp_TestChannelSettingsInsert_65_.sql");
var scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_TestChannelSettingsInsert_65.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Issuing COMMIT TRANSACTION65");
Transaction(cmd, "COMMIT", 65);
InsertIntoSqlVersionsTable(cmd, 65, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION65");
Transaction(cmd, "ROLLBACK", 65);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private void ExecuteScript(string script, SqlCommand cmd, ScriptTypes scriptType = ScriptTypes.Migration, string initializationType = null)
{
log.WriteEntry($"Executing script: {script}");
var scriptString = string.Empty;
switch (scriptType)
{
case ScriptTypes.Migration:
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString(script);
break;
case ScriptTypes.Initialization:
scriptString = DatabaseInitializationScripts.EmbeddedResource.GetString(script);
break;
}
ExecuteScriptCommand(cmd, scriptString, initializationType);
}
private bool MigrateVersion67()
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_DASChannels_DASId_INCLUDE] ON [dbo].[DASChannels]
(
[DASId] ASC
)
INCLUDE ( [ChannelIdx],
[SupportedBridges],
[SupportedExcitations],
[DASDisplayOrder],
[LocalOnly],
[SupportedDigitalInputModes],
[SupportedSquibFireModes],
[SupportedDigitalOutputModes],
[ModuleSerialNumber],
[ModuleArrayIndex])";
sql.ExecuteNonQuery();
sql.CommandText = @"CREATE NONCLUSTERED INDEX [_INDEX_DAS_DASId] ON [dbo].[DAS]
(
[DASId] ASC
);";
sql.ExecuteNonQuery();
sql.CommandText = @"CREATE NONCLUSTERED INDEX [_INDEX_TestSetups_TestSetupId] ON [dbo].[TestSetups]
(
[TestSetupId] ASC
);";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_TestObjectSensors_SensorId_TestObjectId] ON [dbo].[TestObjectSensors]
(
[SensorId] ASC,
[TestObjectId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_TestObjectSensors_TestObjectId_SensorId] ON [dbo].[TestObjectSensors]
(
[TestObjectId] ASC,
[SensorId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_TestObjectChannelSettings_SensorId_TestObjectId] ON [dbo].[TestObjectChannelSettings]
(
[SensorId] ASC,
[TestObjectId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_TestChannelSettings_TestSetupId_SensorId] ON [dbo].[TestChannelSettings]
(
[TestSetupId] ASC,
[SensorId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_SensorsAnalog_SerialNumber] ON [dbo].[SensorsAnalog]
(
[SerialNumber] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_Sensors_SensorType_SensorId] ON [dbo].[Sensors]
(
[SensorType] ASC,
[SensorId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_Sensors_SensorId_SensorType] ON [dbo].[Sensors]
(
[SensorId] ASC,
[SensorType] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_SensorCalibrationRecord_SensorCalibrationId] ON [dbo].[SensorCalibrationRecord]
(
[SensorCalibrationId] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_INDEX_TestSetups_TestSetupName] ON [dbo].[TestSetups]
(
[TestSetupName] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText = @"CREATE VIEW [dbo].[_dta_mv_8] WITH SCHEMABINDING
AS
SELECT [dbo].[TemplateChannels].[TemplateChannelId] as _col_1, [dbo].[TemplateChannels].[TestObjectNumber] as _col_2, [dbo].[TemplateChannels].[NameOfTheChannel] as _col_3, [dbo].[TemplateChannels].[LaboratoryChannelCode] as _col_4, [dbo].[TemplateChannels].[CustomerChannelCode] as _col_5, [dbo].[TemplateChannels].[Comments1] as _col_6, [dbo].[TemplateChannels].[Location] as _col_7, [dbo].[TemplateChannels].[Dimension] as _col_8, [dbo].[TemplateChannels].[Direction] as _col_9, [dbo].[TemplateChannels].[ChannelFrequencyClass] as _col_10, [dbo].[TemplateChannels].[Unit] as _col_11, [dbo].[TemplateChannels].[ReferenceSystem] as _col_12, [dbo].[TemplateChannels].[TransducerType] as _col_13, [dbo].[TemplateChannels].[TransducerId] as _col_14, [dbo].[TemplateChannels].[PreFilterType] as _col_15, [dbo].[TemplateChannels].[CutOffFrequency] as _col_16, [dbo].[TemplateChannels].[ChannelAmplitudeClass] as _col_17, [dbo].[TemplateChannels].[ReferenceChannel] as _col_18, [dbo].[TemplateChannels].[ReferenceChannelName] as _col_19, [dbo].[TemplateChannels].[DataSource] as _col_20, [dbo].[TemplateChannels].[DataStatus] as _col_21, [dbo].[TemplateChannels].[SamplingInterval] as _col_22, [dbo].[TemplateChannels].[BitResolution] as _col_23, [dbo].[TemplateChannels].[TimeOfFirstSample] as _col_24, [dbo].[TemplateChannels].[NumberOfSamples] as _col_25, [dbo].[TemplateChannels].[OffsetPostTest] as _col_26, [dbo].[TemplateChannels].[TransducerNaturalFrequency] as _col_27, [dbo].[TemplateChannels].[TransducerDampingRatio] as _col_28, [dbo].[TemplateChannels].[Comments] as _col_29, [dbo].[TemplateChannels].[FirstGlobalMaximumValue] as _col_30, [dbo].[TemplateChannels].[TimeOfMaximumValue] as _col_31, [dbo].[TemplateChannels].[FirstGlobalMinimumValue] as _col_32, [dbo].[TemplateChannels].[TimeOfMinimumValue] as _col_33, [dbo].[TemplateChannels].[StartOffsetInterval] as _col_34, [dbo].[TemplateChannels].[EndOffsetInterval] as _col_35, [dbo].[TemplateChannels].[Required] as _col_36, [dbo].[TemplateChannels].[LocalOnly] as _col_37, [dbo].[TemplateChannels].[MMEChannelId] as _col_38, [dbo].[TemplateChannels].[MMEChannelType] as _col_39, [dbo].[TemplateChannels].[TemplateId] as _col_40, [dbo].[TemplateChannels].[DisplayOrder] as _col_41, [dbo].[TestObjectTemplates].[TemplateName] as _col_42 FROM [dbo].[TestObjectTemplates], [dbo].[TemplateChannels] WHERE [dbo].[TestObjectTemplates].[TemplateId] = [dbo].[TemplateChannels].[TemplateId]
";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE UNIQUE CLUSTERED INDEX [_dta_index__dta_mv_8_c_6_788510188__K1] ON [dbo].[_dta_mv_8]
(
[_col_1] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText =
@"CREATE NONCLUSTERED INDEX [_dta_index__dta_mv_8_6_788510188__K40] ON [dbo].[_dta_mv_8]
(
[_col_40] ASC
)";
sql.ExecuteNonQuery();
sql.CommandText = @"DROP PROCEDURE [dbo].[sp_TestSetupsMarkIncomplete]";
sql.ExecuteNonQuery();
sql.CommandText = @"CREATE PROCEDURE [dbo].[sp_TestSetupsMarkIncomplete]
@SensorId int = null
, @SensorSerialNumber nvarchar(50) = null
, @Message nvarchar(255) = null
, @TestSetupId int = null
, @TestSetupName nvarchar(50) = null
, @errorNumber int output
, @errorMessage nvarchar(250) output
AS
BEGIN
set @errorNumber = 0
set @errorMessage = space(0)
begin try
if(@SensorSerialNumber is null)
begin
set @TestSetupId = [dbo].[foo_IdGetTestSetup](@TestSetupName)
update TestSetups SET Dirty=0, Complete=0 , ErrorMessage = isnull(@Message, ErrorMessage) where @TestSetupName is null or TestSetupId = @TestSetupId
end
else
begin
if(@SensorId is null)
begin
set @SensorId = [dbo].[foo_IdGetSensor](@SensorSerialNumber)
end
update TestSetups
set
Dirty = 0
, Complete = 0
, ErrorMessage = isnull(@Message, ErrorMessage)
from TestObjectSensors s inner join TestSetupObjects t ON s.TestObjectId = t.TestObjectId
inner join TestSetups ts on ts.TestSetupId = t.TestSetupId WHERE s.SensorId = @SensorId
end
end try
begin catch
set @errorMessage = error_message()
set @errorNumber = error_number()
end catch
END";
sql.ExecuteNonQuery();
InsertIntoSqlVersionsTable(sql, 68, 0);
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
return false;
}
finally
{
sql.Connection.Dispose();
}
}
return true;
}
//updates sp_SensorCalibrationsDelete for support.dtsweb.com/hc/requests/5507
//(sp_SensorCalibrationsDelete deleting multiple entries)
private bool MigrateVersion75()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION75");
Transaction(cmd, "BEGIN", 75);
ExecuteScript("dbo.Alter_sp_SensorsAnalogUpdateInsert_75.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION75");
Transaction(cmd, "COMMIT", 75);
InsertIntoSqlVersionsTable(cmd, 76, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 75);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion76()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION76");
Transaction(cmd, "BEGIN", 76);
ExecuteScript("dbo.Alter_SensorsSquib_Table_76.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsSquibGet_76.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsSquibUpdateInsert_76.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION76");
Transaction(cmd, "COMMIT", 76);
InsertIntoSqlVersionsTable(cmd, 77, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 76);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion77()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION77");
Transaction(cmd, "BEGIN", 77);
ExecuteScript("dbo.Alter_SensorsSquib_Table_77.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION77");
Transaction(cmd, "COMMIT", 77);
InsertIntoSqlVersionsTable(cmd, 78, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 77);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion78()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION78");
Transaction(cmd, "BEGIN", 78);
ExecuteScript("dbo.Add_ZeroMethod_ChannelSettings.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION78");
Transaction(cmd, "COMMIT", 78);
InsertIntoSqlVersionsTable(cmd, 79, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 78);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion79()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION79");
Transaction(cmd, "BEGIN", 79);
ExecuteScript("dbo.Migrate_ZeroMethod_Values.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION79");
Transaction(cmd, "COMMIT", 79);
InsertIntoSqlVersionsTable(cmd, 80, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 79);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion80()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION80");
Transaction(cmd, "BEGIN", 80);
ExecuteScript("dbo.Add_ClockSource_Settings.sql", cmd);
ExecuteScript("dbo.Alter_TestSetups_Table78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetups_Get_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetups_Insert_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetups_Update_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetups_InsertUpdate_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetups_UpdateInsert_78.sql", cmd);
ExecuteScript("dbo.Alter_TestSetupHardware_Table78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardware_Get_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardware_Insert_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardware_Update_78.sql", cmd);
ExecuteScript("dbo.Update_ChannelSettings.sql", cmd);
ExecuteScript("dbo.Add_PowerPro.sql", cmd);
ExecuteScript("dbo.Add_PowerPro_Settings.sql", cmd);
ExecuteScript("dbo.Add_IDList_Type.sql", cmd);
ExecuteScript("dbo.Add_sp_GroupsWithSensorsGet.sql", cmd);
ExecuteScript("dbo.Add_sp_TestSetupsWithSensorsGet.sql", cmd);
ExecuteScript("dbo.Update_SensorCalibrations_78.sql", cmd);
ExecuteScript("dbo.Update_SensorCalibrations_78_2.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorCalibrationsInsert_78.sql", cmd);
ExecuteScript("dbo.Update_UIItems_78.sql", cmd);
ExecuteScript("dbo.Migrate_InitialOffset.sql", cmd);
ExecuteScript("dbo.Migrate_UserValue123.sql", cmd);
//15390 Store the ZMO in EU in the DataPRO DB
ExecuteScript("dbo.Create_sp_SensorsAnalogZMODbGet.sql", cmd);
ExecuteScript("dbo.Create_SensorChangeType.sql", cmd);
ExecuteScript("dbo.Create_SensorChangeHistory.sql", cmd);
ExecuteScript("dbo.InsertIntoSensorChangeType_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsDelete_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsDeleteAll_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogDelete_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsDigitalInDelete_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsDigitalOutDelete_78.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsSquibDelete_78.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsChangeHistoryGet.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsChangeHistoryInsert.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsChangeHistoryDelete.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorChangeTypesGet.sql", cmd);
//FB 13120 Updating the database
ExecuteScript("dbo.Alter_SoftwareFilters_Table.sql", cmd);
ExecuteScript("dbo.Alter_sp_SoftwareFiltersGet.sql", cmd);
ExecuteScript("dbo.Alter_sp_SoftwareFiltersInsert.sql", cmd);
ExecuteScript("dbo.Alter_sp_SoftwareFiltersUpdate.sql", cmd);
ExecuteScript("dbo.UpdateData_FilterClass.sql", cmd);
ExecuteScript("dbo.UpdateData_SoftwareFilters.sql", cmd);
//FB 15523
ExecuteScript("dbo.DeleteData_ChannelSettings.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION80");
Transaction(cmd, "COMMIT", 80);
InsertIntoSqlVersionsTable(cmd, 81, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 80);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// Migrates version 82 to 83
/// 16290 Unhandled exception using push to test setup
/// corrects sp_GroupAndTestSetupGet
/// </summary>
/// <returns></returns>
private bool MigrateVersion82()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION83");
Transaction(cmd, "BEGIN", 83);
ExecuteScript("dbo.Alter_sp_GroupAndTestGet82.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION83");
Transaction(cmd, "COMMIT", 83);
InsertIntoSqlVersionsTable(cmd, 83, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION83");
Transaction(cmd, "ROLLBACK", 83);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
/// <summary>
/// migrates from version 83 to version 84 (3.0 to 3.1 DP)
/// </summary>
/// <returns></returns>
private bool MigrateVersion83(SetStatusDelegate SetStatus, string _targetDir, string registryDataPROExe, string applicationSettings)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION84");
Transaction(cmd, "BEGIN", 84);
ExecuteScript("dbo.Alter_SensorsAnalog_Table81.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogGet81.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogInsert81.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogInsertUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorCalibrationsGet81.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsAnalogUpdateCalibrationId.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorCalibrationsInsert81.sql", cmd);
ExecuteScript("dbo.Alter_DAS_Table81.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASGet81.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASInsert81.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASUpdateInsert81.sql", cmd);
ExecuteScript("dbo.Alter_Groups_Table81.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsGet81.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsInsert81.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsUpdateInsert81.sql", cmd);
ExecuteScript("dbo.Alter_TestSetups_Table81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsGet81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsert81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsertUpdate81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdateInsert81.sql", cmd);
ExecuteScript("dbo.Alter_TestSetupHardware_Table81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardwareGet81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardwareInsert81.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardwareUpdate81.sql", cmd);
ExecuteScript("dbo.Create_sp_DASFirstUseSet.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsAnalogFirstUseSet.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsDelete81.sql", cmd);
ExecuteScript("dbo.Create_sp_TestSetupsDeleteManyByDate.sql", cmd);
ExecuteScript("dbo.Create_sp_TestSetupsDeleteManyById.sql", cmd);
ExecuteScript("dbo.Create_sp_TestSetupsDeleteManyByName.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASChannelsGet.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupGroupsGet.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupHardwareGet.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION84");
Transaction(cmd, "COMMIT", 84);
MigrateChannelSettings(SetStatus);
MigrateTestSetupHardwareAAFRates(SetStatus, _targetDir, registryDataPROExe, applicationSettings);
InsertIntoSqlVersionsTable(cmd, 84, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 84);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 84 to version 85 (3.1 to later 3.1 DP)
/// </summary>
/// <returns></returns>
private bool MigrateVersion84()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION85");
Transaction(cmd, "BEGIN", 85);
ExecuteScript("dbo.Alter_sp_TestSetupsDeleteManyById_85.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsDeleteManyByName_85.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASInsert_85.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION85");
Transaction(cmd, "COMMIT", 85);
InsertIntoSqlVersionsTable(cmd, 85, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 85);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// gets all calibration entries which have is proportional = false but have sensitivity units of mVperVperEU
/// </summary>
/// <returns></returns>
private Tuple<int, string>[] GetCalibrationRecordsToUpdateSensitivityUnits()
{
var toUpdate = new List<Tuple<int, string>>();
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT [SensorCalibrationId],[CalibrationRecords] FROM [SensorCalibrations] where [IsProportional] = 0 AND [CalibrationRecords] like '%mVperVperEU%'";
var reader = cmd.ExecuteReader();
while (reader.Read())
{
try
{
var id = Convert.ToInt32(reader["SensorCalibrationId"]);
var s = (string)reader["CalibrationRecords"];
toUpdate.Add(new Tuple<int, string>(id, s));
}
catch (Exception ex)
{
log.WriteEntry(ex.Message);
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
}
finally
{
cmd.Connection.Dispose();
}
return toUpdate.ToArray();
}
}
/// <summary>
/// Updates all the given records by replacing mVperVperEU with mVperEU
/// </summary>
/// <param name="toUpdate"></param>
private void UpdateCalibrationSensitivityUnits(Tuple<int, string>[] toUpdate)
{
if (toUpdate.Any())
{
foreach (var entry in toUpdate)
{
using (var cmd = DbOperations.GetSQLCommand(true))
{
try
{
cmd.CommandText = "UPDATE [SensorCalibrations] SET [CalibrationRecords]=@1 WHERE [SensorCalibrationId]=@2";
var s = entry.Item2.Replace("mVperVperEU", "mVperEU");
cmd.Parameters.Add(new SqlParameter("@1", SqlDbType.NVarChar) { Value = s });
cmd.Parameters.Add(new SqlParameter("@2", SqlDbType.Int) { Value = entry.Item1 });
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
log.WriteEntry(ex.Message);
}
finally
{
cmd.Connection.Dispose();
}
}
}
}
}
private bool MigrateVersion86()
{
try
{
var toUpdate = GetCalibrationRecordsToUpdateSensitivityUnits();
if (null != toUpdate && toUpdate.Any())
{
UpdateCalibrationSensitivityUnits(toUpdate);
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION86");
Transaction(cmd, "BEGIN", 87);
ExecuteScript("dbo.Add_S6DB3.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION86");
Transaction(cmd, "COMMIT", 87);
InsertIntoSqlVersionsTable(cmd, 87, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry($"Throwing exception due to: {ex.Message}");
Transaction(cmd, "ROLLBACK", 87);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 85 to version 86 (3.1 to later 3.1 DP)
/// </summary>
/// <returns></returns>
private bool MigrateVersion85()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION85");
Transaction(cmd, "BEGIN", 86);
ExecuteScript("dbo.Update_PowerPro_Settings.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION85");
Transaction(cmd, "COMMIT", 86);
InsertIntoSqlVersionsTable(cmd, 86, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 86);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 87 to version 88
/// </summary>
/// <returns></returns>
private bool MigrateVersion87(SetStatusDelegate SetStatus, string _previousDir, string registryDataPROExe, string applicationSettings,
out MigrationResult result)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION88");
Transaction(cmd, "BEGIN", 88);
// FB16225: update diadem system settings from "channel description" or "channel comment" to "sensor serial number" or "channel name"
ExecuteScript("dbo.Update_Settings_Table84.sql", cmd);
//FB 16148 Added hardware type Slice Mini DB (SPM)
ExecuteScript("dbo.Add_SPM.sql", cmd);
//FB 16129 Implement TSR AIR in DataPRO Database
ExecuteScript("dbo.Add_DIR.sql", cmd);
ExecuteScript("dbo.Add_DKR.sql", cmd);
ExecuteScript("dbo.Add_TSR_Air.sql", cmd);
ExecuteScript("dbo.Add_TSR_Air_RevB.sql", cmd);
ExecuteScript("dbo.Update_Settings_Table84.sql", cmd);
ExecuteScript("dbo.Add_TSA_Embedded_Sensor.sql", cmd);
//FB 9812 Measure Squib Resistances step
//FB 16367 Multiple event recording mode support
ExecuteScript("dbo.Alter_TestSetups_Table86.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsDelete86.sql", cmd);
ExecuteScript("dbo.Add_MeasureSquibResistances_TSD.sql", cmd);
ExecuteScript("dbo.Add_TSRAIR_DefaultProperties.sql", cmd);
ExecuteScript("dbo.Add_S6DB.sql", cmd);
//3003 Attach Test History to Sensors
ExecuteScript("dbo.Add_TestHistory.sql", cmd);
ExecuteScript("dbo.Add_SensorTestHistory.sql", cmd);
ExecuteScript("dbo.SensorTestHistoryDelete.sql", cmd);
ExecuteScript("dbo.SensorTestHistoryGet.sql", cmd);
ExecuteScript("dbo.SensorTestHistoryUpdateInsert.sql", cmd);
ExecuteScript("dbo.TestHistoryDelete.sql", cmd);
ExecuteScript("dbo.TestHistoryGet.sql", cmd);
ExecuteScript("dbo.TestHistoryUpdateInsert.sql", cmd);
ExecuteScript("dbo.Alter_tbl_TestSetups_TestSetupUniqueId.sql", cmd);
//allow streaming modes
ExecuteScript("dbo.Add_AllowStreaming_DefaultProperty.sql", cmd);
ExecuteScript("dbo.Add_sp_DefaultPropertiesUpdateByName.sql", cmd);
ExecuteScript("dbo.AlterTestSetupsTSRAir.sql", cmd);
ExecuteScript("dbo.AlterTestSetupsWakeup.sql", cmd);
ExecuteScript("dbo.Alter_spTestSetupsGet87.sql", cmd);
ExecuteScript("dbo.Alter_spTestSetupsInsert87.sql", cmd);
ExecuteScript("dbo.Alter_spTestSetupsUpdate87.sql", cmd);
ExecuteScript("dbo.Alter_spTestSetupsUpdateInsert87.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASDelete87.sql", cmd);
ExecuteScript("dbo.Alter_spSensorsAnalogBridgeRes87.sql", cmd);
ExecuteScript("dbo.DeleteTDASRackModules.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION88");
Transaction(cmd, "COMMIT", 88);
result = MigrateStreamingConfigSetting(SetStatus, _previousDir, registryDataPROExe, applicationSettings);
InsertIntoSqlVersionsTable(cmd, 88, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 88);
result = MigrationResult.ExceptionThrown;
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 88 to version 89
/// </summary>
/// <returns></returns>
private bool MigrateVersion88(SetStatusDelegate SetStatus, string _previousDir, string registryDataPROExe, string applicationSettings)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION89");
Transaction(cmd, "BEGIN", 89);
ExecuteScript("dbo.Add_TSRAIR_Settings.sql", cmd);
ExecuteScript("dbo.Add_DIRDKR_Settings.sql", cmd);
ExecuteScript("dbo.Modify_foo_GetIdenticalChannelCount.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION89");
Transaction(cmd, "COMMIT", 89);
InsertIntoSqlVersionsTable(cmd, 89, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 89);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 89 to version 90
/// </summary>
/// <returns></returns>
private bool MigrateVersion89(SetStatusDelegate SetStatus, string _previousDir, string registryDataPROExe, string applicationSettings)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION90");
Transaction(cmd, "BEGIN", 90);
ExecuteScript("dbo.Add_OBRDDR_89.sql", cmd);
ExecuteScript("dbo.Add_MaxAAFRate.sql", cmd);
ExecuteScript("dbo.sp_DASGet_MaxAAFRate.sql", cmd);
ExecuteScript("dbo.sp_DASInsert_MaxAAFRate.sql", cmd);
ExecuteScript("dbo.sp_DASUpdate_MaxAAFRate.sql", cmd);
ExecuteScript("dbo.sp_DASUpdateInsert_MaxAAFRate.sql", cmd);
//Remove TSR AIR-related fields from TestSetups table
ExecuteScript("dbo.sp_TestSetups_DeleteLevelTriggers.sql", cmd);
ExecuteScript("dbo.sp_TestSetupsGet.sql", cmd);
ExecuteScript("dbo.sp_TestSetupsInsert.sql", cmd);
ExecuteScript("dbo.sp_TestSetupsInsertUpdate.sql", cmd);
ExecuteScript("dbo.sp_TestSetupsUpdate.sql", cmd);
ExecuteScript("dbo.sp_TestSetupsUpdateInsert.sql", cmd);
//More TSR AIR-related changes
ExecuteScript("Alter_TestSetups_TSRAIR_40.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsGet_TSRAIR.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsert_TSRAIR.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdate_TSRAIR.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdateInsert_TSRAIR.sql", cmd);
ExecuteScript("Update_TSRAIR_PowerSettings.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION90");
Transaction(cmd, "COMMIT", 90);
SetDASMaxAAFilterRates();
ChangeDefaultNumberOfEvents();
InsertIntoSqlVersionsTable(cmd, 90, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 90);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void ChangeDefaultNumberOfEvents()
{
const int DefaultNumberOfEventsId = 424;
//Set it to 1 to accommodate simplification of Recorder modes (FB 25463)
using (var cmd = DbOperations.GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DefaultPropertiesUpdate.ToString();
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = DefaultNumberOfEventsId });
cmd.Parameters.Add(new SqlParameter("@DefaultValue", SqlDbType.NVarChar) { Value = 1 });
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);
cmd.ExecuteNonQuery();
}
catch (Exception ex) { APILogger.Log("failed to update default setting, ", ex); }
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates from version 90to version 91
/// </summary>
/// <returns></returns>
private bool MigrateVersion90()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION91");
Transaction(cmd, "BEGIN", 91);
//Add UART-as-channels
ExecuteScript("dbo.Create_Table_UART_Sensors_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsUARTGet_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsUARTDelete_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsUARTInsert_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsUARTUpdate_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsUARTUpdateInsert_90.sql", cmd);
ExecuteScript("dbo.Add_UART_SensorType.sql", cmd);
ExecuteScript("dbo.Add_UART_ChannelSettings.sql", cmd);
ExecuteScript("dbo.Add_UART_TestSpecificSensor.sql", cmd);
ExecuteScript("dbo.Add_S6A_Prototype_UART_Channel.sql", cmd);
//Add StreamOutput-as-channels
ExecuteScript("dbo.Create_Table_StreamOutput_Sensors_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamOutputGet_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamOutputDelete_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamOutputInsert_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamOutputUpdate_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamOutputUpdateInsert_90.sql", cmd);
ExecuteScript("dbo.Add_StreamOutput_SensorType.sql", cmd);
ExecuteScript("dbo.Add_StreamOutput_ChannelSettings.sql", cmd);
ExecuteScript("dbo.Add_StreamOutput_TestSpecificSensor.sql", cmd);
ExecuteScript("dbo.Add_S6A_Prototype_StreamOutput_Channel.sql", cmd);
ExecuteScript("dbo.Add_TSRAIR_Prototype_StreamOutput_Channel.sql", cmd);
ExecuteScript("dbo.Update_DAS_S6AplusUARTandStreamOutput.sql", cmd);
ExecuteScript("dbo.Update_DAS_TSRAIRplusStreamOutput.sql", cmd);
//Add StreamInput-as-channels
ExecuteScript("dbo.Create_Table_StreamInput_Sensors_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamInputGet_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamInputDelete_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamInputInsert_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamInputUpdate_90.sql", cmd);
ExecuteScript("dbo.Create_sp_SensorsStreamInputUpdateInsert_90.sql", cmd);
ExecuteScript("dbo.Add_StreamInput_SensorType.sql", cmd);
ExecuteScript("dbo.Add_StreamInput_ChannelSettings.sql", cmd);
ExecuteScript("dbo.Add_StreamInput_TestSpecificSensor.sql", cmd);
ExecuteScript("dbo.Add_S6A_ER_Prototype_StreamInput_Channel.sql", cmd);
ExecuteScript("dbo.Update_DAS_S6AERplusStreamInput.sql", cmd);
//http://manuscript.dts.local/f/cases/21227/sp_DeleteAll-may-delete-test-specific-sensors-which-aren-t-desired-to-be-deleted
ExecuteScript("dbo.Alter_sp_SensorsDeleteAll_90.sql", cmd);
//18294 Implement Bridge AC / DC coupling(fw update dependent)
ExecuteScript("dbo.Alter_SensorsAnalog_90.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogGet_90.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogInsert_90.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogUpdate_90.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorsAnalogUpdateInsert_90.sql", cmd);
//24429 sp_TagsDelete fails when there are tag assignments with the tag in existance
ExecuteScript("dbo.Alter_sp_TagsDelete_90.sql", cmd);
//25567 sp_DASInsert lets you insert duplicates
ExecuteScript("dbo.Alter_sp_DASUpdateInsert_90.sql", cmd);
ExecuteScript("dbo.Alter_sp_DASInsert_90.sql", cmd);
//25682 Stored procedure for Channel delete should probably delete any linked level triggers
ExecuteScript("dbo.Alter_sp_ChannelsDelete_90.sql", cmd);
//25460 Add SLICE PRO Distributor in db, but not yet in DataPRO UI, to avoid migration step later
ExecuteScript("dbo.Add_SLICE_PRO_Distributor_Prototype.sql", cmd);
ExecuteScript("dbo.Add_SLICE_PRO_Distributor_PowerSettings.sql", cmd);
//26856 LTS infrastructure
ExecuteScript("dbo.LTS_Create_Table_StoredProcedureVersions.sql", cmd);
ExecuteScript("dbo.LTS_Create_sp_StoredProcedureVersionsGet.sql", cmd);
//25599 DataPRO Shouldn't Warn User if pulling/pushing to test setup because of first two characters of the iso code
ExecuteScript("dbo.Alter_foo_GetIdenticalChannelCount.sql", cmd);
//28281 Add SLICE6 Falcon prototype to database, but not yet in DataPRO UI, to avoid migration step later
ExecuteScript("dbo.Add_Falcon_Prototype.sql", cmd);
ExecuteScript("dbo.Add_Falcon_Prototype_DAS_Channels.sql", cmd);
//28282 Add SLICE6 Falcon power settings to database, but not yet in DataPRO UI, to avoid migration step later
ExecuteScript("dbo.Add_Falcon_PowerSettings.sql", cmd);
//28245 Change default stream profile from "Ch10 Manual config" to "Ch10 128bit PCM Time Format 2" to match default TMAT file
ExecuteScript("dbo.Update_DefaultUDPStreamProfile.sql", cmd);
//28242 Change default AAF for SLICE products to 3k Hz
ExecuteScript("dbo.Update_Table_Settings_90.sql", cmd);
//17854 Add primary keys to the LastUsedHardware, Settings, and UIItemSettings tables so that they will be included in a
//comparison of data by Visual Studio's Tools | SQL Server | New Data Comparison feature.
ExecuteScript("dbo.Alter_LastUsedHardware_90_Add_ID.sql", cmd);
ExecuteScript("dbo.Alter_LastUsedHardware_90_Set_ID_PrimaryKey.sql", cmd);
ExecuteScript("dbo.Alter_Settings_90_Add_ID.sql", cmd);
ExecuteScript("dbo.Alter_Settings_90_Set_ID_PrimaryKey.sql", cmd);
ExecuteScript("dbo.Alter_UIItemSettings_90_Add_ID.sql", cmd);
ExecuteScript("dbo.Alter_UIItemSettings_90_Set_ID_PrimaryKey.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION91");
Transaction(cmd, "COMMIT", 91);
InsertIntoSqlVersionsTable(cmd, 91, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 91);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates from version 91 to version 92
/// </summary>
/// <returns></returns>
private bool MigrateVersion91(SetStatusDelegate SetStatus, string previousDir, string registryDataPROExe, string applicationSettings)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION921");
Transaction(cmd, "BEGIN", 921);
ExecuteScript("Alter_sp_TestSetupsInsert_1PPSOut.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_1PPSOut.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_1PPSOut.sql", cmd);
ExecuteScript("Add_sp_TestSetupsInsert_92.sql", cmd);
ExecuteScript("Add_sp_TestSetupsUpdate_92.sql", cmd);
ExecuteScript("Add_sp_TestSetupsInsertUpdate_92.sql", cmd);
ExecuteScript("Add_sp_TestSetupsUpdateInsert_92.sql", cmd);
ExecuteScript("Add_sp_TestSetupsGet_92.sql", cmd);
ExecuteScript("Insert_StoredProcedureVersions_TestSetups_92.sql", cmd);
//29758 Set TSR AIR Min and Max Sample Rates (100, 20000)
ExecuteScript("dbo.Update_DAS_TSRAIR_MinMaxSampleRate.sql", cmd);
//29769 Add UART and StreamOut channels for any SLICE6Air being migrated
//These scripts check for ChannelTypes = '0,0,0,0,0,0' because that's the case where a SLICE6Air
//has not already been rediscovered in 4.0 (which would result in '0,0,0,0,0,0,5,6').
ExecuteScript("dbo.Add_S6A_UART_Channel.sql", cmd);
ExecuteScript("dbo.Add_S6A_StreamOutput_Channel.sql", cmd);
//Ensure that this script run after the ones above, since it will set the ChannelTypes to '0,0,0,0,0,0,5,6'
ExecuteScript("dbo.Update_DAS_S6A_ChannelTypes.sql", cmd);
//29898 Change RegionsOfInterest field in TestSetups table to multiple tables - part 1
ExecuteScript("TestSetupROIs.sql", cmd);
ExecuteScript("ROIPeriodChannels.sql", cmd);
ExecuteScript("Add_sp_ROIPeriodChannelsInsert.sql", cmd);
ExecuteScript("Add_sp_ROIPeriodChannelsGet.sql", cmd);
ExecuteScript("Add_sp_TestSetupROIsDelete.sql", cmd);
ExecuteScript("Add_sp_TestSetupROIsInsert.sql", cmd);
ExecuteScript("Add_sp_TestSetupROIsGet.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION921");
Transaction(cmd, "COMMIT", 921);
//29865 Migrate RegionsOfInterest field into TestSetupROIs and ROIPeriodChannels tables
log.WriteEntry("Calling MigrateROIToTables");
MigrateROIToTables(SetStatus);
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 921);
return false;
}
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION922");
Transaction(cmd, "BEGIN", 922);
//29898 Change RegionsOfInterest field in TestSetups table to multiple tables - part 2
ExecuteScript("Alter_TestSetups_RemoveRegionsOfInterest.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsDelete_92.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsDeleteManyByDate_92.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsDeleteManyById_92.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsDeleteManyByName_92.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsAndGroupsDeleteAll_92.sql", cmd);
ExecuteScript("Add_dbo.foo_RegionsOfInterestString.sql", cmd);
ExecuteScript("Add_dbo.foo_ROIStringToValueString.sql", cmd);
ExecuteScript("Add_dbo.sp_StringToRegionsOfInterestTables.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_92_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsertUpdate_92_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_92_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdateInsert_92_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_92_ROI.sql", cmd);
//29830 Add RepeatAutoArmOrStreaming field to TestSetups table
ExecuteScript("Alter_TestSetups_Add_RepeatAutoArmOrStreaming.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_92_EnableRepeat.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_92_EnableRepeat.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdateInsert_92_EnableRepeat.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsertUpdate_92_EnableRepeat.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_92_EnableRepeat.sql", cmd);
//29835 Add IgnoreShortedStart and IgnoreShortedTrigger to TestSetups table
ExecuteScript("Alter_TestSetups_Add_IgnoreShortedStartAndTrigger.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_92_IgnoreShorted.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_92_IgnoreShorted.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdateInsert_92_IgnoreShorted.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsertUpdate_92_IgnoreShorted.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_92_IgnoreShorted.sql", cmd);
ExecuteScript("Add_sp_DefaultPropertiesInsert.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_ROI.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_ROI.sql", cmd);
//29760 Implement ACCoupleEnable for TSR AIR
ExecuteScript("Add_sp_ChannelSettingsGet_92.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_92.sql", cmd);
ExecuteScript("Insert_ChannelSetting_ACCoupling_92.sql", cmd);
ExecuteScript("Update_StoredProcedureVersions_ACCoupling_92.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION922");
Transaction(cmd, "COMMIT", 922);
//Combine these with MigrateROIToTables() if possible
MigrateDefaultAutoArmRepeatEnableToTestSetups(SetStatus);
MigrateConfigIgnoreShortedToTestSetups(SetStatus, previousDir, registryDataPROExe, applicationSettings);
InsertIntoSqlVersionsTable(cmd, 92, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 922);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// migrates a database from version 92 to version 93 (adds stream output changes for
/// </summary>
/// <returns></returns>
private bool MigrateVersion92()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION93");
Transaction(cmd, "BEGIN", 93);
ExecuteScript("Alter_sp_SensorsStreamOutput_93.sql", cmd);
ExecuteScript("Add_sp_SensorsStreamOutputGet_93.sql", cmd);
ExecuteScript("Add_sp_SensorsStreamOutputInsert_93.sql", cmd);
ExecuteScript("Add_sp_SensorsStreamOutputUpdate_93.sql", cmd);
ExecuteScript("Add_sp_SensorsStreamOutputUpdateInsert_93.sql", cmd);
//30249 Add LTS behavior for case 30075 (ADC UART stream)
ExecuteScript("Add_sp_GroupChannelSettingsGet_93.sql", cmd);
ExecuteScript("Add_sp_GroupChannelSettingsInsert_93.sql", cmd);
ExecuteScript("Add_sp_GroupChannelSettingsUpdate_93.sql", cmd);
ExecuteScript("Add_sp_GroupChannelSettingsUpdateInsert_93.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsGet.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsInsert.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsUpdate.sql", cmd);
ExecuteScript("Alter_sp_SensorsStreamOutputGet.sql", cmd);
ExecuteScript("Alter_sp_SensorsStreamOutputInsert.sql", cmd);
ExecuteScript("Alter_sp_SensorsStreamOutputUpdate.sql", cmd);
ExecuteScript("Insert_ChannelSettings_93.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_93.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_92_93.sql", cmd);
ExecuteScript("Add_sp_ChannelSettingsGet_93_93.sql", cmd);
//36831 Keep ImportCreateDynamicGroups and CSVImportCreateDynamicGroups settings in sync
ExecuteScript("Alter_sp_SettingsUpdateInsert_ImportCreateDynamicGroups.sql", cmd);
ExecuteScript("Update_StoredProcecures_93.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION93");
Transaction(cmd, "COMMIT", 93);
InsertIntoSqlVersionsTable(cmd, 93, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 93);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates a database from version 93 to version 94 (updates TSR AIR power settings)
/// </summary>
/// <returns></returns>
private bool MigrateVersion93()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION94");
Transaction(cmd, "BEGIN", 94);
ExecuteScript("Update_TSRAIR_PowerSettings_94.sql", cmd);
ExecuteScript("Update_TSRAIR_WakeUpMotionTimeout_94.sql", cmd);
//31810 Add these columns/keys if they weren't added in MigrateVersion90() because
//a database had been previously migrated through Version 90 before the
//corresponding scripts had been implemented in MigrateVersion 90().
ExecuteScript("Conditionally_Alter_LastUsedHardware_90_Add_ID.sql", cmd);
ExecuteScript("Conditionally_Alter_LastUsedHardware_90_Set_ID_PrimaryKey.sql", cmd);
ExecuteScript("Conditionally_Alter_Settings_90_Add_ID.sql", cmd);
ExecuteScript("Conditionally_Alter_Settings_90_Set_ID_PrimaryKey.sql", cmd);
ExecuteScript("Conditionally_Alter_UIItemSettings_90_Add_ID.sql", cmd);
ExecuteScript("Conditionally_Alter_UIItemSettings_90_Set_ID_PrimaryKey.sql", cmd);
//36831 Keep ImportCreateDynamicGroups and CSVImportCreateDynamicGroups settings in sync
ExecuteScript("Alter_sp_SettingsUpdateInsert_ImportCreateDynamicGroups.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION94");
Transaction(cmd, "COMMIT", 94);
InsertIntoSqlVersionsTable(cmd, 94, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 94);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates a database from version 94 to version 95 (v4.1, S6A-BR/Falcon, etc.)
/// </summary>
/// <returns></returns>
private bool MigrateVersion94()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION95");
Transaction(cmd, "BEGIN", 95);
//PTP Domain ID pt 1
ExecuteScript("Alter_tbl_TestSetupsHardware_Add_PTPDomainID_95.sql", cmd);
//S6A-BR
ExecuteScript("Update_DAS_S6Falcon_95.sql", cmd);
ExecuteScript("Delete_DASChannels_S6Falcon_95.sql", cmd);
ExecuteScript("Update_DASChannels_S6Falcon_95.sql", cmd);
ExecuteScript("Add_sp_DASGet_95_95.sql", cmd); //S6A-BR & PTP Domain ID
ExecuteScript("Add_sp_TestSetupHardwareGet_95_95.sql", cmd);
ExecuteScript("Alter_sp_DASGet_95.sql", cmd);
ExecuteScript("Alter_sp_TestSetupHardwareGet_95.sql", cmd);
//TSRAIR UART
ExecuteScript("Update_DAS_TSRAIR_Prototype_UART_95.sql", cmd);
ExecuteScript("Add_DASChannels_TSRAIR_Prototype_UART_95.sql", cmd);
ExecuteScript("Update_DASChannels_TSRAIR_Prototype_95.sql", cmd);
//PTP Domain ID pt 2
ExecuteScript("Add_sp_TestSetupHardwareInsert_95_95.sql", cmd);
ExecuteScript("Add_sp_TestSetupHardwareUpdate_95_95.sql", cmd);
//31738 Improve performance by making less database calls
ExecuteScript("Add_StringList_Type_95.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsGet_95.sql", cmd);
//33415 Voltage insertion channel should be half bridge
ExecuteScript("Insert_BridgeType_ChannelSetting_95.sql", cmd);
//33415 omissions
ExecuteScript("Alter_sp_ChannelSettingsGet_92_95.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_93_95.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_95.sql", cmd);
ExecuteScript("Create_sp_ChannelSettingsGet_93_95.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsGet_93_95.sql", cmd);
ExecuteScript("Alter_sp_GroupChannelSettingsGet_95_BridgeType.sql", cmd);
//36831 Keep ImportCreateDynamicGroups and CSVImportCreateDynamicGroups settings in sync
ExecuteScript("Alter_sp_SettingsUpdateInsert_ImportCreateDynamicGroups.sql", cmd);
//36833 If any StreamOutput sensor already has an advanced Stream Profile, add (if non-existent)
// or update, DefaultUseAdvancedUDPStreamProfiles = True, to DefaultProperties table, and
// set corresponding value to True for all Users in UserProperties table.
ExecuteScript("Set_DefaultUseAdvancedUDPStreamProfilesToTrue.sql", cmd);
ExecuteScript("Update_StoredProcedures_95.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION95");
Transaction(cmd, "COMMIT", 95);
InsertIntoSqlVersionsTable(cmd, 95, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 95);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates a database from version 95 to version 96 (v4.2+, Multiple-event w/UART, etc.)
/// </summary>
/// <returns></returns>
private bool MigrateVersion95()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION96");
Transaction(cmd, "BEGIN", 96);
// Multiple-event w/UART recording modes
ExecuteScript("Alter_sp_TestSetupsGet_92_96.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet_96.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_92_96.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsInsert_96.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_92_96.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsUpdate_96.sql", cmd);
ExecuteScript("Create_sp_TestSetupsGet_96_96.sql", cmd);
ExecuteScript("Create_sp_TestSetupsInsert_96_96.sql", cmd);
ExecuteScript("Create_sp_TestSetupsUpdate_96_96.sql", cmd);
ExecuteScript("Create_sp_TestSetupsInsertUpdate_96_96.sql", cmd);
ExecuteScript("Create_sp_TestSetupsUpdateInsert_96_96.sql", cmd);
//TSRAIRUser values
ExecuteScript("dbo.UserProperties_DownloadAll.sql", cmd);
ExecuteScript("dbo.UserProperties_ViewAll.sql", cmd);
ExecuteScript("dbo.UserProperties_Export.sql", cmd);
ExecuteScript("dbo.UserProperties_ExportCSVUnfiltered.sql", cmd);
//36831 Keep ImportCreateDynamicGroups and CSVImportCreateDynamicGroups settings in sync
ExecuteScript("Alter_sp_SettingsUpdateInsert_ImportCreateDynamicGroups.sql", cmd);
//36833 If any StreamOutput sensor already has an advanced Stream Profile, add (if non-existent)
// or update, DefaultUseAdvancedUDPStreamProfiles = True, to DefaultProperties table, and
// set corresponding value to True for all Users in UserProperties table.
ExecuteScript("Set_DefaultUseAdvancedUDPStreamProfilesToTrue.sql", cmd);
//39285 Change S6A-BR voltage defaults
ExecuteScript("Update_S6A-BR_Power_Settings.sql", cmd);
ExecuteScript("Update_StoredProcedures_96.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION96");
Transaction(cmd, "COMMIT", 96);
InsertIntoSqlVersionsTable(cmd, 96, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 96);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates a database from version 95 to version 96 (v4.2+, Multiple-event w/UART, etc.)
/// </summary>
/// <returns></returns>
private bool MigrateVersion96()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION97");
Transaction(cmd, "BEGIN", 97);
ExecuteScript("Alter_sp_TestSetupsGet_97.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet92_97.sql", cmd);
ExecuteScript("Alter_sp_TestSetupsGet96_97.sql", cmd);
ExecuteScript("Create_sp_TestSetupsGet97_97.sql", cmd);
ExecuteScript("Update_StoredProcedures_97.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION97");
Transaction(cmd, "COMMIT", 97);
InsertIntoSqlVersionsTable(cmd, 97, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 97);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
/// <summary>
/// migrates a database from version 95 to version 96 (v4.2+, Multiple-event w/UART, etc.)
/// </summary>
/// <returns></returns>
private bool MigrateVersion97(SetStatusDelegate SetStatus)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION98");
Transaction(cmd, "BEGIN", 98);
ExecuteScript("CreateDiagnosticRuns_98.sql", cmd);
ExecuteScript("CreateAnalogDiagnostics_98.sql", cmd);
ExecuteScript("Create_spDiagRunUpdateInsert.sql", cmd);
ExecuteScript("Create_spAnalogDiagUpdateInsert.sql", cmd);
ExecuteScript("Create_spAnalogDiagGet.sql", cmd);
ExecuteScript("Create_spDiagnosticRunsGet.sql", cmd);
ExecuteScript("Conditionally_Alter_ROIPeriodChannels_Add_ChannelId_98.sql", cmd);
ExecuteScript("Conditionally_Alter_ROIPeriodChannels_Add_Constraint_98.sql", cmd);
ExecuteScript("Conditionally_Alter_ROIPeriodChannels_Check_Constraint_98.sql", cmd);
ExecuteScript("Add_sp_ChannelsDelete_98.sql", cmd);
ExecuteScript("Add_sp_ROIPeriodChannelsGet_98.sql", cmd);
ExecuteScript("Add_sp_ROIPeriodChannelsInsert_98.sql", cmd);
MigrateAllTestSetupROIs(cmd, SetStatus);
ExecuteScript("Alter_SensorsAnalog_98.sql", cmd);
ExecuteScript("Alter_sp_SensorsAnalogGet_98.sql", cmd);
ExecuteScript("Create_sp_SensorsAnalogInsert_98.sql", cmd);
ExecuteScript("Create_sp_SensorsAnalogUpdate_98.sql", cmd);
ExecuteScript("Create_sp_SensorsAnalogUpdateInsert_98.sql", cmd);
ExecuteScript("Create_sp_SensorsAnalogUsageCountUpdate_98.sql", cmd);
ExecuteScript("Create_sp_SensorsAnalogAssemblyUsageCountUpdate_98.sql", cmd);
ExecuteScript("Alter_SensorCalibrations_98.sql", cmd);
ExecuteScript("Alter_sp_SensorCalibrationsGet_98.sql", cmd);
ExecuteScript("Create_sp_SensorCalibrationsInsert_98.sql", cmd);
ExecuteScript("Create_sp_SensorCalibrationsUpdate_98.sql", cmd);
ExecuteScript("Create_sp_SensorCalibrationsSensitivityInspectionSet.sql", cmd);
ExecuteScript("Create_sp_SensorCalibrationsUsageCountUpdate.sql", cmd);
//http://manuscript.dts.local/f/cases/39470/Add-UI-for-configurable-option-to-allow-UDP-aligning-to-PPS
ExecuteScript("ALTER_TesetSetups_98.sql", cmd);
ExecuteScript("Create_spTestSetupsGet_98.sql", cmd);
ExecuteScript("Create_spTestSetupsUpdate_98.sql", cmd);
ExecuteScript("Create_spTestSetupsUpdateInsert_98.sql", cmd);
ExecuteScript("Create_spTestSetupsInsert_98.sql", cmd);
ExecuteScript("RemoveUnusedSP.sql", cmd);
ExecuteScript("RepairFalconPrototype.sql", cmd);
ExecuteScript("Update_StoredProcedures_98.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION98");
Transaction(cmd, "COMMIT", 98);
InsertIntoSqlVersionsTable(cmd, 98, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry($"Throwing exception due to: {ex.Message}");
Transaction(cmd, "ROLLBACK", 98);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
private void MigrateAllTestSetupROIs(SqlCommand cmd, SetStatusDelegate SetStatus)
{
var cmdText = $"SELECT DISTINCT TestSetupId FROM TestSetupROIs";
cmd.CommandText = cmdText;
var testSetupIdList = new List<Int32>();
using (var ds = Connection.QueryDataSet(cmd))
{
foreach (var row in ds.Tables[0].Rows)
{
testSetupIdList.Add(Convert.ToInt32((row as DataRow).ItemArray[0]));
}
}
var testSetupCount = 0;
foreach (var testSetupId in testSetupIdList)
{
testSetupCount++;
cmdText = $"SELECT TestSetupName FROM TestSetups WHERE TestSetupId = {testSetupId}";
cmd.CommandText = cmdText;
var testSetupName = string.Empty;
using (var ds = Connection.QueryDataSet(cmd))
{
//There should only be 1
testSetupName = Convert.ToString(ds.Tables[0].Rows[0].ItemArray[0]);
}
MigrateChannelNamesToChannelIds(cmd, testSetupId, true, SetStatus, testSetupCount, testSetupIdList.Count, testSetupName);
}
}
public static List<Dictionary<long, string>> MigrateChannelNamesToChannelIds(SqlCommand cmd,
int testSetupId,
bool storeInDb,
SetStatusDelegate SetStatus = null,
int testSetupCount = 1,
int testSetupIdListCount = 1,
string testSetupName = "")
{
var IdNameList = new List<Dictionary<long, string>>();
//Process one ROI at a time because the same channel may be in more than one
var cmdText = $"SELECT TestSetupROIId FROM TestSetupROIs WHERE TestSetupId = '{testSetupId}'";
cmd.CommandText = cmdText;
var testSetupROIList = new List<Int64>();
using (var ds = Connection.QueryDataSet(cmd))
{
foreach (var row in ds.Tables[0].Rows)
{
var testSetupROI = row as DataRow;
testSetupROIList.Add(Convert.ToInt64(testSetupROI.ItemArray[0]));
}
}
foreach (var testSetupROIId in testSetupROIList)
{
var channelIdAndNameDict = new Dictionary<long, string>();
//Get all of the channel names in this ROI and find their corresponding ID
cmdText = $"SELECT ChannelName FROM ROIPeriodChannels WHERE TestSetupROIId = {testSetupROIId}";
cmd.CommandText = cmdText;
var channelNameList = new List<string>();
using (var ds = Connection.QueryDataSet(cmd))
{
foreach (var row in ds.Tables[0].Rows)
{
var channelNameRow = row as DataRow;
channelNameList.Add(Convert.ToString(channelNameRow.ItemArray[0]));
}
}
var channelNameCount = 0;
foreach (var channelName in channelNameList)
{
channelNameCount++;
if (SetStatus != null)
{
SetStatus($"Migrating {testSetupCount} of {testSetupIdListCount} Test Setups and {channelNameCount} of {channelNameList.Count} channels ({testSetupName}/{channelName.Trim('\\')}");
}
var sensorNotFound = false;
var backslashIndex = channelName.Replace("Assigned by ID", "").Trim().LastIndexOf("\\");
var sensorSerialNumber = channelName.Substring(backslashIndex + 1);
//Get the sensor's ID
cmdText = $"SELECT id FROM Sensors WHERE SerialNumber = '{sensorSerialNumber}'";
cmd.CommandText = cmdText;
var sensorId = -1;
using (var ds = Connection.QueryDataSet(cmd))
{
//There should only be 1 (or none if the sensor doesn't exist)
if ((ds.Tables[0].Rows == null) || (ds.Tables[0].Rows.Count == 0))
{
sensorNotFound = true; //skip this one
}
else
{
sensorId = Convert.ToInt32(ds.Tables[0].Rows[0].ItemArray[0]);
}
}
if (sensorNotFound) continue;
cmdText = $"SELECT GroupId FROM TestSetupGroups WHERE TestSetupId = '{testSetupId}'";
cmd.CommandText = cmdText;
var groupIdList = new List<Int32>();
using (var ds = Connection.QueryDataSet(cmd))
{
foreach (var row in ds.Tables[0].Rows)
{
var groupIdRow = row as DataRow;
groupIdList.Add(Convert.ToInt32(groupIdRow.ItemArray[0]));
}
}
foreach (var groupId in groupIdList)
{
if (backslashIndex == 0)
{
cmdText = $"SELECT Id FROM Channels WHERE GroupId = {groupId} AND SensorId = {sensorId} AND DASId IS NULL";
}
else
{
var dasSerialNumberStart = channelName.Contains(':')
? channelName.IndexOf(':') + 1
: channelName.IndexOf('[') + 1;
var dasSerialNumberLength = channelName.LastIndexOf(']') - dasSerialNumberStart;
var dasSerialNumber = channelName.Substring(dasSerialNumberStart, dasSerialNumberLength);
cmdText = $"SELECT DASId FROM DAS where SerialNumber = '{dasSerialNumber}'";
cmd.CommandText = cmdText;
var dasId = -1;
var dasNotFound = false;
using (var ds = Connection.QueryDataSet(cmd))
{
if ((ds.Tables[0].Rows == null) || (ds.Tables[0].Rows.Count == 0))
{
dasNotFound = true;
}
else
{
//There should only be 1
dasId = Convert.ToInt32(ds.Tables[0].Rows[0].ItemArray[0]);
}
}
if (dasNotFound)
{
cmdText = $"SELECT Id FROM Channels WHERE GroupId = {groupId} AND SensorId = {sensorId}";
}
else
{
var dasChannelIndexStart = channelName.IndexOf('-') + 1;
var dasChannelIndex = -1;
if (channelName.Substring(dasChannelIndexStart - 3, 2) == "SQ")
{
dasChannelIndex = (Convert.ToInt32(channelName.Substring(dasChannelIndexStart, 2)) * 2) - 2; //0-relative
}
else
{
dasChannelIndex = Convert.ToInt32(channelName.Substring(dasChannelIndexStart, 2)) - 1; //0-relative
}
cmdText = $"SELECT Id FROM Channels WHERE GroupId = '{groupId}' AND DASId = '{dasId}' AND DASChannelIndex = {dasChannelIndex} AND SensorId = {sensorId}";
}
}
cmd.CommandText = cmdText;
var channelIdList = new List<Int64>();
using (var ds = Connection.QueryDataSet(cmd))
{
//There may be more than one. Some may have already been stored in ChannelID,
//and some may not be in the ROIPeriodChannels table at all.
foreach (var row in ds.Tables[0].Rows)
{
var channelIdRow = row as DataRow;
channelIdList.Add(Convert.ToInt32(channelIdRow.ItemArray[0]));
}
}
if (storeInDb)
{
//There may be more than one channel that can be assigned to this ROI
foreach (var channelId in channelIdList)
{
cmdText = $"SELECT TOP 1 ROIPeriodChannelId FROM ROIPeriodChannels WHERE TestSetupROIId = {testSetupROIId} AND ChannelName = '{channelName}' AND ChannelId IS NULL";
cmd.CommandText = cmdText;
Int64 roiPeriodChannelId = 0;
using (var ds = Connection.QueryDataSet(cmd))
{
if ((ds.Tables[0].Rows == null) || (ds.Tables[0].Rows.Count == 0))
{
//We need to do an Insert
//cmdText = $"INSERT INTO ROIPeriodChannels SET TestSetupROIId = {testSetupROIId}, ChannelName = '{channelName}', ChannelID = {channelId}";
cmdText = $"INSERT INTO ROIPeriodChannels(TestSetupROIId, ChannelName, ChannelID) VALUES({ testSetupROIId}, '{channelName}', { channelId})";
Connection.ExecuteScriptCommand(cmd, cmdText);
}
else
{
//Get the first ROIPeriodChannelId, and do an UPDATE; this works if there is 1 or more than 1
roiPeriodChannelId = Convert.ToInt64(ds.Tables[0].Rows[0].ItemArray[0]);
cmdText = $"UPDATE ROIPeriodChannels SET ChannelId = {channelId} WHERE ROIPeriodChannelId = {roiPeriodChannelId}";
Connection.ExecuteScriptCommand(cmd, cmdText);
}
}
}
}
else
{
foreach (var channelId in channelIdList)
{
channelIdAndNameDict[channelId] = channelName;
}
}
}
}
IdNameList.Add(channelIdAndNameDict);
}
return IdNameList;
}
private bool MigrateVersion98()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION99");
Transaction(cmd, "BEGIN", 99);
ExecuteScript("dbo.Add_SLICETC_Prototype.sql", cmd);
ExecuteScript("dbo.Add_SLICETC_Prototype_DAS_Channels.sql", cmd);
ExecuteScript("dbo.Add_Thermocoupler_SensorType.sql", cmd);
ExecuteScript("dbo.Create_sp_ThermocouplerGet.sql", cmd);
ExecuteScript("dbo.Create_Table_SensorsThermocoupler.sql", cmd);
ExecuteScript("Add_sp_DASGet_99_99.sql", cmd);
ExecuteScript("Alter_sp_DASGet_99.sql", cmd);
ExecuteScript("Alter_sp_DASGet_95_99.sql", cmd);
ExecuteScript("Add_sp_TestSetupHardwareGet_99_99.sql", cmd);
ExecuteScript("Alter_sp_TestSetupHardwareGet_99.sql", cmd);
ExecuteScript("Alter_sp_TestSetupHardwareGet_95_99.sql", cmd);
ExecuteScript("Alter_sp_ChannelsGet_99.sql", cmd);
ExecuteScript("Add_sp_ChannelsGet_99_99.sql", cmd);
ExecuteScript("Update_StoredProcedures_99.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION99");
Transaction(cmd, "COMMIT", 99);
InsertIntoSqlVersionsTable(cmd, 99, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry($"Throwing exception due to: {ex.Message}");
Transaction(cmd, "ROLLBACK", 99);
return false;
}
finally { cmd.Connection.Dispose(); }
}
}
private bool MigrateVersion99(string targetDir)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION100");
Transaction(cmd, "BEGIN", 100);
ExecuteScript("Add_sp_DASGet_100_100.sql", cmd);
ExecuteScript("Alter_sp_DASGet_100.sql", cmd);
ExecuteScript("Alter_sp_DASGet_95_100.sql", cmd);
ExecuteScript("Alter_sp_DASGet_99_100.sql", cmd);
ExecuteScript("Add_SLICE_PRO_CAN_FD_Prototype.sql", cmd);
ExecuteScript("Add_SLICE_PRO_CAN_FD_Prototype_DAS_Channels.sql", cmd);
ExecuteScript("Add_CAN_SensorType.sql", cmd);
ExecuteScript("Create_Table_SensorsCAN.sql", cmd);
ExecuteScript("Create_sp_SensorsCANGet.sql", cmd);
ExecuteScript("Insert_Can_ChannelSettings.sql", cmd);
ExecuteScript("Create_sp_ChannelSettingsGet_95_100.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_100.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_92_100.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_93_100.sql", cmd);
ExecuteScript("Alter_sp_ChannelSettingsGet_95_100.sql", cmd);
ExecuteScript("Update_StoredProcedures_100.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION100");
Transaction(cmd, "COMMIT", 100);
InsertIntoSqlVersionsTable(cmd, 100, 0);
//FB 44608 purge the orphaned in all sensors tables
//this code will not throw any exception , this code runs stored procedure sp_SensorsPurge
PurgeSensors(cmd);
}
catch (Exception ex)
{
log.WriteEntry($"Throwing exception due to: {ex.Message}");
Transaction(cmd, "ROLLBACK", 100);
return false;
}
finally { cmd.Connection.Dispose(); }
}
//FB 44343 Always have the Aero sensors in the database
//FB 44771 Temporarily disable until fix is ready
//ImportInitializationSensors(targetDir);
return true;
}
private static void PurgeSensors(SqlCommand cmd)
{
try
{
var hr = RunSensorsPurge(cmd);
if (0 == hr)
{
return;
}
APILogger.Log($"SensorsDeleteAll failed, result: {hr}");
}
catch
{
APILogger.Log($"SensorsDeleteAll failed, result");
}
}
//FB 44608
/// <summary>
/// Purge the orphaned records in Sensors tables
/// </summary>
/// <param name="user"></param>
/// <param name="connection"></param>
/// <returns></returns>
public static ulong RunSensorsPurge(SqlCommand cmd)
{
try
{
cmd.CommandText = "sp_SensorsPurge";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Clear();
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(errorMessage);
cmd.ExecuteNonQuery();
if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
{
APILogger.Log($"sp_SensorsPurge failed: {errorMessage.Value}");
return ErrorCodes.ERROR_UNKNOWN;
}
return ErrorCodes.ERROR_SUCCESS;
}
catch (Exception ex)
{
APILogger.Log($"sp_SensorsPurge failed: {ex.Message}");
return ErrorCodes.ERROR_UNKNOWN;
}
}
/// <summary>
/// This loops through all of the Test Setups, to determine what the new RepeatAutoArmOrStreaming
/// field should be set to in the TestSetups table. It does this be reading the LastModifiedBy
/// field, then using the value to query the DefaultAutoArmRepeatEnable value in the UserProperties table.
/// If that value is True, then the RepeatAutoArmOrStreaming field is set to True, if not it is left NULL.
/// It also caches the User/Boolean to avoid repeated unneeded queries.
/// </summary>
/// <param name="SetStatus"></param>
/////////////Combine this with MigrateROIToTables() if possible
private void MigrateDefaultAutoArmRepeatEnableToTestSetups(SetStatusDelegate SetStatus)
{
using (var cmd = GetSQLCommand(true))
{
try
{
// Get all of the Test Setups
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_TestSetupsGet_92";
cmd.Parameters.Clear();
var testSetupReader = cmd.ExecuteReader();
// Process each Test Setup
log.WriteEntry("Reading the Test Setups");
var userEnableRepeatCache = new Dictionary<string, bool>();
while (testSetupReader.Read())
{
var testSetupName = Classes.Utility.GetString(testSetupReader, "SetupName");
SetStatus("Migrating AutoArmRepeatEnable in " + testSetupName + "...");
var testSetupId = Classes.Utility.GetInt(testSetupReader, "TestSetupId", -1);
var lastModifiedBy = Classes.Utility.GetString(testSetupReader, "LastModifiedBy");
//Check to see if we've already cached this user
if (userEnableRepeatCache.ContainsKey(lastModifiedBy))
{
//It's cached, so check to see if the value is True
if (userEnableRepeatCache[lastModifiedBy])
{
//It's True, so update this Test Setup
using (var updateCmd = GetSQLCommand(true))
{
try
{
// If the value is False, we don't do anything because NULL gets converted to False
updateCmd.CommandType = CommandType.Text;
updateCmd.CommandText = $"UPDATE [TestSetups] SET RepeatAutoArmOrStreaming = 1 WHERE TestSetupId = {testSetupId}";
updateCmd.Parameters.Clear();
updateCmd.ExecuteNonQuery();
}
finally
{
updateCmd.Connection.Dispose();
}
}
}
}
else
{
//The user was not cached, so try to Get the UserId. If that fails, use "Admin".
int userId = 0;
try
{
userId = GetUserId(lastModifiedBy);
}
catch (Exception ex)
{
log.WriteEntry($"Changing to Admin: {ex.Message}");
// The user that last modified this Test Setup no longer exists, so use Admin
userId = GetUserId("Admin");
}
//Get the value in the UserProperties table.
var enableRepeatUserDefault = GetEnableRepeatDefaultForUser(userId);
//We wouldn't be here if it was cached, but double-check to be sure before caching it.
if (!userEnableRepeatCache.ContainsKey(lastModifiedBy))
{
userEnableRepeatCache[lastModifiedBy] = enableRepeatUserDefault;
}
//Check to see if the value is True
if (enableRepeatUserDefault)
{
using (var updateCmd = GetSQLCommand(true))
{
try
{
// If the value is False, we don't do anything because NULL gets converted to False
updateCmd.CommandType = CommandType.Text;
updateCmd.CommandText = $"UPDATE [TestSetups] SET RepeatAutoArmOrStreaming = 1 WHERE TestSetupId = {testSetupId}";
updateCmd.Parameters.Clear();
updateCmd.ExecuteNonQuery();
}
finally
{
updateCmd.Connection.Dispose();
}
}
}
}
}
}
catch (Exception ex)
{
log.WriteEntry(ex.Message);
throw;
}
finally
{
cmd.Connection.Dispose();
}
}
}
/// <summary>
/// This loops through all of the Test Setups, to determine what the new IgnoreShortedStart and IgnoreShortedTrigger
/// fields should be set to in the TestSetups table. It does this by reading these from the old config file.
/// If the value is True, then the corresponding field is set to True, if not it is left NULL.
/// </summary>
/// <param name="SetStatus"></param>
/////////////Combine this with MigrateROIToTables() if possible
private void MigrateConfigIgnoreShortedToTestSetups(SetStatusDelegate SetStatus, string previousDir, string registryDataPROExe, string applicationSettings)
{
const int DefaultIgnoreShortedStartEnum = 490;
const int DefaultIgnoreShortedTriggerEnum = 491;
const string IgnoreShortedStart = "IgnoreShortedStart";
const string IgnoreShortedTrigger = "IgnoreShortedTrigger";
bool defaultIgnoreShortedStart = false;
bool defaultIgnoreShortedTrigger = false;
if (previousDir != null && Directory.Exists(previousDir))
{
//Get default IgnoreShortedStart and IgnoreShortedTrigger from old config
var oldConfig = GetConfig(previousDir, registryDataPROExe, applicationSettings);
if (oldConfig.ContainsKey(IgnoreShortedStart))
{
defaultIgnoreShortedStart = Convert.ToBoolean(oldConfig[IgnoreShortedStart]);
}
if (oldConfig.ContainsKey(IgnoreShortedTrigger))
{
defaultIgnoreShortedTrigger = Convert.ToBoolean(oldConfig[IgnoreShortedTrigger]);
}
}
//Set the defaults for these in the DefaultProperties and UserProperties tables
InsertNewBooleanDefaultProperty(DefaultIgnoreShortedStartEnum, "DefaultIgnoreShortedStart", defaultIgnoreShortedStart);
InsertNewBooleanDefaultProperty(DefaultIgnoreShortedTriggerEnum, "DefaultIgnoreShortedTrigger", defaultIgnoreShortedTrigger);
//Get all entries in the TestSetup table and set IgnoreShortedStart and IgnoreShortedTrigger if both are not False
//If both are false, leaving NULL as the value is OK because that will be converted to False when read.
if (defaultIgnoreShortedStart || defaultIgnoreShortedTrigger)
{
UpdateTestSetupIgnoreShorted(SetStatus, defaultIgnoreShortedStart, defaultIgnoreShortedTrigger);
}
}
private void InsertNewBooleanDefaultProperty(int propertyId, string propertyName, bool defaultValue)
{
var defaultProperties = GetAllDefaultPropertyValues();
foreach (var defaultProperty in defaultProperties)
{
if (defaultProperty.Item1 == propertyId || defaultProperty.Item2 == propertyName)
{
return; //Property already exists
}
}
//If we got here, the property doesn't exist so insert it
//Add it to the DefaultProperties table
InsertBooleanDefaultProperty(propertyId, propertyName, defaultValue);
//Add it to the UserProperties table
var userIdList = GetAllUserIds();
foreach (var userId in userIdList)
{
if (!UserPropertiesRecordExists(userId, propertyId))
{
SetUserProperty(userId, propertyId, defaultValue ? "True" : "False");
}
}
}
/// <summary>
/// This function takes a User name and returns a User Id
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
private int GetUserId(string user)
{
var userIdReturn = 0;
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_UsersGetId.ToString();
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@UserName", SqlDbType.NVarChar, 50) { Value = user });
var userId = new SqlParameter("@UserId", SqlDbType.Int) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(userId);
cmd.ExecuteScalar();
userIdReturn = Convert.ToInt32(userId.Value);
}
finally
{
cmd.Connection.Dispose();
}
}
return userIdReturn;
}
/// <summary>
/// This function takes a User Id and returns the value of the DefaultAutoArmRepeatEnable
/// property in the UserProperties table.
/// </summary>
/// <param name="userId">The UserId field in the UserProperties table</param>
/// <returns>The value of the PropertyValue field in the UserProperties table</returns>
private bool GetEnableRepeatDefaultForUser(int userId)
{
var enableRepeatDefault = false;
using (var cmd = GetSQLCommand(true))
{
//First get the PropertyId corresponding to the DefaultAutoArmRepeatEnable property.
var defaultAutoArmRepeatEnablePropertyId = 0;
try
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = " SELECT PropertyId FROM DefaultProperties WHERE PropertyName = 'DefaultAutoArmRepeatEnable'";
cmd.Parameters.Clear();
var propertyReader = cmd.ExecuteReader();
if (propertyReader.Read())
{
defaultAutoArmRepeatEnablePropertyId = Convert.ToInt32(propertyReader["PropertyId"]);
}
propertyReader.Close();
}
catch (Exception ex)
{
log.WriteEntry(ex.Message);
//If there was a problem, leave.
cmd.Connection.Dispose();
throw;
}
//Now get the value of the DefaultAutoArmRepeatEnable property (True/False)
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_UserPropertiesGet.ToString();
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.Int) { Value = userId });
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = defaultAutoArmRepeatEnablePropertyId });
var userPropertyReader = cmd.ExecuteReader();
if (userPropertyReader.Read())
{
enableRepeatDefault = Convert.ToBoolean(userPropertyReader["PropertyValue"]);
}
}
finally
{
cmd.Connection.Dispose();
}
}
return enableRepeatDefault;
}
protected System.ComponentModel.BindingList<Interface.RegionOfInterest.IRegionOfInterest> _regionsOfInterest =
new System.ComponentModel.BindingList<Interface.RegionOfInterest.IRegionOfInterest>();
public System.ComponentModel.BindingList<Interface.RegionOfInterest.IRegionOfInterest> RegionsOfInterest
{
get => _regionsOfInterest;
set => _regionsOfInterest = value;
}
/// <summary>
/// Convert the string RegionsOfInterest field in the TestSetups table to
/// the TestSetupROIs and ROIPeriodChannels tables.
/// </summary>
/// <param name="SetStatus">The function that provides progress feedback</param>
private void MigrateROIToTables(SetStatusDelegate SetStatus)
{
//Go through each Test Setup
using (var testSetupCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_TestSetupsGet");
testSetupCmd.CommandType = CommandType.StoredProcedure;
testSetupCmd.CommandText = "sp_TestSetupsGet";
testSetupCmd.Parameters.Clear();
testSetupCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = null });
var testSetupReader = testSetupCmd.ExecuteReader();
log.WriteEntry("Reading the Test Setups");
while (testSetupReader.Read())
{
log.WriteEntry("Reading RegionsOfInterest");
var sRegions = Classes.Utility.GetString(testSetupReader, "RegionsOfInterest");
log.WriteEntry("Reading TestSetupId");
var testSetupId = Classes.Utility.GetInt(testSetupReader, "TestSetupId", -1);
log.WriteEntry("Reading SetupName");
var testSetupName = Classes.Utility.GetString(testSetupReader, "SetupName");
log.WriteEntry("Displaying status");
SetStatus("Migrating ROIs in " + testSetupName + "...");
//the deserialization is going to fire off a whole bunch of change notifications that don't really mean anything
//just skip them
log.WriteEntry("Setting Deserializing to True");
Classes.TestSetups.RegionOfInterest.Deserializing = true;
try
{
log.WriteEntry("Clearing RegionsOfInterest");
RegionsOfInterest.Clear();
log.WriteEntry("Actually deserializing");
var deserializedROIs = new System.Web.Script.Serialization.JavaScriptSerializer()
.Deserialize<System.ComponentModel.BindingList<Classes.TestSetups.RegionOfInterest>>(sRegions);
if (deserializedROIs == null)
{
log.WriteEntry("deserializedROIs is NULL");
//This may be from a Test Setup that was imported from an earlier release that
//didn't yet have the concept of multiple ROIs, so create one with the current values.
var ROIEnd = Classes.Utility.GetDouble(testSetupReader, "ROIEnd");
var ROIStart = Classes.Utility.GetDouble(testSetupReader, "ROIStart");
RegionsOfInterest.Add(new Classes.TestSetups.RegionOfInterest("", true, ROIStart, ROIEnd));
}
else
{
log.WriteEntry("Processing each ROI");
//Process each ROI in each Test Setup
foreach (var deserializedROI in deserializedROIs)
{
log.WriteEntry("Adding to RegionsOfInterest list");
RegionsOfInterest.Add(deserializedROI);
}
}
//Now put each Region Of Interest in the new tables
log.WriteEntry("Putting each ROI in the new tables");
foreach (var regionOfInterest in RegionsOfInterest)
{
log.WriteEntry("Calling StoreRegionsOfInterest");
StoreRegionsOfInterest(testSetupId, regionOfInterest);
}
}
finally { Classes.TestSetups.RegionOfInterest.Deserializing = false; }
}
}
finally
{
testSetupCmd.Connection.Dispose();
}
}
}
/// <summary>
/// Insert a Region Of Interest into the TestSetupROIs and ROIPeriodChannels tables
/// </summary>
/// <param name="testSetupId">The value that corresponds to the column in the TestSetups table</param>
/// <param name="regionOfInterest">The ROI to be stored</param>
private void StoreRegionsOfInterest(int testSetupId, Interface.RegionOfInterest.IRegionOfInterest regionOfInterest)
{
using (var testSetupROIsCommand = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_TestSetupROIsInsert");
testSetupROIsCommand.CommandType = CommandType.StoredProcedure;
testSetupROIsCommand.CommandText = "sp_TestSetupROIsInsert";
testSetupROIsCommand.Parameters.Clear();
testSetupROIsCommand.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
testSetupROIsCommand.Parameters.Add(new SqlParameter("@Suffix", SqlDbType.NVarChar, 50) { Value = regionOfInterest.Suffix });
testSetupROIsCommand.Parameters.Add(new SqlParameter("@ROIStart", SqlDbType.Float) { Value = regionOfInterest.Start });
testSetupROIsCommand.Parameters.Add(new SqlParameter("@ROIEnd", SqlDbType.Float) { Value = regionOfInterest.End });
testSetupROIsCommand.Parameters.Add(new SqlParameter("@IsEnabled", SqlDbType.Int) { Value = regionOfInterest.IsEnabled });
testSetupROIsCommand.Parameters.Add(new SqlParameter("@IsDefault", SqlDbType.Int) { Value = regionOfInterest.IsDefault });
var newIdParam = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupROIsCommand.Parameters.Add(newIdParam);
var errorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupROIsCommand.Parameters.Add(errorNumberParam);
var errorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
testSetupROIsCommand.Parameters.Add(errorMessageParam);
testSetupROIsCommand.ExecuteNonQuery();
if ((int.Parse(errorNumberParam.Value.ToString()) == 0) && (regionOfInterest.ChannelNames.Length > 0))
{
//Return the new id so that it can be used to enter this ROI period's channels into the ROIPeriodChannels table
var testSetupROIId = int.Parse(newIdParam.Value.ToString());
foreach (var channelName in regionOfInterest.ChannelNames)
{
//Find the channel's hardware channel if is assigned and can be determined.
var newChannelName = $"\\{channelName}";
//Get all of the GroupId values from the TestSetupGroups table with this TestSetupId
var groupIdList = GetGroupIds(testSetupId);
if (groupIdList.Any())
{
//Get the id from the Sensors table
var tsrAirChannelFound = false;
var sensorIdAndTypeDict = GetSensorId(channelName);
if (!sensorIdAndTypeDict.Any() && channelName == SensorConstants.TEST_SPECIFIC_ANALOG_SERIAL)
{
//None returned, so see if this is a TSR AIR channel
sensorIdAndTypeDict = GetSensorId(SensorConstants.TEST_SPECIFIC_ANALOG_SERIAL);
tsrAirChannelFound = sensorIdAndTypeDict.Any();
}
//If more than one row returned give up
if (sensorIdAndTypeDict.Count == 1)
{
//Get all of the DASIds and DASChannelIndex values from the Channels table with the GroupId and SensorId
foreach (var groupId in groupIdList)
{
var dasIdAndDasChannelIndexList = GetDASIdAndDASChannelIndex(groupId, sensorIdAndTypeDict.FirstOrDefault().Key);
if (tsrAirChannelFound)
{
var serialNumber = GetDASSerialNumber(dasIdAndDasChannelIndexList[0].Item1);
newChannelName = GenerateEmbeddedChannelName(serialNumber, channelName);
}
else
{
//If more than one row returned, give up
if (dasIdAndDasChannelIndexList.Count == 1)
{
// Get the SerialNumber and ParentDAS from the DAS table and combine with DASChannelIndex from Channels table
// and the channelName before storing ([SPE00596:SPS01235] CH-04\\an1)
var serialNumber = GetDASSerialNumber(dasIdAndDasChannelIndexList[0].Item1);
if (serialNumber != "")
{
var channelNumber = (dasIdAndDasChannelIndexList[0].Item2 + 1);
var chLabel = "CH";
if (sensorIdAndTypeDict.FirstOrDefault().Value == 3)
{
//Squib channel numbering needs to be divided by 2
channelNumber = ((dasIdAndDasChannelIndexList[0].Item2 / 2) + 1);
chLabel = "SQ";
}
newChannelName = $"[{serialNumber}] {chLabel}-{channelNumber.ToString("00")}\\{channelName}";
}
}
}
}
}
}
//Store the channel in the ROIPeriodChannels table
StorePeriodChannel(testSetupROIId, newChannelName);
}
}
}
finally
{
testSetupROIsCommand.Connection.Dispose();
}
}
}
/// <summary>
/// This function takes a TSR AIR serial number and a channel name that doesn't have
/// hardware, nor "\" pre-pended, and returns a new channel name with the hardware pre-pended.
/// </summary>
/// <param name="serialNumber"></param>
/// <param name="channelName"></param>
/// <returns></returns>
private string GenerateEmbeddedChannelName(string serialNumber, string channelName)
{
var newChannelName = string.Empty;
var channelNumber = 0;
if (channelName.Contains("Low g"))
{
serialNumber = $"{serialNumber}-Low g";
channelNumber = Convert.ToInt32(channelName.Substring(channelName.Length - 1, 1));
}
else if (channelName.Contains("High g"))
{
serialNumber = $"{serialNumber}-High g";
channelNumber = Convert.ToInt32(channelName.Substring(channelName.Length - 1, 1));
}
else if (channelName.Contains("Angular Rate"))
{
serialNumber = $"{serialNumber}-ARS";
channelNumber = Convert.ToInt32(channelName.Substring(channelName.Length - 1, 1));
}
else if (channelName.Contains("Temperature") ||
channelName.Contains("Humidity") ||
channelName.Contains("Pressure"))
{
serialNumber = $"{serialNumber}-Atm";
if (channelName.Contains("Temperature"))
{
channelNumber = 1;
}
else if (channelName.Contains("Humidity"))
{
channelNumber = 2;
}
else if (channelName.Contains("Pressure"))
{
channelNumber = 3;
}
}
newChannelName = $"[{serialNumber}] CH-{(channelNumber).ToString("00")}\\{channelName}";
return newChannelName;
}
/// <summary>
/// Get all of the GroupId values from the TestSetupGroups table with this TestSetupId
/// </summary>
/// <param name="testSetupId">The value that corresponds to the column in the TestSetups table</param>
/// <returns></returns>
private List<int> GetGroupIds(int testSetupId)
{
var groupIds = new List<int>();
using (var testSetupGroupsCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_TestSetupGroupsGet");
testSetupGroupsCmd.CommandType = CommandType.StoredProcedure;
testSetupGroupsCmd.CommandText = "sp_TestSetupGroupsGet";
testSetupGroupsCmd.Parameters.Clear();
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
var reader = testSetupGroupsCmd.ExecuteReader();
while (reader.Read())
{
groupIds.Add(Classes.Utility.GetInt(reader, "GroupId"));
}
}
finally
{
testSetupGroupsCmd.Connection.Dispose();
}
}
return groupIds;
}
/// <summary>
/// Get the id from the Sensors table with this serial number
/// </summary>
/// <param name="channelName">The serial number of the sensor on this channel</param>
/// <returns></returns>
private Dictionary<int, int> GetSensorId(string channelName)
{
var IdAndType = new Dictionary<int, int>();
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_SensorsGet");
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = "sp_SensorsGet";
sensorsCmd.Parameters.Clear();
sensorsCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 50) { Value = channelName });
var reader = sensorsCmd.ExecuteReader();
while (reader.Read())
{
var id = Classes.Utility.GetInt(reader, "Id", -1);
var sensorType = Classes.Utility.GetInt(reader, "SensorType", -1);
IdAndType[id] = sensorType;
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
return IdAndType;
}
/// <summary>
/// Get the DASId and DASChannelIndex values from the Channels table with this GroupId and SensorId
/// </summary>
/// <param name="groupId">The value that matches the column in the Groups table</param>
/// <param name="sensorId">The value that matches the column in the Sensors table</param>
/// <returns>A list of DASId/DASChannelIndex tuples (hopefully a list of length 1)</returns>
private List<Tuple<int, int>> GetDASIdAndDASChannelIndex(int groupId, int sensorId)
{
var dasIdAndChannelIndexList = new List<Tuple<int, int>>();
using (var channelsCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_ChannelsGet");
channelsCmd.CommandType = CommandType.StoredProcedure;
channelsCmd.CommandText = "sp_ChannelsGet";
channelsCmd.Parameters.Clear();
channelsCmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = groupId });
var reader = channelsCmd.ExecuteReader();
while (reader.Read())
{
//Passing SensorId as a parameter is ignored if GroupId is not null
if (Classes.Utility.GetInt(reader, "SensorId", -1) == sensorId)
{
var dasAndChannelIndex = new Tuple<int, int>(Classes.Utility.GetInt(reader, "DASId", -1), Classes.Utility.GetInt(reader, "DASChannelIndex", -1));
dasIdAndChannelIndexList.Add(dasAndChannelIndex);
}
}
}
finally
{
channelsCmd.Connection.Dispose();
}
}
return dasIdAndChannelIndexList;
}
/// <summary>
/// Get the SerialNumber and ParentDAS from the DAS table and combine with DASChannelIndex from Channels table
/// and the channelName before storing ([SPE00596:SPS01235] CH-04\\an1)
/// </summary>
/// <param name="dasId">The value that matches the column in the DAS table</param>
/// <returns></returns>
private string GetDASSerialNumber(int dasId)
{
using (var DASCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_DASGet");
DASCmd.CommandType = CommandType.StoredProcedure;
DASCmd.CommandText = "sp_DASGet";
DASCmd.Parameters.Clear();
var reader = DASCmd.ExecuteReader();
while (reader.Read())
{
var foundDASId = Classes.Utility.GetInt(reader, "DASId", -1);
if (foundDASId == dasId)
{
var dasString = "";
var parentDAS = Classes.Utility.GetString(reader, "ParentDAS");
if (parentDAS != "")
{
dasString = $"{parentDAS}:";
}
dasString = $"{dasString}{Classes.Utility.GetString(reader, "SerialNumber", "")}";
return dasString;
}
}
}
finally
{
DASCmd.Connection.Dispose();
}
}
return "";
}
/// <summary>
/// Insert a record into the ROIPeriodChannels table
/// </summary>
/// <param name="testSetupROIId">The value that matches the column in the TestSetupROIs table</param>
/// <param name="newChannelName">The channel name that may or may not be preceded by the Hardware Channel (DAS and channel index)</param>
private void StorePeriodChannel(int testSetupROIId, string newChannelName)
{
using (var roiPeriodChannelsInsertCmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Calling sp_ROIPeriodChannelsInsert");
roiPeriodChannelsInsertCmd.CommandType = CommandType.StoredProcedure;
roiPeriodChannelsInsertCmd.CommandText = "sp_ROIPeriodChannelsInsert";
roiPeriodChannelsInsertCmd.Parameters.Clear();
roiPeriodChannelsInsertCmd.Parameters.Add(new SqlParameter("@TestSetupROIId", SqlDbType.Int) { Value = testSetupROIId });
roiPeriodChannelsInsertCmd.Parameters.Add(new SqlParameter("@ChannelName", SqlDbType.NVarChar, 4000) { Value = newChannelName });
var channelErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
roiPeriodChannelsInsertCmd.Parameters.Add(channelErrorNumberParam);
var channelErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
roiPeriodChannelsInsertCmd.Parameters.Add(channelErrorMessageParam);
roiPeriodChannelsInsertCmd.ExecuteNonQuery();
}
finally
{
roiPeriodChannelsInsertCmd.Connection.Dispose();
}
}
}
private void SetDASMaxAAFilterRates()
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
//PowerPRO
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.PowerPRO.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.PowerPro}";
sql.ExecuteNonQuery();
//SLICE1
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE_Base}";
sql.ExecuteNonQuery();
//SLICE1_5
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE1_5.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE1_5_Micro_Base} OR " +
$"TYPE = {(int)HardwareTypes.SLICE1_5_Nano_Base}";
sql.ExecuteNonQuery();
//SLICE2
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE2.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE2_Base} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_Bridge_Hi} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_Bridge_Lo} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_DIM} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_IEPE_Hi} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_IEPE_Lo} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_SIM} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_SLD} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_SLS} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_TOM} OR " +
$"TYPE = {(int)HardwareTypes.SLICE2_SLT}";
sql.ExecuteNonQuery();
//SLICE6
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE6.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE6_Base}";
sql.ExecuteNonQuery();
//SLICE6AIR
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE6AIR.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE6_AIR}";
sql.ExecuteNonQuery();
//SLICE6AIRBR
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE6AIRBR.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE6_AIR_BR}";
sql.ExecuteNonQuery();
//SLICE6DB
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICE6DB.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE6DB} OR " +
$"TYPE = {(int)HardwareTypes.SLICE6DB3} OR " +
$"TYPE = {(int)HardwareTypes.SLICE6DB_InDummy}";
sql.ExecuteNonQuery();
//SLICEDB
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.SLICEDB.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SLICE_Distributor}";
sql.ExecuteNonQuery();
//TDAS
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.TDAS.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.SIM} OR " +
$"TYPE = {(int)HardwareTypes.DIM} OR " +
$"TYPE = {(int)HardwareTypes.TOM} OR " +
$"TYPE = {(int)HardwareTypes.TDAS_LabRack} OR " +
$"TYPE = {(int)HardwareTypes.TDAS_Pro_Rack}";
sql.ExecuteNonQuery();
//TSRAIR
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constant.DASSpecific.TSRAIR.MaxAAFilterRateHz} WHERE " +
$"TYPE = {(int)HardwareTypes.TSR_AIR} OR " +
$"TYPE = {(int)HardwareTypes.TSR_AIR_RevB}";
sql.ExecuteNonQuery();
//other
sql.CommandText = $"UPDATE [DAS] SET MaxAAFRate = {Constants.MaxAAFilterRateHz} WHERE MaxAAFRate IS NULL;";
sql.ExecuteNonQuery();
}
catch (Exception)
{
//ignore
}
finally
{
sql.Connection.Dispose();
}
}
}
private bool MigrateVersion74()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION74");
Transaction(cmd, "BEGIN", 74);
ExecuteScript("dbo.Alter_CalculatedChannels_Table74.sql", cmd);
ExecuteScript("dbo.Update_CalculatedChannels_74.sql", cmd);
ExecuteScript("dbo.Alter_sp_CalculatedChannelsGet_74.sql", cmd);
ExecuteScript("dbo.Alter_sp_CalculatedChannelsInsert_74.sql", cmd);
ExecuteScript("dbo.Alter_sp_CalculatedChannelsUpdate_74.sql", cmd);
ExecuteScript("dbo.Alter_sp_CalculatedChannelsUpdateInsert_74.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION74");
Transaction(cmd, "COMMIT", 74);
InsertIntoSqlVersionsTable(cmd, 75, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 74);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion73()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION73");
Transaction(cmd, "BEGIN", 73);
ExecuteScript("dbo.Alter_TestSetups_Table.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsGet_73.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsert_73.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsertUpdate_73.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdate_73.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdateInsert_73.sql", cmd);
ExecuteScript("dbo.Add_SLICE6AIR_HardwareAndSettings.sql", cmd);
ExecuteScript("dbo.Add_TSDigitalInput.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupGroupsUpdate_73.sql", cmd);
ExecuteScript("dbo.Alter_sp_UsersDelete.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION73");
Transaction(cmd, "COMMIT", 73);
InsertIntoSqlVersionsTable(cmd, 74, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 73);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion72(SetStatusDelegate SetStatus)
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION72");
Transaction(cmd, "BEGIN", 72);
ExecuteScript("sp_TestSetupGroupsGet.StoredProcedure_72.sql", cmd);
ExecuteScript("sp_LockFree_72.sql", cmd);
ExecuteScript("sp_LockGet_72.sql", cmd);
ExecuteScript("sp_LockUpdate_72.sql", cmd);
ExecuteScript("dbo.foo_GetIdenticalChannelCount_72.sql", cmd);
ExecuteScript("dbo.foo_GetIdenticalGroupChannelSettingsCount_72.sql", cmd);
ExecuteScript("dbo.foo_GetTotalChannelCount_72.sql", cmd);
ExecuteScript("dbo.foo_GetTotalGroupChannelSettingsCount_72.sql", cmd);
ExecuteScript("dbo.sp_CompareGroupHardware.StoredProcedure_72.sql", cmd);
ExecuteScript("dbo.sp_CompareGroupChannelSettings.StoredProcedure_72.sql", cmd);
ExecuteScript("dbo.sp_CompareGroups.StoredProcedure_72.sql", cmd);
//1 insert new parameters, 2 migrate old parameters over, 3 remove old parameters
ExecuteScript("ChannelSettings_72.sql", cmd);
ExecuteScript("sp_ChannelSettingsUpdate.sql", cmd);
ExecuteScript("dbo.Alter_TestSetupHardware.Table_72.sql", cmd);
ExecuteScript("dbo.sp_TestSetupHardwareGet.StoredProcedure_72.sql", cmd);
ExecuteScript("dbo.sp_TestSetupHardwareInsert.StoredProcedure_72.sql", cmd);
ExecuteScript("dbo.sp_TestSetupHardwareUpdate.StoredProcedure_72.sql", cmd);
ExecuteScript("dbo.Alter_TestSetups_Table_72.sql", cmd);
ExecuteScript("dbo.Insert_DefaultProperties_CalibrationBehavior_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsGet.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsert.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsInsertUpdate.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdate.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdateInsert.sql", cmd);
ExecuteScript("DASChannels_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestSetupsUpdate_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_CustomerDetailsDelete_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_LabratoryDetailsDelete_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_TestEngineerDetailsDelete_72.sql", cmd);
//13886 DataPRO crashed while trying to configure Test Setup for test rail test C61063
ExecuteScript("dbo.Alter_sp_GroupsDelete_72.sql", cmd);
//Add support for Group renaming
ExecuteScript("Alter_tbl_Groups_StaticGroupId_72.sql", cmd);
ExecuteScript("dbo.Alter_foo_GetIdenticalChannelCount_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_CompareGroups_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsInsert_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsUpdate_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsUpdateInsert_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupsGet_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_GroupChannelSettingsDelete_72.sql", cmd);
ExecuteScript("INDEX_CHANNELCODES1_72.sql", cmd);
ExecuteScript("INDEX_CHANNELCODES2_72.sql", cmd);
ExecuteScript("INDEX_CHANNELCODES3_72.sql", cmd);
ExecuteScript("INDEX_CHANNELS1_72.sql", cmd);
ExecuteScript("INDEX_CHANNELS2_72.sql", cmd);
ExecuteScript("INDEX_CHANNELS3_72.sql", cmd);
ExecuteScript("INDEX_SENSORCALIBRATIONS1_72.sql", cmd);
ExecuteScript("INDEX_SENSORSANALOG1_72.sql", cmd);
ExecuteScript("INDEX_TESTSETUP1_72.sql", cmd);
//Take [DataPRO] out of scripts
ExecuteScript("dbo.Alter_foo_GetTotalChannelCount_72.sql", cmd);
ExecuteScript("dbo.Alter_foo_GetIdenticalChannelCount_72.sql", cmd);
ExecuteScript("dbo.Alter_foo_GetTotalGroupChannelSettingsCount_72.sql", cmd);
ExecuteScript("dbo.Alter_foo_GetIdenticalGroupChannelSettingsCount_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_ChannelsDelete_72.sql", cmd);
//Remove calls to SplitRecord assembly
ExecuteScript("dbo.Alter_sp_DBImportSensorsSquib_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsAnalog_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsDigitalOut_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportTestSetups_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsDigitalInput_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsAnalog_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsDigitalInput_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsDigitalOut_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportSensorsSquib_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_DBImportTestSetups_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorCalibrationsInsert_Pre20_72.sql", cmd);
ExecuteScript("dbo.Alter_sp_SensorCalibrationsInsert_72.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION72");
Transaction(cmd, "COMMIT", 72);
MigrateTestSetupHardwareSamplesPerSecond(SetStatus);
InsertStaticGroupIds(SetStatus);
var squibChannelIdList = RemoveUnrelatedChannelSettings(SetStatus);
AddSquibNonDefaultSettings(squibChannelIdList);
MigrateDigitalOutputMode();
InsertIntoSqlVersionsTable(cmd, 73, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 72);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private bool MigrateVersion71()
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION71");
Transaction(cmd, "BEGIN", 71);
ExecuteScript("sp_SensorCalibrationsDelete.StoredProcedure_71.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION71");
Transaction(cmd, "COMMIT", 71);
InsertIntoSqlVersionsTable(cmd, 72, 0);
return true;
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
Transaction(cmd, "ROLLBACK", 71);
return false;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void MigrateTestSetupHardwareAAFRates(SetStatusDelegate SetStatus, string _targetDir, string registryDataPROExe, string applicationSettings)
{
int defaultAAFRatio = 5; //If _targetDir is null, this must be a stand-alone migration and no config is available
if (_targetDir != null)
{
//Get default AAF ratio from config
var newConfig = GetConfig(_targetDir, registryDataPROExe, applicationSettings);
defaultAAFRatio = Convert.ToInt32(newConfig["SampleRateAAFilterRatio"]);
}
//Get all entries in the TestSetupHardware table and change their AntiAliasFilterRate from 0 to their default
UpdateTestSetupHardwareEntries(_targetDir, registryDataPROExe, applicationSettings, defaultAAFRatio);
}
private MigrationResult MigrateStreamingConfigSetting(SetStatusDelegate SetStatus, string _previousDir, string registryDataPROExe, string applicationSettings)
{
var result = MigrationResult.OK;
bool allowStreaming = false; //If this is a stand-alone migration, it's possible that the files needed
//are not in the folder that the db is in, so set AllowStreamingModes to false.
if (_previousDir != null &&
File.Exists(Path.Combine(_previousDir, "DataPRO.exe.config")) &&
File.Exists(Path.Combine(_previousDir, "DataPRO.exe")))
{
//Get previous streaming setting from config
var oldConfig = GetConfig(_previousDir, registryDataPROExe, applicationSettings);
//Older versions (2.1 for example) do not have AllowStreaming in the config
allowStreaming = oldConfig.ContainsKey("AllowStreaming") && Convert.ToBoolean(oldConfig["AllowStreaming"]);
}
else
{
//Warn user that since either the DataPRO.exe or the DataPRO.exe.config file was missing,
//AllowStreamingModes didn't get migrated from the previous version, and is set to False.
//To allow streaming modes, check the "Allow streaming modes" checkbox in the "Test setup settings" step
//of the System Settings tab.
result = MigrationResult.WarningAllowStreamingModesWasNotMigrated;
}
//Update the default property with what was set in the config, or False from above
UpdateDefaultPropertyByName("AllowStreamingModes", allowStreaming.ToString());
return result;
}
private void SetDefaultAAFRate(int dasId, int testSetupId, bool addOrRemove, int samplesPerSecond, bool isClockMaster, int antiAliasFilterRate)
{
using (var testSetupHardwareUpdateCmd = GetSQLCommand(true))
{
try
{
testSetupHardwareUpdateCmd.CommandType = CommandType.StoredProcedure;
testSetupHardwareUpdateCmd.CommandText = "sp_TestSetupHardwareUpdate";
testSetupHardwareUpdateCmd.Parameters.Clear();
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@AddOrRemove", SqlDbType.Bit) { Value = addOrRemove });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@SamplesPerSecond", SqlDbType.Float) { Value = samplesPerSecond });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@IsClockMaster", SqlDbType.Bit) { Value = isClockMaster });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@AntiAliasFilterRate", SqlDbType.Float) { Value = antiAliasFilterRate });
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupHardwareUpdateCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
testSetupHardwareUpdateCmd.Parameters.Add(errorMessage);
testSetupHardwareUpdateCmd.ExecuteNonQuery();
}
finally
{
testSetupHardwareUpdateCmd.Connection.Dispose();
}
}
}
private HardwareTypes GetDASTypeEnum(int dasId)
{
//Get the Type from the DAS table where DASId = dasId
using (var dasCmd = GetSQLCommand(true))
{
try
{
dasCmd.CommandType = CommandType.StoredProcedure;
dasCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DASGet.ToString();
var dasReader = dasCmd.ExecuteReader();
while (dasReader.Read())
{
if (Convert.ToInt32(dasReader["DASId"]) == dasId)
{
var dasType = Convert.ToInt32(dasReader["Type"]);
HardwareTypes enumType = (HardwareTypes)dasType;
return enumType;
}
}
}
finally
{
dasCmd.Connection.Dispose();
}
}
return HardwareTypes.UNDEFINED;
}
private void UpdateDefaultPropertyByName(string propertyName, string defaultValue)
{
using (var updateDefaultPropertyCmd = GetSQLCommand(true))
{
try
{
updateDefaultPropertyCmd.CommandType = CommandType.StoredProcedure;
updateDefaultPropertyCmd.CommandText = "sp_DefaultPropertiesUpdateByName";
updateDefaultPropertyCmd.Parameters.Clear();
updateDefaultPropertyCmd.Parameters.Add(new SqlParameter("@PropertyName", SqlDbType.NVarChar, 255) { Value = propertyName });
updateDefaultPropertyCmd.Parameters.Add(new SqlParameter("@DefaultValue", SqlDbType.NVarChar, 255) { Value = defaultValue });
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
updateDefaultPropertyCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
updateDefaultPropertyCmd.Parameters.Add(errorMessage);
updateDefaultPropertyCmd.ExecuteNonQuery();
}
finally
{
updateDefaultPropertyCmd.Connection.Dispose();
}
}
}
private void UpdateTestSetupHardwareEntries(string _targetDir, string registryDataPROExe, string applicationSettings, int defaultAAFRatio)
{
using (var testSetupsHardwareGetCmd = GetSQLCommand(true))
{
try
{
testSetupsHardwareGetCmd.CommandType = CommandType.StoredProcedure;
//Get all TestSetupHardware rows
testSetupsHardwareGetCmd.CommandText = "sp_TestSetupHardwareGet";
testSetupsHardwareGetCmd.Parameters.Clear();
var testSetupHardwareReader = testSetupsHardwareGetCmd.ExecuteReader();
while (testSetupHardwareReader.Read())
{
//Determine DAS type
var dasId = Convert.ToInt32(testSetupHardwareReader["DASId"]);
var dasTypeEnum = GetDASTypeEnum(dasId);
var testSetupId = Convert.ToInt32(testSetupHardwareReader["TestSetupId"]);
var addOrRemove = Convert.ToBoolean(testSetupHardwareReader["AddOrRemove"]);
var samplesPerSecond = Convert.ToInt32(testSetupHardwareReader["SamplesPerSecond"]);
var isClockMaster = Convert.ToBoolean(testSetupHardwareReader["IsClockMaster"]);
var defaultAntiAliasFilterRate = GenerateDefaultAntiAliasFilterRate(dasTypeEnum, samplesPerSecond, _targetDir,
registryDataPROExe, applicationSettings, defaultAAFRatio);
//Update AntiAliasFilterRate field
SetDefaultAAFRate(dasId, testSetupId, addOrRemove, samplesPerSecond, isClockMaster, defaultAntiAliasFilterRate);
}
}
finally
{
testSetupsHardwareGetCmd.Connection.Dispose();
}
}
}
/// <summary>
/// Set the new fields, IgnoreShortedStart and IgnoreShortedTrigger, based on the old config
/// </summary>
/// <param name="SetStatus">Function to display status</param>
/// <param name="ignoreShortedStart">The value to be set in the new IgnoreShortedStart field</param>
/// <param name="ignoreShortedStart">The value to be set in the new IgnoreShortedTrigger field</param>
private void UpdateTestSetupIgnoreShorted(SetStatusDelegate SetStatus, bool ignoreShortedStart, bool ignoreShortedTrigger)
{
using (var cmd = GetSQLCommand(true))
{
try
{
// Get all of the Test Setups
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupsGet.ToString();
cmd.Parameters.Clear();
var testSetupReader = cmd.ExecuteReader();
// Process each Test Setup
log.WriteEntry("Reading the Test Setups");
while (testSetupReader.Read())
{
var testSetupName = Classes.Utility.GetString(testSetupReader, "SetupName");
SetStatus("Migrating IgnoreShorted in " + testSetupName + "...");
var testSetupId = Classes.Utility.GetInt(testSetupReader, "TestSetupId", -1);
using (var updateCmd = GetSQLCommand(true))
{
try
{
updateCmd.CommandType = CommandType.Text;
updateCmd.CommandText = "UPDATE [TestSetups] SET " +
$"IgnoreShortedStart = {(Convert.ToInt32(ignoreShortedStart))}, " +
$"IgnoreShortedTrigger = {(Convert.ToInt32(ignoreShortedTrigger))} " +
$"WHERE TestSetupId = {testSetupId}";
updateCmd.Parameters.Clear();
updateCmd.ExecuteNonQuery();
}
finally
{
updateCmd.Connection.Dispose();
}
}
}
}
catch (Exception ex)
{
log.WriteEntry(ex.Message);
throw;
}
finally
{
cmd.Connection.Dispose();
}
}
}
private int GenerateDefaultAntiAliasFilterRate(HardwareTypes dasTypeEnum, int samplesPerSecond, string _targetDir,
string registryDataPROExe, string applicationSettings, int defaultAAFRatio)
{
int antiAliasFilterRate = 0;
switch (dasTypeEnum)
{
case HardwareTypes.DIM:
case HardwareTypes.G5INDUMMY:
case HardwareTypes.G5VDS:
case HardwareTypes.SIM:
case HardwareTypes.TDAS_Pro_Rack:
case HardwareTypes.TDAS_LabRack:
case HardwareTypes.TOM:
antiAliasFilterRate = Convert.ToInt32(GetAAFException(SerializableAAF.DAS_TYPE.TDAS, samplesPerSecond, _targetDir,
registryDataPROExe, applicationSettings, defaultAAFRatio));
break;
default:
antiAliasFilterRate = Convert.ToInt32(GetAAFException(SerializableAAF.DAS_TYPE.SLICE, samplesPerSecond, _targetDir,
registryDataPROExe, applicationSettings, defaultAAFRatio));
break;
}
return antiAliasFilterRate;
}
private static readonly List<int> DefaultTDASAAFSPSIndicies = new List<int>(new[]
{
250,
500,
1000,
2000,
2500,
5000,
8000,
10000,
12500,
20000,
25000,
40000,
50000,
60000,
75000,
100000,
150000,
300000
});
private static readonly List<double> DefaultTDASAAFCutoffs = new List<double>(new double[]
{
50,
100,
200,
500,
500,
1000,
2000,
2900,
2900,
3620,
3620,
0,
0,
0,
0,
0,
0,
0
});
private double GetAAFException(SerializableAAF.DAS_TYPE dasType, int sps, string _targetDir, string registryDataPROExe,
string applicationSettings, int defaultAAFRatio)
{
//Generate key from dasType and sps
var key = $"{(int)dasType}_x_{sps}";
//Get default value based on ratio
var defaultValue = (double)sps / defaultAAFRatio;
//Update default value if appropriate
switch (dasType)
{
case SerializableAAF.DAS_TYPE.TDAS:
var index = DefaultTDASAAFSPSIndicies.IndexOf(sps);
if (index >= 0 && index < DefaultTDASAAFCutoffs.Count)
{
defaultValue = DefaultTDASAAFCutoffs[index];
}
break;
case SerializableAAF.DAS_TYPE.SLICE:
if (sps != 10000)
{
if (sps == 12500)
{
defaultValue = 2900;
}
}
else
{
defaultValue = 2900;
} //this is the only built in slice exception right now
break;
//this exception is because of
//https://support.dtsweb.com/hc/en-us/community/posts/208919368-DataPro-1-01-0425-default-AAF-setting?page=1#community_comment_213875877
}
//Get PropertyValue from Settings table where key is the PropertyId
return GetSettingDouble(key, defaultValue);
}
private Dictionary<string, string> GetConfig(string _targetDir, string registryDataPROExe, string applicationSettings)
{
var newPath = string.Empty;
//Open the new config file just installed
newPath = Path.Combine(_targetDir, registryDataPROExe);
var _newConfig = ConfigurationManager.OpenExeConfiguration(@newPath);
var _newSettings = GetConfigApplicationSettings(_newConfig, applicationSettings);
var _newSettingsDictionary = _newSettings.Cast<SettingElement>().ToDictionary(newSetting => newSetting.Name, newSetting => newSetting.Value.ValueXml.InnerXml);
return _newSettingsDictionary;
}
private SettingElementCollection GetConfigApplicationSettings(Configuration _newConfig, string applicationSettings)
{
var configurationSectionGroup = _newConfig.SectionGroups[applicationSettings];
if (configurationSectionGroup == null) return null;
return configurationSectionGroup.Sections[0] is ClientSettingsSection clientSettingsSection ? clientSettingsSection.Settings : null;
}
private double GetSettingDouble(string key, double defaultValue)
{
//Get PropertyValue from Settings table where key is the PropertyId
var sValue = GetSettingValue(key);
return !double.TryParse(sValue, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out var d) ? defaultValue : d;
}
private string GetSettingValue(string id)
{
var stringValue = string.Empty;
using (var settingsCmd = GetSQLCommand(true))
{
try
{
settingsCmd.CommandType = CommandType.StoredProcedure;
settingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SettingsGet.ToString();
settingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar) { Value = id });
using (var ds = Connection.QueryDataSet(settingsCmd))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
stringValue = Convert.ToString(ds.Tables[0].Rows[0][Settings.UserFields.PropertyValue.ToString()]);
}
}
}
finally { settingsCmd.Connection.Dispose(); }
}
return stringValue;
}
private void MigrateChannelSettings(SetStatusDelegate SetStatus)
{
//Get all channel settings
var channelSettingsDict = GetAllChannelSettings(); //SettingName, Id
//Get all channel ids and their sensors
var channelSensorDict = GetChannelIdsAndSensors(); //ChannelId, SensorId
//For each channel/sensor pair
var channelCount = channelSensorDict.Count;
var count = 0;
foreach (var pair in channelSensorDict)
{
count++;
SetStatus("Adding to GroupChannelSettings table (Channel " + count + "/" + channelCount + ")");
//Get the settings for this channel already in GroupChannelSettings
var existingSettings = GetChannelSettings(pair.Key);
SensorConstants.SensorType sensorType;
var success = GetSensorType(pair.Value, out sensorType);
if (!success) continue;
//Get sensor and calibration values
var SensorAndCalibrationValues = GetSensorAndCalibrationValues(sensorType, pair.Value);
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
InsertSettingIfNeeded(existingSettings, channelSettingsDict["Range"], pair.Key, SensorAndCalibrationValues["Range"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["Polarity"], pair.Key, SensorAndCalibrationValues["Polarity"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["ZeroMethod"], pair.Key, SensorAndCalibrationValues["ZeroMethod"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["ZeroMethodStart"], pair.Key, SensorAndCalibrationValues["ZeroMethodStart"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["ZeroMethodEnd"], pair.Key, SensorAndCalibrationValues["ZeroMethodEnd"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["UserValue1"], pair.Key, SensorAndCalibrationValues["UserValue1"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["UserValue2"], pair.Key, SensorAndCalibrationValues["UserValue2"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["UserValue3"], pair.Key, SensorAndCalibrationValues["UserValue3"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["InitialOffset"], pair.Key, SensorAndCalibrationValues["InitialOffset"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["FilterClass"], pair.Key, SensorAndCalibrationValues["FilterClass"]);
break;
case SensorConstants.SensorType.DigitalIn:
InsertSettingIfNeeded(existingSettings, channelSettingsDict["DIMode"], pair.Key, SensorAndCalibrationValues["DIMode"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["DefaultValue"], pair.Key, SensorAndCalibrationValues["DefaultValue"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["ActiveValue"], pair.Key, SensorAndCalibrationValues["ActiveValue"]);
break;
case SensorConstants.SensorType.DigitalOut:
InsertSettingIfNeeded(existingSettings, channelSettingsDict["OutputMode"], pair.Key, SensorAndCalibrationValues["OutputMode"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["DigitalOutLimitDuration"], pair.Key, SensorAndCalibrationValues["DigitalOutLimitDuration"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["DigitalOutDuration"], pair.Key, SensorAndCalibrationValues["DigitalOutDuration"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["DigitalOutDelay"], pair.Key, SensorAndCalibrationValues["DigitalOutDelay"]);
break;
case SensorConstants.SensorType.Squib:
InsertSettingIfNeeded(existingSettings, channelSettingsDict["SQMode"], pair.Key, SensorAndCalibrationValues["SQMode"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["SquibLimitDuration"], pair.Key, SensorAndCalibrationValues["SquibLimitDuration"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["SquibDuration"], pair.Key, SensorAndCalibrationValues["SquibDuration"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["SquibDelay"], pair.Key, SensorAndCalibrationValues["SquibDelay"]);
InsertSettingIfNeeded(existingSettings, channelSettingsDict["SquibCurrent"], pair.Key, SensorAndCalibrationValues["SquibCurrent"]);
break;
}
}
}
private void InsertSettingIfNeeded(List<int> existingSettings, int settingId, long channelId, string settingValue)
{
if (!existingSettings.Contains(settingId))
{
InsertSettingsValue(channelId, settingId, settingValue);
}
}
private void InsertSettingsValue(Int64 channelId, int settingId, string settingValue)
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.StoredProcedure;
sql.CommandText = @"sp_GroupChannelSettingsInsert";
sql.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
sql.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = settingId });
sql.Parameters.Add(new SqlParameter("@SettingValue", SqlDbType.NVarChar, 255) { Value = settingValue });
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
sql.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
sql.Parameters.Add(errorMessage);
sql.ExecuteNonQuery();
if (null != errorNumber.Value && !DBNull.Value.Equals(errorNumber.Value)
&& 0 != Convert.ToInt32(errorNumber.Value))
{
throw new Exception((string)errorMessage.Value);
}
}
finally
{
sql.Connection.Dispose();
}
}
}
private Dictionary<string, string> GetSensorAndCalibrationValues(SensorConstants.SensorType sensorType, int sensorId)
{
var sensorAndCalibrationValues = new Dictionary<string, string>();
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
sensorAndCalibrationValues = GetAnalogSensorAndCalibrationValues(sensorId);
break;
case SensorConstants.SensorType.DigitalIn:
sensorAndCalibrationValues = GetDigitalInSensorValues(sensorId);
break;
case SensorConstants.SensorType.DigitalOut:
sensorAndCalibrationValues = GetDigitalOutSensorValues(sensorId);
break;
case SensorConstants.SensorType.Squib:
sensorAndCalibrationValues = GetSquibSensorValues(sensorId);
break;
}
return sensorAndCalibrationValues;
}
private Dictionary<string, string> GetSquibSensorValues(int sensorId)
{
var sensorAndCalibrationValues = new Dictionary<string, string>();
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsSquibGet.ToString();
sensorsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
sensorsCmd.ExecuteNonQuery();
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs == null || sensorsDs.Tables == null || sensorsDs.Tables.Count != 1 ||
sensorsDs.Tables[0].Rows == null || sensorsDs.Tables[0].Rows.Count != 1) return null;
//SQMode 9
sensorAndCalibrationValues["SQMode"] = Convert.ToInt16(sensorsDs.Tables[0].Rows[0]["FireMode"]).ToString();
//SquibLimitDuration 13
sensorAndCalibrationValues["SquibLimitDuration"] = Convert.ToBoolean(sensorsDs.Tables[0].Rows[0]["LimitDuration"]).ToString();
//SquibDuration 14
sensorAndCalibrationValues["SquibDuration"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["DurationMS"]).ToString();
//SquibDelay 15
sensorAndCalibrationValues["SquibDelay"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["DelayMS"]).ToString();
//SquibCurrent 19
sensorAndCalibrationValues["SquibCurrent"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["SquibOutputCurrent"]).ToString();
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
return sensorAndCalibrationValues;
}
private Dictionary<string, string> GetDigitalOutSensorValues(int sensorId)
{
var sensorAndCalibrationValues = new Dictionary<string, string>();
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalOutGet.ToString();
sensorsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
sensorsCmd.ExecuteNonQuery();
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs == null || sensorsDs.Tables == null || sensorsDs.Tables.Count != 1 ||
sensorsDs.Tables[0].Rows == null || sensorsDs.Tables[0].Rows.Count != 1) return null;
//OutputMode 8
sensorAndCalibrationValues["OutputMode"] = Convert.ToInt32(sensorsDs.Tables[0].Rows[0]["OutputMode"]).ToString();
//DigitalOutLimitDuration 16
sensorAndCalibrationValues["DigitalOutLimitDuration"] = Convert.ToBoolean(sensorsDs.Tables[0].Rows[0]["LimitDuration"]).ToString();
//DigitalOutDuration 17
sensorAndCalibrationValues["DigitalOutDuration"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["DurationMSFloat"]).ToString();
//DigitalOutDelay 18
sensorAndCalibrationValues["DigitalOutDelay"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["DelayMS"]).ToString();
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
return sensorAndCalibrationValues;
}
private Dictionary<string, string> GetDigitalInSensorValues(int sensorId)
{
var sensorAndCalibrationValues = new Dictionary<string, string>();
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalInGet.ToString();
sensorsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
sensorsCmd.ExecuteNonQuery();
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs == null || sensorsDs.Tables == null || sensorsDs.Tables.Count != 1 ||
sensorsDs.Tables[0].Rows == null || sensorsDs.Tables[0].Rows.Count != 1) return null;
//DIMode 10
sensorAndCalibrationValues["DIMode"] = Convert.ToInt32(sensorsDs.Tables[0].Rows[0]["SettingMode"]).ToString();
var scaleMultiplierArray = Convert.ToString(sensorsDs.Tables[0].Rows[0]["ScaleMultiplier"]).Split(',');
//DefaultValue 11
sensorAndCalibrationValues["DefaultValue"] = scaleMultiplierArray[1];
//ActiveValue 12
sensorAndCalibrationValues["ActiveValue"] = scaleMultiplierArray[2];
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
return sensorAndCalibrationValues;
}
private Dictionary<string, string> GetAnalogSensorAndCalibrationValues(int sensorId)
{
var sensorAndCalibrationValues = new Dictionary<string, string>();
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsAnalogGet.ToString();
sensorsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
sensorsCmd.ExecuteNonQuery();
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs == null || sensorsDs.Tables == null || sensorsDs.Tables.Count != 1 ||
sensorsDs.Tables[0].Rows == null || sensorsDs.Tables[0].Rows.Count != 1) return null;
//Range 1
sensorAndCalibrationValues["Range"] = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["Capacity"]).ToString();
//Polarity 3
sensorAndCalibrationValues["Polarity"] = Convert.ToBoolean(sensorsDs.Tables[0].Rows[0]["Invert"]) ? "-" : "+";
//UserValue1 23
sensorAndCalibrationValues["UserValue1"] = Convert.ToString(sensorsDs.Tables[0].Rows[0]["UserValue1"]);
//UserValue2 24
sensorAndCalibrationValues["UserValue2"] = Convert.ToString(sensorsDs.Tables[0].Rows[0]["UserValue2"]);
//UserValue3 25
sensorAndCalibrationValues["UserValue3"] = Convert.ToString(sensorsDs.Tables[0].Rows[0]["UserValue3"]);
//FilterClass 27
var sensorString = Convert.ToString(sensorsDs.Tables[0].Rows[0]["FilterClass"]);
var settingString = "None,0";
switch (sensorString)
{
case "1650 (CFC1000)":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("A");
break;
case "1000 (CFC600)":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("B");
break;
case "300 (CFC180)":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("C");
break;
case "100 (CFC60)":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("D");
break;
case "None":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("P");
break;
case "Unfiltered":
settingString = Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC("0");
break;
}
sensorAndCalibrationValues["FilterClass"] = settingString;
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
using (var cmd = DbOperations.GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorCalibrationsGet.ToString();
cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
{
if (ds == null || ds.Tables == null || ds.Tables.Count != 1 ||
ds.Tables[0].Rows == null || ds.Tables[0].Rows.Count == 0) return null;
var latestDate = new DateTime();
string latestInitialOffset = string.Empty;
string latestZeroMethod = string.Empty;
foreach (DataRow row in ds.Tables[0].Rows)
{
var modifyDate = Convert.ToDateTime(row["ModifyDate"]);
if (modifyDate > latestDate)
{
latestDate = modifyDate;
latestInitialOffset = Convert.ToString(row["InitialOffset"]);
latestZeroMethod = Convert.ToString(row["ZeroMethod"]);
}
}
//InitialOffset 26
sensorAndCalibrationValues["InitialOffset"] = latestInitialOffset;
var zeroMethodArray = latestZeroMethod.Split(',');
//ZeroMethod 20
sensorAndCalibrationValues["ZeroMethod"] = zeroMethodArray[0];
//ZeroMethodStart 21
sensorAndCalibrationValues["ZeroMethodStart"] = zeroMethodArray[1];
//ZeroMethodEnd 22
sensorAndCalibrationValues["ZeroMethodEnd"] = zeroMethodArray[2];
}
}
finally
{
cmd.Connection.Dispose();
}
}
return sensorAndCalibrationValues;
}
private Dictionary<string, int> GetAllChannelSettings()
{
var dictionary = new Dictionary<string, int>();
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.StoredProcedure;
sql.CommandText = @"sp_ChannelSettingsGet";
sql.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null });
sql.Parameters.Add(new SqlParameter("@SettingName", SqlDbType.NVarChar, 255) { Value = null });
var reader = sql.ExecuteReader();
while (reader.Read())
{
var id = Convert.ToInt32(reader["Id"]);
var name = (string)reader["SettingName"];
dictionary[name] = id;
}
}
finally
{
sql.Connection.Dispose();
}
}
return dictionary;
}
private bool GetSensorType(int sensorId, out SensorConstants.SensorType sensorType)
{
using (var sensorCmd = DbOperations.GetSQLCommand(true))
{
try
{
sensorCmd.CommandType = CommandType.StoredProcedure;
sensorCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsGet.ToString();
sensorCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
sensorCmd.ExecuteNonQuery();
using (var sensorDs = Connection.QueryDataSet(sensorCmd))
{
if (sensorDs == null || sensorDs.Tables == null || sensorDs.Tables.Count != 1 ||
sensorDs.Tables[0].Rows == null || sensorDs.Tables[0].Rows.Count != 1)
{
sensorType = SensorConstants.SensorType.Analog; //can't set null to a non-nullable type
return false; //Cant return null to a non-nullable type
}
if (!Enum.TryParse(sensorDs.Tables[0].Rows[0]["SensorType"].ToString(), out sensorType))
{
return false;
}
return true;
}
}
finally
{
sensorCmd.Connection.Dispose();
}
}
}
private Dictionary<Int64, int> GetChannelIdsAndSensors()
{
var channelSensorDict = new Dictionary<Int64, int>();
using (var channelCmd = GetSQLCommand(true))
{
try
{
channelCmd.CommandType = CommandType.StoredProcedure;
channelCmd.CommandText = @"sp_ChannelsGet";
var reader = channelCmd.ExecuteReader();
while (reader.Read())
{
var channelId = Convert.ToInt64(reader["Id"]);
if ((reader["SensorId"]) != DBNull.Value)
{
var sensorId = Convert.ToInt32(reader["SensorId"]);
channelSensorDict[channelId] = sensorId;
}
}
}
finally
{
channelCmd.Connection.Dispose();
}
}
return channelSensorDict;
}
private void MigrateDigitalOutputMode()
{
const string SYSTEM = "SYSTEM";
const string DEFAULTDIGITALOUTMODE = "DefaultDigitalOutMode";
const string TSDTESTSPECIFIC = "TSD_TestSpecific";
var defaultDigitalOutModeTextValue = string.Empty;
//Get text value from DefaultDigitalOutputMode in Settings table
using (var settingsCmd = GetSQLCommand(true))
{
try
{
settingsCmd.CommandType = CommandType.StoredProcedure;
settingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SettingsGet.ToString();
settingsCmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.NVarChar) { Value = SYSTEM });
settingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar) { Value = DEFAULTDIGITALOUTMODE });
using (var ds = Connection.QueryDataSet(settingsCmd))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
defaultDigitalOutModeTextValue = Convert.ToString(ds.Tables[0].Rows[0][Settings.UserFields.PropertyValue.ToString()]);
}
}
}
finally { settingsCmd.Connection.Dispose(); }
}
//Store it in the OutputMode field of the "TSD_TestSpecific" sensor in the SensorsDigitalOut table
//Get Id from SensorsDigitalOut table for the TSD_TestSpecific sensor
var sensorId = 0;
var outputMode = 0;
var delayMS = 0;
var limitDuration = false;
var durationMSFloat = 0.0D;
var lastModified = DateTime.Now;
var lastModifiedBy = string.Empty;
var version = 0;
var userTags = new byte[0];
var doNotUse = false;
var broken = false;
using (var sensorsDigitalOutGetCmd = GetSQLCommand(true))
{
try
{
sensorsDigitalOutGetCmd.CommandType = CommandType.StoredProcedure;
sensorsDigitalOutGetCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalOutGet.ToString();
sensorsDigitalOutGetCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 50) { Value = TSDTESTSPECIFIC });
sensorsDigitalOutGetCmd.ExecuteNonQuery();
using (var sensorDs = Connection.QueryDataSet(sensorsDigitalOutGetCmd))
{
if (sensorDs != null && sensorDs.Tables != null && sensorDs.Tables.Count == 1 &&
sensorDs.Tables[0].Rows != null && sensorDs.Tables[0].Rows.Count == 1)
{
sensorId = Convert.ToInt32(sensorDs.Tables[0].Rows[0]["id"]);
outputMode = Convert.ToInt32(sensorDs.Tables[0].Rows[0]["OutputMode"]);
delayMS = Convert.ToInt32(sensorDs.Tables[0].Rows[0]["DelayMS"]);
limitDuration = Convert.ToBoolean(sensorDs.Tables[0].Rows[0]["LimitDuration"]);
durationMSFloat = Convert.ToDouble(sensorDs.Tables[0].Rows[0]["DurationMSFloat"]);
lastModified = Convert.ToDateTime(sensorDs.Tables[0].Rows[0]["LastModified"]);
lastModifiedBy = Convert.ToString(sensorDs.Tables[0].Rows[0]["LastModifiedBy"]);
version = Convert.ToInt32(sensorDs.Tables[0].Rows[0]["Version"]);
userTags = (byte[])sensorDs.Tables[0].Rows[0]["UserTags"];
doNotUse = Convert.ToBoolean(sensorDs.Tables[0].Rows[0]["DoNotUse"]);
broken = Convert.ToBoolean(sensorDs.Tables[0].Rows[0]["Broken"]);
}
}
}
finally
{
sensorsDigitalOutGetCmd.Connection.Dispose();
}
}
//Store value converted from text to int into OutputMode field.
using (var sensorsDigitalOutUpdateCmd = GetSQLCommand(true))
{
try
{
sensorsDigitalOutUpdateCmd.CommandType = CommandType.StoredProcedure;
sensorsDigitalOutUpdateCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalOutUpdate.ToString();
#region params
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = sensorId });
Enum.TryParse(defaultDigitalOutModeTextValue, out DigitalOutputModes defaultDigitalOutModeIntValue);
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@OutputMode", SqlDbType.SmallInt) { Value = defaultDigitalOutModeIntValue });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@DelayMS", SqlDbType.Float) { Value = delayMS });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@LimitDuration", SqlDbType.Bit) { Value = limitDuration });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@DurationMSFloat", SqlDbType.Float) { Value = durationMSFloat });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = lastModified });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar) { Value = lastModifiedBy });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@Version", SqlDbType.Int) { Value = version });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@UserTags", SqlDbType.Binary) { Value = userTags });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@DoNotUse", SqlDbType.Bit) { Value = doNotUse });
sensorsDigitalOutUpdateCmd.Parameters.Add(new SqlParameter("@Broken", SqlDbType.Bit) { Value = broken });
var errorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
sensorsDigitalOutUpdateCmd.Parameters.Add(errorNumberParam);
var errorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
sensorsDigitalOutUpdateCmd.Parameters.Add(errorMessageParam);
#endregion params
sensorsDigitalOutUpdateCmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
throw new Exception((string)errorMessageParam.Value);
}
}
finally
{
sensorsDigitalOutUpdateCmd.Connection.Dispose();
}
}
}
private void AddSquibNonDefaultSettings(List<Int64> squibChannelIdList)
{
foreach (var squibChannelId in squibChannelIdList)
{
//We don't want to stomp on any settings already set for this channel
var squibSettingsAlreadySet = GetChannelSettings(squibChannelId);
//We don't want to waste time setting something to a default value if
//it's not set to anything because it will use the default value anyway.
var squibDefaults = new Dictionary<string, string>();
squibDefaults["DelayMS"] = GetSquibDefault(SensorConstants.SensorSettings.SquibDelay);
squibDefaults["DurationMS"] = GetSquibDefault(SensorConstants.SensorSettings.SquibDuration);
squibDefaults["FireMode"] = GetSquibDefault(SensorConstants.SensorSettings.SQMode);
squibDefaults["SquibOutputCurrent"] = GetSquibDefault(SensorConstants.SensorSettings.SquibCurrent);
squibDefaults["LimitDuration"] = GetSquibDefault(SensorConstants.SensorSettings.SquibLimitDuration);
SetNonDefaultSquibValues(squibChannelId, squibSettingsAlreadySet, squibDefaults);
}
}
private string GetSquibDefault(SensorConstants.SensorSettings setting)
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.StoredProcedure;
sql.CommandText = @"sp_ChannelSettingsGet";
sql.Parameters.Add(new SqlParameter("@SettingName", SqlDbType.NVarChar, 255) { Value = setting });
var reader = sql.ExecuteReader();
if (reader.Read())
{
return (string)reader["DefaultValue"];
}
}
finally
{
sql.Connection.Dispose();
}
}
return string.Empty;
}
private List<int> GetChannelSettings(long channelId)
{
var channelSettings = new List<int>();
using (var groupChannelSettingsCmd = GetSQLCommand(true))
{
try
{
groupChannelSettingsCmd.CommandType = CommandType.StoredProcedure;
groupChannelSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupChannelSettingsGet.ToString();
#region params
groupChannelSettingsCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
#endregion params
var reader = groupChannelSettingsCmd.ExecuteReader();
while (reader.Read())
{
try
{
var groupChannelSettingId = Convert.ToInt16(reader["SettingId"]);
channelSettings.Add(groupChannelSettingId);
}
catch (Exception ex)
{
APILogger.Log("Failed to load Group Channel Settings: ", ex);
}
}
reader.Close();
}
finally
{
groupChannelSettingsCmd.Connection.Dispose();
}
}
return channelSettings;
}
private void SetNonDefaultSquibValues(Int64 squibChannelId,
List<int> squibSettingsAlreadySet,
Dictionary<string, string> squibDefaults)
{
using (var squibValuesCmd = GetSQLCommand(true))
{
try
{
squibValuesCmd.CommandType = CommandType.Text;
squibValuesCmd.CommandText = "SELECT S.DelayMS, S.DurationMS, S.FireMode, S.SquibOutputCurrent, S.LimitDuration" +
" from[SensorsSquib] as S inner join Channels as C on C.SensorId = S.SensorId WHERE C.Id = " + squibChannelId;
using (var squibValueReader = squibValuesCmd.ExecuteReader())
{
while (squibValueReader.Read())
{
if (!squibSettingsAlreadySet.Contains((int)SensorConstants.SensorSettings.SquibDelay + 1) && //14 + 1
(Convert.ToString(squibValueReader["DelayMS"]) != squibDefaults["DelayMS"]))
{
AddSquibNonDefaultSettings(squibChannelId, SensorConstants.SensorSettings.SquibDelay, Convert.ToString(squibValueReader["DelayMS"]));
}
if (!squibSettingsAlreadySet.Contains((int)SensorConstants.SensorSettings.SquibDuration + 1) && //13 + 1
(Convert.ToString(squibValueReader["DurationMS"]) != squibDefaults["DurationMS"]))
{
AddSquibNonDefaultSettings(squibChannelId, SensorConstants.SensorSettings.SquibDuration, Convert.ToString(squibValueReader["DurationMS"]));
}
if (!squibSettingsAlreadySet.Contains((int)SensorConstants.SensorSettings.SQMode + 1) && //8 + 1
(Convert.ToString(squibValueReader["FireMode"]) != squibDefaults["FireMode"]))
{
AddSquibNonDefaultSettings(squibChannelId, SensorConstants.SensorSettings.SQMode, Convert.ToString(squibValueReader["FireMode"]));
}
if (!squibSettingsAlreadySet.Contains((int)SensorConstants.SensorSettings.SquibCurrent + 1) && //18 + 1
(Convert.ToString(squibValueReader["SquibOutputCurrent"]) != squibDefaults["SquibOutputCurrent"]))
{
AddSquibNonDefaultSettings(squibChannelId, SensorConstants.SensorSettings.SquibCurrent, Convert.ToString(squibValueReader["SquibOutputCurrent"]));
}
if (!squibSettingsAlreadySet.Contains((int)SensorConstants.SensorSettings.SquibLimitDuration + 1) && //12 + 1
(Convert.ToString(squibValueReader["LimitDuration"]) != squibDefaults["LimitDuration"]))
{
AddSquibNonDefaultSettings(squibChannelId, SensorConstants.SensorSettings.SquibLimitDuration, Convert.ToString(squibValueReader["LimitDuration"]));
}
}
}
}
finally
{
squibValuesCmd.Connection.Dispose();
}
}
}
private List<Int64> RemoveUnrelatedChannelSettings(SetStatusDelegate SetStatus)
{
var squibChannelIdList = new List<Int64>();
//Get each Channel's sensor type
using (var channelCmd = GetSQLCommand(true))
{
try
{
channelCmd.CommandType = CommandType.Text;
channelCmd.CommandText = "SELECT COUNT(*) FROM Channels WHERE SensorId <> '' ";
var channelCount = channelCmd.ExecuteScalar();
var count = 0;
channelCmd.CommandText = "SELECT C.Id, S.SensorType from[Sensors] as S inner join Channels as C on C.SensorId = S.Id";
var reader = channelCmd.ExecuteReader();
while (reader.Read())
{
count++;
SetStatus("Migrating GroupChannelSettings table (Channel " + count + "/" + channelCount + ")");
if (Enum.TryParse(reader["SensorType"].ToString(), out SensorConstants.SensorType sensorType))
{
using (var groupChannelSettingsCmd = GetSQLCommand(true))
{
try
{
groupChannelSettingsCmd.CommandType = CommandType.StoredProcedure;
groupChannelSettingsCmd.CommandText = @"sp_GroupChannelSettingsDelete";
var channelId = Convert.ToInt64(reader["Id"]);
groupChannelSettingsCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupChannelSettingsCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
groupChannelSettingsCmd.Parameters.Add(errorMessage);
//Remove all settings in GroupChannelSettings that don't apply to this Channel
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.OutputMode); //8
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SQMode); //9
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DIMode); //10
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DefaultValue); //11
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.ActiveValue); //12
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibLimitDuration); //13
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDuration); //14
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDelay); //15
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutLimitDuration); //16
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDuration); //17
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDelay); //18
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibCurrent); //19
break;
case SensorConstants.SensorType.DigitalIn:
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Range); //1
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.CFC); //2
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Polarity); //3
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.OutputMode); //8
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SQMode); //9
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibLimitDuration); //13
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDuration); //14
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDelay); //15
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutLimitDuration); //16
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDuration); //17
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDelay); //18
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibCurrent); //19
break;
case SensorConstants.SensorType.Squib:
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Range); //1
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.CFC); //2
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Polarity); //3
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.OutputMode); //8
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DIMode); //10
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DefaultValue); //11
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.ActiveValue); //12
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutLimitDuration); //16
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDuration); //17
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DigitalOutDelay); //18
squibChannelIdList.Add(channelId);
break;
case SensorConstants.SensorType.DigitalOut:
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Range); //1
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.CFC); //2
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.Polarity); //3
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SQMode); //9
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DIMode); //10
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.DefaultValue); //11
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.ActiveValue); //12
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibLimitDuration); //13
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDuration); //14
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibDelay); //15
RemoveUnrelatedChannelSetting(groupChannelSettingsCmd, SensorConstants.SensorSettings.SquibCurrent); //19
break;
}
if (null != errorNumber.Value && !DBNull.Value.Equals(errorNumber.Value))
{
if (0 != Convert.ToInt32(errorNumber.Value))
{
throw new Exception((string)errorMessage.Value);
}
}
}
finally
{
groupChannelSettingsCmd.Connection.Dispose();
}
}
}
}
}
finally
{
channelCmd.Connection.Dispose();
}
}
return squibChannelIdList;
}
private void AddSquibNonDefaultSettings(Int64 channelId, SensorConstants.SensorSettings settingId, string settingValue)
{
using (var groupChannelSettingsCmd = GetSQLCommand(true))
{
try
{
groupChannelSettingsCmd.CommandType = CommandType.StoredProcedure;
groupChannelSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupChannelSettingsInsert.ToString();
#region params
groupChannelSettingsCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
groupChannelSettingsCmd.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = (int)settingId + 1 });
groupChannelSettingsCmd.Parameters.Add(new SqlParameter("@SettingValue", SqlDbType.NVarChar, 255) { Value = settingValue });
var channelErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupChannelSettingsCmd.Parameters.Add(channelErrorNumberParam);
var channelErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
groupChannelSettingsCmd.Parameters.Add(channelErrorMessageParam);
#endregion params
groupChannelSettingsCmd.ExecuteNonQuery();
if (int.Parse(channelErrorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(channelErrorMessageParam.Value.ToString());
}
}
finally
{
groupChannelSettingsCmd.Connection.Dispose();
}
}
}
private void RemoveUnrelatedChannelSetting(SqlCommand groupChannelSettingsCmd, SensorConstants.SensorSettings setting)
{
var param = new SqlParameter("@SettingId", SqlDbType.BigInt) { Value = (int)setting + 1 };
groupChannelSettingsCmd.Parameters.Add(param);
groupChannelSettingsCmd.ExecuteNonQuery();
groupChannelSettingsCmd.Parameters.Remove(param);
}
private void InsertStaticGroupIds(SetStatusDelegate SetStatus)
{
SetStatus("Setting StaticGroupIds...");
var serialNumberToIdMapping = new Dictionary<string, int>();
using (var staticGroup = GetSQLCommand(true))
{
try
{
staticGroup.CommandType = CommandType.StoredProcedure;
staticGroup.CommandText = @"sp_GroupsGet";
staticGroup.Parameters.Add(new SqlParameter("@Embedded", SqlDbType.Bit) { Value = false });
var reader = staticGroup.ExecuteReader();
//Make a list of all of the static Groups' DisplayName/Id pairs
while (reader.Read())
{
serialNumberToIdMapping[Convert.ToString(reader["DisplayName"])] = Convert.ToInt32(reader["Id"]);
}
}
finally
{
staticGroup.Connection.Dispose();
}
}
using (var embeddedGroup = GetSQLCommand(true))
{
try
{
embeddedGroup.CommandType = CommandType.StoredProcedure;
embeddedGroup.CommandText = @"sp_GroupsGet";
embeddedGroup.Parameters.Add(new SqlParameter("@Embedded", SqlDbType.Bit) { Value = true });
var reader = embeddedGroup.ExecuteReader();
//Update any Groups' StaticGroupId
while (reader.Read())
{
using (var updateGroup = GetSQLCommand(true))
{
try
{
if (serialNumberToIdMapping.ContainsKey(Convert.ToString(reader["DisplayName"])))
{
updateGroup.CommandType = CommandType.StoredProcedure;
updateGroup.CommandText = @"sp_GroupsUpdate";
updateGroup.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = Convert.ToString(reader["Id"]) });
updateGroup.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 255) { Value = Convert.ToString(reader["SerialNumber"]) });
updateGroup.Parameters.Add(new SqlParameter("@DisplayName", SqlDbType.NVarChar, 255) { Value = Convert.ToString(reader["DisplayName"]) });
updateGroup.Parameters.Add(new SqlParameter("@Description", SqlDbType.NVarChar, 255) { Value = Convert.ToString(reader["Description"]) });
updateGroup.Parameters.Add(new SqlParameter("@Embedded", SqlDbType.Bit) { Value = Convert.ToString(reader["Embedded"]) });
updateGroup.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = Convert.ToString(reader["LastModified"]) });
updateGroup.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 50) { Value = Convert.ToString(reader["LastModifiedBy"]) });
updateGroup.Parameters.Add(new SqlParameter("@StaticGroupId", SqlDbType.Int) { Value = serialNumberToIdMapping[Convert.ToString(reader["DisplayName"])] });
var groupErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
updateGroup.Parameters.Add(groupErrorNumberParam);
var groupErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
updateGroup.Parameters.Add(groupErrorMessageParam);
updateGroup.ExecuteNonQuery();
}
}
finally
{
updateGroup.Connection.Dispose();
}
}
}
}
finally
{
embeddedGroup.Connection.Dispose();
}
}
}
private void MigrateTestSetupHardwareSamplesPerSecond(SetStatusDelegate SetStatus)
{
SetStatus("Migrating TestSetupHardwareSamplesPerSecond...");
using (var testSetupsGetCmd = GetSQLCommand(true))
{
try
{
testSetupsGetCmd.CommandType = CommandType.Text;
testSetupsGetCmd.CommandText = "SELECT COUNT(*) FROM TestSetups";
var testSetupCount = testSetupsGetCmd.ExecuteScalar();
var count = 0;
testSetupsGetCmd.CommandType = CommandType.StoredProcedure;
//Get all Test Setups
testSetupsGetCmd.CommandText = "sp_TestSetupsGet";
testSetupsGetCmd.Parameters.Clear();
var testSetupReader = testSetupsGetCmd.ExecuteReader();
while (testSetupReader.Read())
{
count++;
SetStatus("Migrating TestSetupHardware table (Test Setup " + count + "/" + testSetupCount + ")");
var testSetupId = Convert.ToInt32(testSetupReader["TestSetupId"]);
var samplesPerSecond = Convert.ToDouble(testSetupReader["SamplesPerSecond"]);
//Get all Hardware in this Test Setup
using (var testSetupHardwareCmd = GetSQLCommand(true))
{
try
{
testSetupHardwareCmd.CommandType = CommandType.StoredProcedure;
testSetupHardwareCmd.CommandText = "sp_TestSetupHardwareGet";
testSetupHardwareCmd.Parameters.Clear();
testSetupHardwareCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
var testSetupHardwareReader = testSetupHardwareCmd.ExecuteReader();
while (testSetupHardwareReader.Read())
{
var dasId = Convert.ToInt32(testSetupHardwareReader["DASId"]);
var addOrRemove = Convert.ToBoolean(testSetupHardwareReader["AddOrRemove"]);
using (var testSetupHardwareUpdateCmd = GetSQLCommand(true))
{
try
{
testSetupHardwareUpdateCmd.CommandType = CommandType.StoredProcedure;
testSetupHardwareUpdateCmd.CommandText = "sp_TestSetupHardwareUpdate";
testSetupHardwareUpdateCmd.Parameters.Clear();
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@AddOrRemove", SqlDbType.Bit) { Value = addOrRemove });
testSetupHardwareUpdateCmd.Parameters.Add(new SqlParameter("@SamplesPerSecond", SqlDbType.Float) { Value = samplesPerSecond });
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupHardwareUpdateCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
testSetupHardwareUpdateCmd.Parameters.Add(errorMessage);
testSetupHardwareUpdateCmd.ExecuteNonQuery();
}
finally
{
testSetupHardwareUpdateCmd.Connection.Dispose();
}
}
}
}
finally
{
testSetupHardwareCmd.Connection.Dispose();
}
}
}
}
finally
{
testSetupsGetCmd.Connection.Dispose();
}
}
}
private bool MigrateVersion70(SetStatusDelegate SetStatus, string dbName)
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION70");
Transaction(cmd, "BEGIN", 70);
//Build all tables
MigrateToISOSimplification(SetStatus, dbName);
cmd.Parameters.Clear();
log.WriteEntry("Issuing COMMIT TRANSACTION70");
Transaction(cmd, "COMMIT", 70);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION70");
Transaction(cmd, "ROLLBACK", 70);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
public void MigrateToISOSimplification(SetStatusDelegate SetStatus, string dbName)
{
//Copy unchanged data from DataPROPre20.mdf
ResetLocalConnectionStringDb(dbName + "Pre20"); //Use for DataPROPre20 db when migrating to DataPRO db
//Needed before Test Setups
CopyUnchangedOrNewFieldsOnlyTable("CustomerDetails", "CustomerId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("LabratoryDetails", "LabratoryId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("TestEngineerDetails", "TestEngineerId", 0, SetStatus, dbName);
RemoveNonExistentIdsFromTestSetups(dbName);
CopyUnchangedOrNewFieldsOnlyTable("TestSetups", "TestSetupId", 0, SetStatus, dbName); //Needed before inserting into LevelTriggers table
MigrateTestSetupCaches();
InsertDefaultCalibrationBehavior(dbName);
CopyUnchangedOrNewFieldsOnlyTable("CalculatedChannels", "Id", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("SensorModels", "SensorModelId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("Tags", "TagId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("TagAssignments", "ObjectID", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("LockedItemCategories", "CategoryId", 0, SetStatus, dbName);
//Don't assume that the Users table will contain Admin, PowerUser, User, and Guest at IDs 1-4
ClearTable("UserProperties"); //Cannot clear the Users table until this is cleared
ClearTable("UIItemSettings"); //Cannot clear the UIItems and Users tables until this is cleared
ClearTable("UIItems"); //Remove the pre-loaded UIItems in case the source db has different IDs
ClearTable("Users"); //Remove the 4 pre-loaded users in case the source db has modified them
CopyUnchangedOrNewFieldsOnlyTable("Users", "ID", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("UserProperties", "UserId", 0, SetStatus, dbName);
//Since we cleared the UserProperties table above to match the UserId field,
//we need to re-insert the properties that are new in this version of DataPRO.
InsertNewDefaultUserProperties(dbName);
CopyUnchangedOrNewFieldsOnlyTable("UIItems", "ID", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("UIItemSettings", "UserID", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("LockedItems", "LockId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("TestSetupObjectMetaData", "MetaDataId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("TestSetupSettings", "TestSetupId", 0, SetStatus, dbName);
MigrateSettingsTable(SetStatus, dbName);
MigrateDigitalOutputMode(); //Set the OutputMode field of the SensorsDigitalOut table based on the DefaultDigitalOutMode value in the Settings table
//Build Sensors and Sensors<x> tables
BuildSensorTables(SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("SensorCalibrations", "SensorCalibrationId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("SensorCalibrationRecord", "SensorCalibrationRecordId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("SensorCalibrationRecordPolynomial", "recId", 0, SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("SensorCalibrationRecordIRTracc", "recId", 0, SetStatus, dbName); //This may not be used; if so, it will be empty
CopyUnchangedOrNewFieldsOnlyTable("DAS", "DASId", 366, SetStatus, dbName); //Needed for the migration of the TestSetupHardware table
MigrateTestSetupHardwareTable(SetStatus, dbName);
CopyUnchangedOrNewFieldsOnlyTable("DASChannels", "DASId", 366, SetStatus, dbName);
List<GroupChannelHelper> groupChannelHelpers = new List<GroupChannelHelper>();
//Build Groups table
BuildGroupsTable(SetStatus, ref groupChannelHelpers, dbName);
//this needs a migration step, to come later.
CopyUnchangedOrNewFieldsOnlyTable("TestGraphs", "GraphId", 0, SetStatus, dbName);
//the structure hasn't changed, we just need to update the channel id's, so above copies it in
//and below fixes the channel ids.
FixGraphReferences(groupChannelHelpers, dbName);
FixCalculatedChannelReferences(groupChannelHelpers, dbName);
//Build ChannelCodes table
BuildChannelCodesTable(SetStatus, dbName);
ResetLocalConnectionStringDb(dbName); //Use regular db in the future
SetStatus("Done with migration to ISO simplification!");
}
/// <summary>
/// This "cleans" Test Setups so that migration of the TestSetups table does
/// not fail due to a FOREIGN KEY conflict with FK_TestSetups_CustomerDetails.
/// This is because when a Customer is deleted, its CustomerId is not updated in any Test Setups.
/// </summary>
/// <param name="dbName"></param>
private void RemoveNonExistentIdsFromTestSetups(string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandText = $"UPDATE TestSetups SET CustomerId = 0 WHERE CustomerId NOT IN (SELECT CustomerId from CustomerDetails)";
cmd.ExecuteNonQuery();
cmd.CommandText = $"UPDATE TestSetups SET TestEngineerId = 0 WHERE TestEngineerId NOT IN (SELECT TestEngineerId from TestEngineerDetails)";
cmd.ExecuteNonQuery();
cmd.CommandText = $"UPDATE TestSetups SET LabratoryId = 0 WHERE LabratoryId NOT IN (SELECT LabratoryId from LabratoryDetails)";
cmd.ExecuteNonQuery();
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void InsertNewDefaultUserProperties(string dbName)
{
ResetLocalConnectionStringDb(dbName);
var defaultProperties = GetAllDefaultPropertyValues();
var userIdList = GetAllUserIds();
foreach (var userId in userIdList)
{
foreach (var defaultProperty in defaultProperties)
{
if (!UserPropertiesRecordExists(userId, defaultProperty.Item1))
{
SetUserProperty(userId, defaultProperty.Item1, defaultProperty.Item2);
}
}
}
}
/// <summary>
/// Get all of the system default property values
/// </summary>
/// <returns></returns>
private List<Tuple<int, string>> GetAllDefaultPropertyValues()
{
var properties = new List<Tuple<int, string>>();
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DefaultPropertiesGet.ToString();
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = null });
using (var ds = Connection.QueryDataSet(cmd))
{
properties.AddRange(from DataRow row in ds.Tables[0].Rows
let id = Convert.ToInt32(row["PropertyId"])
let value = Convert.ToString(row["DefaultValue"])
select new Tuple<int, string>(id, value));
}
}
finally { cmd.Connection.Dispose(); }
}
return properties;
}
/// <summary>
/// Get all of the ID values from the Users table
/// </summary>
/// <returns></returns>
private List<int> GetAllUserIds()
{
var userIdList = new List<int>();
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_UsersGetIdsAll"; //sp_UserGetIdsAll in DataPROPre20.mdf; sp_UsersGetIdsAll DataPRO.mdf!
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
userIdList.Add(Convert.ToInt32(dr[Users.UserFields.ID.ToString()]));
}
}
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception)
{
//Ignore
}
return userIdList;
}
private void InsertBooleanDefaultProperty(int propertyId, string propertyName, bool defaultPropertyValue)
{
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DefaultPropertiesInsert.ToString();
#region params
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = propertyId });
cmd.Parameters.Add(new SqlParameter("@PropertyName", SqlDbType.NVarChar) { Value = propertyName });
cmd.Parameters.Add(new SqlParameter("@DefaultValue", SqlDbType.NVarChar) { Value = defaultPropertyValue ? "True" : "False" });
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 params
cmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
//errorMessageParam.Value
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void SetUserProperty(int userId, int propertyId, string propertyValue)
{
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_UserPropertiesInsert.ToString();
#region params
cmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.Int) { Value = userId });
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = propertyId });
cmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar) { Value = propertyValue });
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 params
cmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
//errorMessageParam.Value
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void ClearTable(string tableName)
{
ResetLocalConnectionStringDb("DataPRO");
using (var CMD = GetSQLCommand(true))
{
CMD.CommandText = $"DELETE FROM [dbo].[{tableName}]";
CMD.ExecuteNonQuery();
CMD.Connection.Dispose();
}
}
//separates the old pre 2.0 channel concatanated references into just a string channel reference
public static string[] GetChannelsFromSQL(string channels)
{
List<string> list = new List<string>();
channels = channels.Replace("{", "").Replace("}", "");
var tokens = channels.Split(new[] { "§" }, StringSplitOptions.None);
foreach (var token in tokens)
{
var sChannelId = token.Replace("(", "").Replace(")", "");
list.Add(sChannelId);
}
return list.ToArray();
}
//fixes pre 2.0 channel id referens for graphs to the new version
private void FixGraphReferences(List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
var lookup = new Dictionary<string, long>();
foreach (var groupChannel in groupChannelHelpers)
{
var key = $"{groupChannel.TestObjectName}_{groupChannel.MMEChannelType}_{groupChannel.MMEChannelId}";
lookup[key] = groupChannel.ChannelId;
}
//get PRE2.0 db
ResetLocalConnectionStringDb(dbName + "Pre20");
var toSet = new List<Tuple<int, string>>();
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = "SELECT [GraphId], [Channels] FROM [TestGraphs]";
var reader = sql.ExecuteReader();
while (reader.Read())
{
var graphId = Convert.ToInt32(reader["GraphId"]);
var sChannels = (string)reader["Channels"];
var channels = GetChannelsFromSQL(sChannels);
var newIds = new List<string>();
foreach (var ch in channels.Where(x => lookup.ContainsKey(x)))
{
newIds.Add(lookup[ch].ToString());
}
toSet.Add(new Tuple<int, string>(graphId, string.Join(",", newIds.ToArray())));
}
}
finally
{
sql.Connection.Dispose();
}
}
if (toSet.Any())
{
//get the future db
ResetLocalConnectionStringDb(dbName);
foreach (var next in toSet)
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = $"UPDATE [TestGraphs] SET [Channels]=@1 WHERE [GraphId]=@2";
sql.Parameters.Add(new SqlParameter("@1", SqlDbType.NVarChar, 255) { Value = next.Item2 });
sql.Parameters.Add(new SqlParameter("@2", SqlDbType.Int) { Value = next.Item1 });
sql.ExecuteNonQuery();
}
finally
{
sql.Connection.Dispose();
}
}
}
}
}
// FB13194: fixes pre 2.0 channel id references for calculated channels to the new version
private void FixCalculatedChannelReferences(List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
var lookup = new Dictionary<string, long>();
foreach (var groupChannel in groupChannelHelpers)
{
var key = $"{groupChannel.TestObjectName}_{groupChannel.MMEChannelType}_{groupChannel.MMEChannelId}";
lookup[key] = groupChannel.ChannelId;
}
//get PRE2.0 db
ResetLocalConnectionStringDb(dbName + "Pre20");
var toSet = new List<Tuple<int, byte[]>>();
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = "SELECT [Id], [InputChannelIds] FROM [CalculatedChannels]";
var reader = sql.ExecuteReader();
while (reader.Read())
{
var ccId = Convert.ToInt32(reader["Id"]);
var ccChannels = Encoding.UTF8.GetString((byte[])reader["InputChannelIds"]).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var newIds = new List<string>();
foreach (var ch in ccChannels.Where(x => lookup.ContainsKey(x)))
{
newIds.Add(lookup[ch].ToString());
}
toSet.Add(new Tuple<int, byte[]>(ccId, Encoding.UTF8.GetBytes(string.Join(",", newIds.ToArray()))));
}
}
finally
{
sql.Connection.Dispose();
}
}
if (toSet.Any())
{
//get the future db
ResetLocalConnectionStringDb(dbName);
foreach (var next in toSet)
{
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = $"UPDATE [CalculatedChannels] SET [InputChannelIds]=@1 WHERE [Id]=@2";
sql.Parameters.Add(new SqlParameter("@1", SqlDbType.VarBinary) { Value = next.Item2 });
sql.Parameters.Add(new SqlParameter("@2", SqlDbType.Int) { Value = next.Item1 });
sql.ExecuteNonQuery();
}
finally
{
sql.Connection.Dispose();
}
}
}
}
}
private void InsertDefaultCalibrationBehavior(string dbName)
{
ResetLocalConnectionStringDb(dbName);
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = "UPDATE [TestSetups] SET CalibrationBehavior = 1";
sql.ExecuteNonQuery();
}
finally
{
sql.Connection.Dispose();
}
}
}
private void MigrateTestSetupCaches()
{
var testSetupNamesAndCaches = GetAllUnmigratedTestSetupCaches();
foreach (var testSetupNameAndCache in testSetupNamesAndCaches)
{
var migratedCache = MigrateCache(testSetupNameAndCache.Value);
var migratedCacheBinary = new byte[0]; //Fix this so that it sets the migrated cache
using (var sql = GetSQLCommand(true))
{
try
{
sql.CommandType = CommandType.Text;
sql.CommandText = "UPDATE [TestSetups] SET TestSetup=@TestSetup WHERE TestSetupName=@TestSetupName";
sql.Parameters.Add(new SqlParameter("@TestSetup", SqlDbType.Binary) { Value = migratedCacheBinary });
sql.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = testSetupNameAndCache.Key });
sql.ExecuteNonQuery();
}
finally
{
sql.Connection.Dispose();
}
}
}
}
private string MigrateCache(string unmigratedCache)
{
return string.Empty; //Fix this to migrate the cache from 1.10 to 2.0
}
private Dictionary<string, string> GetAllUnmigratedTestSetupCaches()
{
var testSetupNamesAndCaches = new Dictionary<string, string>();
using (var testSetupCmd = GetSQLCommand(true))
{
try
{
testSetupCmd.CommandType = CommandType.StoredProcedure;
testSetupCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupsGet.ToString();
#region params
//Both null so we get them all
#endregion params
using (var testSetupDs = Connection.QueryDataSet(testSetupCmd))
{
if (testSetupDs.Tables.Count > 0 && testSetupDs.Tables[0].Rows.Count > 0)
{
foreach (DataRow testSetupDr in testSetupDs.Tables[0].Rows)
{
var oSetup = testSetupDr["TestSetup"];
if (!DBNull.Value.Equals(oSetup))
{
var bytes = (byte[])oSetup;
var buffer = new byte[4096];
using (var sr = new MemoryStream(bytes))
{
using (GZipStream gs = new GZipStream(sr, CompressionMode.Decompress,
false))
{
using (MemoryStream ms = new MemoryStream(4096))
{
try
{
int count = gs.Read(buffer, 0, buffer.Length);
while (count > 0)
{
ms.Write(buffer, 0, count);
count = gs.Read(buffer, 0, buffer.Length);
}
gs.Close();
ms.Flush();
var str = Encoding.UTF8.GetString(ms.GetBuffer());
testSetupNamesAndCaches[Convert.ToString(testSetupDr["SetupName"])] = str;
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
}
}
}
}
}
}
}
finally { testSetupCmd.Connection.Dispose(); }
}
return testSetupNamesAndCaches;
}
private void MigrateTestSetupHardwareTable(SetStatusDelegate SetStatus, string dbName)
{
SetStatus("Migrating TestSetupHardware table...");
ResetLocalConnectionStringDb(dbName + "Pre20");
//For every entry in the old TestSetupsHardware table, use the TestSetupId to get that Test Setup's SamplesPerSecond value
//and assign it to the SamplesPerSecond column in the new TestSetupsHardware table.
using (var testSetupsHardwareGetCmd = GetSQLCommand(true))
{
try
{
testSetupsHardwareGetCmd.CommandType = CommandType.StoredProcedure;
//Get all TestSetupHardware rows
testSetupsHardwareGetCmd.CommandText = "sp_TestSetupHardwareGet";
testSetupsHardwareGetCmd.Parameters.Clear();
var testSetupHardwareReader = testSetupsHardwareGetCmd.ExecuteReader();
while (testSetupHardwareReader.Read())
{
var dasId = Convert.ToInt32(testSetupHardwareReader["DASId"]);
var testSetupId = Convert.ToInt32(testSetupHardwareReader["TestSetupId"]);
var addOrRemove = Convert.ToBoolean(testSetupHardwareReader["AddOrRemove"]);
//Get the Test Setup associated with this row
using (var testSetupCmd = GetSQLCommand(true))
{
try
{
testSetupCmd.CommandType = CommandType.StoredProcedure;
testSetupCmd.CommandText = "sp_TestSetupsGet";
testSetupCmd.Parameters.Clear();
testSetupCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
var testSetupReader = testSetupCmd.ExecuteReader();
while (testSetupReader.Read())
{
var samplesPerSecond = Convert.ToDouble(testSetupReader["SamplesPerSecond"]);
ResetLocalConnectionStringDb(dbName);
using (var testSetupHardwareInsertCmd = GetSQLCommand(true))
{
try
{
testSetupHardwareInsertCmd.CommandType = CommandType.StoredProcedure;
testSetupHardwareInsertCmd.CommandText = "sp_TestSetupHardwareInsert";
testSetupHardwareInsertCmd.Parameters.Clear();
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@AddOrRemove", SqlDbType.Bit) { Value = addOrRemove });
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@SamplesPerSecond", SqlDbType.Float) { Value = samplesPerSecond });
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@IsClockMaster", SqlDbType.Bit) { Value = false }); //Not in pre-2.0 dbs
testSetupHardwareInsertCmd.Parameters.Add(new SqlParameter("@AntiAliasFilterRate", SqlDbType.Float) { Value = 0 }); //Not in pre-2.0 dbs
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupHardwareInsertCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
testSetupHardwareInsertCmd.Parameters.Add(errorMessage);
testSetupHardwareInsertCmd.ExecuteNonQuery();
}
finally
{
testSetupHardwareInsertCmd.Connection.Dispose();
}
}
}
}
finally
{
testSetupCmd.Connection.Dispose();
}
}
}
}
finally
{
testSetupsHardwareGetCmd.Connection.Dispose();
}
}
}
private void MigrateSettingsTable(SetStatusDelegate SetStatus, string dbName)
{
SetStatus("Migrating Settings table...");
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var oldSettingsCmd = GetSQLCommand(true))
{
try
{
oldSettingsCmd.CommandType = CommandType.StoredProcedure;
oldSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SettingsGet.ToString();
oldSettingsCmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.NVarChar) { Value = "SYSTEM" });
oldSettingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar) { Value = null });
using (var ds = Connection.QueryDataSet(oldSettingsCmd))
{
ResetLocalConnectionStringDb(dbName);
using (var newSettingsCmd = GetSQLCommand(true))
{
try
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
if (Convert.ToString(dr["PropertyId"]) == "ShowISOCodes") continue; //Now, ShowISOCodes is set based on IsoSupportLevel
newSettingsCmd.CommandType = CommandType.StoredProcedure;
newSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SettingsUpdate.ToString(); //Only update existing, don't insert deprecated Settings
if (Convert.ToString(dr["PropertyId"]) == "IsoSupportLevel")
{
//We need to set 2 properties (ShowISOCodes and ShowUserCodes) based on this value, so do 1 and then the other
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar, 255) { Value = "ShowISOCodes" });
switch (Convert.ToString(dr["PropertyValue"]))
{
case "ISO_ONLY":
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "True" });
break;
case "TRANSITORY":
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "True" });
break;
case "NO_ISO":
default:
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "False" });
break;
}
newSettingsCmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.NVarChar, 255) { Value = Convert.ToString(dr["UserId"]) });
var errorNumberParamShowISOCode = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
newSettingsCmd.Parameters.Add(errorNumberParamShowISOCode);
var errorMessageParamShowISOCode = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
newSettingsCmd.Parameters.Add(errorMessageParamShowISOCode);
newSettingsCmd.ExecuteNonQuery(); //ShowISOCodes here - ShowUserCodes below
if (int.Parse(errorNumberParamShowISOCode.Value.ToString()) != 0)
{
//errorMessageParam.Value
}
newSettingsCmd.Parameters.Clear();
//Now set up for ShowUserCodes
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar, 255) { Value = "ShowUserCodes" });
switch (Convert.ToString(dr["PropertyValue"]))
{
case "ISO_ONLY":
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "False" });
break;
case "TRANSITORY":
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "True" });
break;
case "NO_ISO":
default:
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = "True" });
break;
}
}
else
{
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.NVarChar, 255) { Value = Convert.ToString(dr["PropertyId"]) });
newSettingsCmd.Parameters.Add(new SqlParameter("@PropertyValue", SqlDbType.NVarChar, 255) { Value = Convert.ToString(dr["PropertyValue"]) });
}
newSettingsCmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.NVarChar, 255) { Value = Convert.ToString(dr["UserId"]) });
var errorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
newSettingsCmd.Parameters.Add(errorNumberParam);
var errorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
newSettingsCmd.Parameters.Add(errorMessageParam);
newSettingsCmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
//errorMessageParam.Value
}
newSettingsCmd.Parameters.Clear();
}
}
finally
{
newSettingsCmd.Connection.Dispose();
}
}
}
}
finally
{
oldSettingsCmd.Connection.Dispose();
}
}
}
private void CopyUnchangedOrNewFieldsOnlyTable(string tableName, string idField, int idMinimum, SetStatusDelegate SetStatus, string dbName)
{
SetStatus("Copying " + tableName + " table...");
DataColumnCollection columns = null;
var objects = new List<object[]>();
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var cmd = GetSQLCommand(true))
{
cmd.CommandText = $"SELECT * from [dbo].[" + tableName + "] WHERE " + idField + " > " + idMinimum;
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables[0].Rows.Count > 0)
{
columns = ds.Tables[0].Columns;
foreach (DataRow row in ds.Tables[0].Rows)
{
var rowObjects = new object[columns.Count];
for (var i = 0; i < rowObjects.Length; i++)
{
rowObjects[i] = row[i];
}
objects.Add(rowObjects);
}
}
}
cmd.Connection.Dispose();
}
if (null != columns)
{
if (tableName == "TagAssignments" ||
tableName == "UserProperties" ||
tableName == "UIItemSettings")
{
//The TagAssignments table does not have a Primary Key
InsertIntoCurrentTable(tableName, columns, objects, false, dbName);
}
else
{
InsertIntoCurrentTable(tableName, columns, objects, true, dbName);
}
}
}
private void BuildSensorTables(SetStatusDelegate SetStatus, string dbName)
{
//Get data from old Sensors table
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandText = $"SELECT id, SensorId, SensorType from [dbo].[Sensors]";
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs.Tables.Count <= 0 || sensorsDs.Tables[0].Rows.Count <= 0) return;
//For each row, insert into new Sensors table and one of the SensorsX tables
var totalSensorCount = sensorsDs.Tables[0].Rows.Count;
var count = 0;
foreach (DataRow sensorsDr in sensorsDs.Tables[0].Rows)
{
count++;
var sensorStatusDisplay = "Building Sensor tables; Adding sensor " + count + "/" + totalSensorCount;
var id = Convert.ToInt16(sensorsDr["id"]);
var sensorId = Convert.ToInt16(sensorsDr["SensorId"]);
SensorConstants.SensorType sensorType = (SensorConstants.SensorType)Convert.ToInt16(sensorsDr["SensorType"]);
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
ProcessAnalogSensor(id, sensorId, SetStatus, sensorStatusDisplay, dbName);
break;
case SensorConstants.SensorType.DigitalIn:
ProcessDigitalInSensor(id, sensorId, dbName);
break;
case SensorConstants.SensorType.DigitalOut:
ProcessDigitalOutSensor(id, sensorId, dbName);
break;
case SensorConstants.SensorType.Squib:
ProcessSquibSensor(id, sensorId, dbName);
break;
}
}
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
}
private void BuildGroupsTable(SetStatusDelegate SetStatus, ref List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
//Get any static Groups, including embedded, from TestObjects table and store in Groups table
MoveStaticGroupsToGroupsTable(SetStatus, ref groupChannelHelpers, dbName);
//Get all Group Templates from TestObjectTemplates table and store in Groups table
MoveGroupTemplatesToGroupsTable(SetStatus, ref groupChannelHelpers, dbName);
//Get any Added Groups from TestSetupObjects table and store in Groups table
MoveAddedGroupsToGroupsTable(SetStatus, ref groupChannelHelpers, dbName);
}
private void BuildChannelCodesTable(SetStatusDelegate SetStatus, string dbName)
{
SetStatus("Building ChannelCodes table...");
MoveCustomChannelsToChannelCodesTable(SetStatus, dbName);
}
private bool UserPropertiesRecordExists(int userId, int propertyId)
{
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_UserPropertiesGet.ToString();
cmd.Parameters.Add(new SqlParameter("@UserId", SqlDbType.Int) { Value = userId });
cmd.Parameters.Add(new SqlParameter("@PropertyId", SqlDbType.Int) { Value = propertyId });
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables[0].Rows.Count == 1)
{
return true;
}
}
}
finally
{
cmd.Connection.Dispose();
}
}
return false;
}
private void InsertIntoCurrentTable(string tableName, DataColumnCollection columns, List<object[]> data, bool bIdentity, string dbName)
{
const int MAX_BATCH_SIZE = 20;
SqlCommand cmd = null;
var index = 0;
StringBuilder sb = null;
var countSoFar = 0;
foreach (var row in data)
{
if (null == cmd)
{
index = 0;
Connection.ResetLocalConnectionStringDb(dbName);
cmd = GetSQLCommand(true);
sb = new StringBuilder(500);
sb.Append(LocalOnlyOperations.BeginStatement);
if (bIdentity)
{
sb.Append($"SET IDENTITY_INSERT [dbo].[{tableName}] ON;");
}
}
sb.Append($"INSERT INTO [dbo].[{tableName}] (");
for (var i = 0; i < columns.Count; i++)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append(columns[i].ColumnName);
}
sb.Append(") VALUES (");
var numSkipped = 0;
for (var i = 0; i < columns.Count; i++)
{
if (i > 0)
{
sb.Append(",");
}
if (tableName == "TestSetups" &&
(columns[i].ColumnName == "CustomerId" ||
columns[i].ColumnName == "LabratoryId" ||
columns[i].ColumnName == "TestEngineerId") &&
Convert.ToInt32(row[i]) <= 0)
{
numSkipped++;
sb.Append("null");
continue;
}
var key = $"@{index}_{i - numSkipped}";
sb.Append(key);
var dataType = TypeConvertor.ToSqlDbType(columns[i].DataType);
CreateParam(cmd, key, dataType, row[i]);
}
sb.Append(") SELECT SCOPE_IDENTITY();");
index++;
if (MAX_BATCH_SIZE == index)
{
countSoFar += index;
if (bIdentity)
{
sb.Append($"SET IDENTITY_INSERT [dbo].[{tableName}] OFF;");
}
sb.Append(LocalOnlyOperations.CommitStatement);
cmd.CommandText = sb.ToString();
cmd.CommandType = CommandType.Text;
_ = cmd.ExecuteScalar();
cmd.Connection.Dispose();
cmd.Dispose();
cmd = null;
}
}
if (null != cmd)
{
if (bIdentity)
{
sb.Append($"SET IDENTITY_INSERT [dbo].[{tableName}] OFF;");
}
sb.Append(LocalOnlyOperations.CommitStatement);
cmd.CommandText = sb.ToString();
cmd.CommandType = CommandType.Text;
_ = cmd.ExecuteScalar();
cmd.Connection.Dispose();
cmd.Dispose();
cmd = null;
}
}
private void ProcessAnalogSensor(int id, int sensorId, SetStatusDelegate SetStatus, string sensorStatusDisplay, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var analogSensorsCmd = GetSQLCommand(true))
{
try
{
var sb = new StringBuilder("SELECT SerialNumber, ");
sb.Append("UserSerialNumber, ");
sb.Append("Model, ");
sb.Append("SensorModelId, ");
sb.Append("Manufacturer, ");
sb.Append("Status, ");
sb.Append("MeasurementUnit, ");
sb.Append("OffsetToleranceLow, ");
sb.Append("OffsetToleranceHigh, ");
sb.Append("eId, ");
sb.Append("Capacity, ");
sb.Append("Comment, ");
sb.Append("BridgeType, ");
sb.Append("BridgeLegMode, ");
sb.Append("Shunt, ");
sb.Append("Invert, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("FilterClass, ");
sb.Append("BridgeResistance, ");
sb.Append("IsoCode, ");
sb.Append("CheckOffset, ");
sb.Append("SupportedExcitation, ");
sb.Append("InitialEU, ");
sb.Append("CalInterval, ");
sb.Append("CalibrationSignal, ");
sb.Append("InternalShuntResistance, ");
sb.Append("ExternalShuntResistance, ");
sb.Append("UniPolar, ");
sb.Append("RangeLow, ");
sb.Append("RangeAve, ");
sb.Append("RangeHigh, ");
sb.Append("Created, ");
sb.Append("TimesUsed, ");
sb.Append("SensorCategory, ");
sb.Append("BypassFilter, ");
sb.Append("CouplingMode, ");
sb.Append("Version, ");
sb.Append("LastModified, ");
sb.Append("ModifiedBy, ");
sb.Append("LocalOnly, ");
sb.Append("AxisNumber, ");
sb.Append("NumberOfAxes, ");
sb.Append("UserTags, ");
sb.Append("DoNotUse, ");
sb.Append("Broken, ");
sb.Append("DiagnosticsMode ");
sb.Append("from [dbo].[SensorsAnalog] WHERE Id = ");
sb.Append(Convert.ToInt16(sensorId).ToString());
analogSensorsCmd.CommandText = sb.ToString();
using (var analogSensorsDs = Connection.QueryDataSet(analogSensorsCmd))
{
if (analogSensorsDs.Tables.Count <= 0 || analogSensorsDs.Tables[0].Rows.Count <= 0) return;
var serialNumber = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["SerialNumber"]);
var userSerialNumber = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["UserSerialNumber"]);
var model = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["Model"]);
var sensorModelId = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["SensorModelId"]);
var manufacturer = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["Manufacturer"]);
var status = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["Status"]);
var measurementUnit = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["MeasurementUnit"]);
var offsetToleranceLow = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["OffsetToleranceLow"]);
var offsetToleranceHigh = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["OffsetToleranceHigh"]);
var eId = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["eId"]);
var capacity = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["Capacity"]);
var comment = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["Comment"]);
var bridgeType = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["BridgeType"]);
var bridgeLegMode = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["BridgeLegMode"]);
var shunt = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["Shunt"]);
var invert = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["Invert"]) ? 1 : 0;
var userValue1 = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["UserValue1"]);
var userValue2 = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["UserValue2"]);
var userValue3 = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["UserValue3"]);
var filterClass = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["FilterClass"]);
var bridgeResistance = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["BridgeResistance"]);
var isoCode = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["IsoCode"]);
var isoChannelName = string.Empty;
var userCode = string.Empty;
var userChannelName = string.Empty;
var checkOffset = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["CheckOffset"]) ? 1 : 0;
var supportedExcitation = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["SupportedExcitation"]);
var initialEU = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["InitialEU"]);
var calInterval = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["CalInterval"]);
var calibrationSignal = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["CalibrationSignal"]) ? 1 : 0;
var internalShuntResistance = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["InternalShuntResistance"]);
var externalShuntResistance = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["ExternalShuntResistance"]);
var uniPolar = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["UniPolar"]) ? 1 : 0;
var rangeLow = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["RangeLow"]);
var rangeAve = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["RangeAve"]);
var rangeHigh = Convert.ToDouble(analogSensorsDs.Tables[0].Rows[0]["RangeHigh"]);
var created = Convert.ToDateTime(analogSensorsDs.Tables[0].Rows[0]["Created"]);
var timesUsed = Convert.ToInt64(analogSensorsDs.Tables[0].Rows[0]["TimesUsed"]);
var sensorCategory = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["SensorCategory"]);
var bypassFilter = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["BypassFilter"]) ? 1 : 0;
var couplingMode = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["CouplingMode"]);
var version = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["Version"]);
var lastModified = Convert.ToDateTime(analogSensorsDs.Tables[0].Rows[0]["LastModified"]);
var modifiedBy = Convert.ToString(analogSensorsDs.Tables[0].Rows[0]["ModifiedBy"]);
var localOnly = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["LocalOnly"]) ? 1 : 0;
var axisNumber = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["AxisNumber"]);
var numberOfAxes = Convert.ToInt32(analogSensorsDs.Tables[0].Rows[0]["NumberOfAxes"]);
var userTags = new byte[0];
if (analogSensorsDs.Tables[0].Rows[0]["UserTags"].GetType().Name != "DBNull")
{
userTags = (byte[])analogSensorsDs.Tables[0].Rows[0]["UserTags"];
}
var doNotUse = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["DoNotUse"]) ? 1 : 0;
var broken = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["Broken"]) ? 1 : 0;
var diagnosticsMode = Convert.ToBoolean(analogSensorsDs.Tables[0].Rows[0]["DiagnosticsMode"]) ? 1 : 0;
SetStatus(sensorStatusDisplay + " (" + serialNumber + ")");
InsertIntoNewSensorsAnalogAndSensorsTables(
id,
//sensorsAnalogId,
serialNumber,
userSerialNumber,
model,
sensorModelId,
manufacturer,
status,
measurementUnit,
offsetToleranceLow,
offsetToleranceHigh,
eId,
capacity,
comment,
bridgeType,
bridgeLegMode,
shunt,
invert,
userValue1,
userValue2,
userValue3,
filterClass,
bridgeResistance,
isoCode,
isoChannelName,
userCode,
userChannelName,
checkOffset,
supportedExcitation,
initialEU,
calInterval,
calibrationSignal,
internalShuntResistance,
externalShuntResistance,
uniPolar,
rangeLow,
rangeAve,
rangeHigh,
created,
timesUsed,
sensorCategory,
bypassFilter,
couplingMode,
version,
lastModified,
modifiedBy,
localOnly,
axisNumber,
numberOfAxes,
userTags,
doNotUse,
broken,
diagnosticsMode,
dbName
);
}
}
finally
{
analogSensorsCmd.Connection.Dispose();
}
}
}
private void InsertIntoNewSensorsAnalogAndSensorsTables(
int id,
//int sensorsAnalogId,
string serialNumber,
string userSerialNumber,
string model,
int sensorModelId,
string manufacturer,
string status,
string measurementUnit,
double offsetToleranceLow,
double offsetToleranceHigh,
string eId,
double capacity,
string comment,
int bridgeType,
int bridgeLegMode,
int shunt,
int invert,
string userValue1,
string userValue2,
string userValue3,
string filterClass,
double bridgeResistance,
string isoCode,
string isoChannelName,
string userCode,
string userChannelName,
int checkOffset,
string supportedExcitation,
double initialEU,
int calInterval,
int calibrationSignal,
double internalShuntResistance,
double externalShuntResistance,
int uniPolar,
double rangeLow,
double rangeAve,
double rangeHigh,
DateTime created,
long timesUsed,
int sensorCategory,
int bypassFilter,
int couplingMode,
int version,
DateTime lastModified,
string modifiedBy,
int localOnly,
int axisNumber,
int numberOfAxes,
byte[] userTags,
int doNotUse,
int broken,
int diagnosticsMode,
string dbName
)
{
ResetLocalConnectionStringDb(dbName);
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] ON;";
cmd.ExecuteNonQuery();
var sb = new StringBuilder("INSERT INTO [dbo].[Sensors] (id, SensorType, SerialNumber) VALUES (");
sb.Append(id);
sb.Append(", ");
sb.Append(Convert.ToInt16(SensorConstants.SensorType.Analog));
sb.Append(", N'");
sb.Append(serialNumber.Replace("'", "''"));
sb.Append("')");
cmd.CommandText = sb.ToString();
cmd.ExecuteNonQuery();
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] OFF;";
cmd.ExecuteNonQuery();
sb = new StringBuilder("INSERT INTO [dbo].[SensorsAnalog] (");
sb.Append("SensorId, ");
sb.Append("UserSerialNumber, ");
sb.Append("Model, ");
sb.Append("SensorModelId, ");
sb.Append("Manufacturer, ");
sb.Append("Status, ");
sb.Append("MeasurementUnit, ");
sb.Append("OffsetToleranceLow, ");
sb.Append("OffsetToleranceHigh, ");
sb.Append("eId, ");
sb.Append("Capacity, ");
sb.Append("Comment, ");
sb.Append("BridgeType, ");
sb.Append("BridgeLegMode, ");
sb.Append("Shunt, ");
sb.Append("Invert, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("FilterClass, ");
sb.Append("BridgeResistance, ");
sb.Append("IsoCode, ");
sb.Append("IsoChannelName, ");
sb.Append("UserCode, ");
sb.Append("UserChannelName, ");
sb.Append("CheckOffset, ");
sb.Append("SupportedExcitation, ");
sb.Append("InitialEU, ");
sb.Append("CalInterval, ");
sb.Append("CalibrationSignal, ");
sb.Append("InternalShuntResistance, ");
sb.Append("ExternalShuntResistance, ");
sb.Append("UniPolar, ");
sb.Append("RangeLow, ");
sb.Append("RangeAve, ");
sb.Append("RangeHigh, ");
sb.Append("Created, ");
sb.Append("TimesUsed, ");
sb.Append("SensorCategory, ");
sb.Append("BypassFilter, ");
sb.Append("CouplingMode, ");
sb.Append("Version, ");
sb.Append("LastModified, ");
sb.Append("ModifiedBy, ");
sb.Append("LocalOnly, ");
sb.Append("AxisNumber, ");
sb.Append("NumberOfAxes, ");
sb.Append("UserTags, ");
sb.Append("DoNotUse, ");
sb.Append("Broken, ");
sb.Append("DiagnosticsMode ");
sb.Append(") ");
sb.Append("VALUES (");
//sb.Append(sensorsAnalogId); //The first should not be preceded by a comma
sb.Append(id); //The first should not be preceded by a comma
sb.Append(AppendStringValue(userSerialNumber));
sb.Append(AppendStringValue(model));
sb.Append(AppendIntValue(sensorModelId));
sb.Append(AppendStringValue(manufacturer));
sb.Append(AppendStringValue(status));
sb.Append(AppendStringValue(measurementUnit));
sb.Append(AppendDoubleValue(offsetToleranceLow));
sb.Append(AppendDoubleValue(offsetToleranceHigh));
sb.Append(AppendStringValue(eId));
sb.Append(AppendDoubleValue(capacity));
sb.Append(AppendStringValue(comment));
sb.Append(AppendIntValue(bridgeType));
sb.Append(AppendIntValue(bridgeLegMode));
sb.Append(AppendIntValue(shunt));
sb.Append(AppendIntValue(invert));
sb.Append(AppendStringValue(userValue1));
sb.Append(AppendStringValue(userValue2));
sb.Append(AppendStringValue(userValue3));
sb.Append(AppendStringValue(filterClass));
sb.Append(AppendDoubleValue(bridgeResistance));
sb.Append(AppendStringValue(isoCode));
sb.Append(AppendStringValue(isoChannelName));
sb.Append(AppendStringValue(userCode));
sb.Append(AppendStringValue(userChannelName));
sb.Append(AppendIntValue(checkOffset));
sb.Append(AppendStringValue(supportedExcitation));
sb.Append(AppendDoubleValue(initialEU));
sb.Append(AppendIntValue(calInterval));
sb.Append(AppendIntValue(calibrationSignal));
sb.Append(AppendDoubleValue(internalShuntResistance));
sb.Append(AppendDoubleValue(externalShuntResistance));
sb.Append(AppendIntValue(uniPolar));
sb.Append(AppendDoubleValue(rangeLow));
sb.Append(AppendDoubleValue(rangeAve));
sb.Append(AppendDoubleValue(rangeHigh));
sb.Append(AppendDateTimeValue(created));
sb.Append(AppendLongValue(timesUsed));
sb.Append(AppendIntValue(sensorCategory));
sb.Append(AppendIntValue(bypassFilter));
sb.Append(AppendIntValue(couplingMode));
sb.Append(AppendIntValue(version));
sb.Append(AppendDateTimeValue(lastModified));
sb.Append(AppendStringValue(modifiedBy));
sb.Append(AppendIntValue(localOnly));
sb.Append(AppendIntValue(axisNumber));
sb.Append(AppendIntValue(numberOfAxes));
sb.Append(AppendParameter("@userTags"));
sb.Append(AppendIntValue(doNotUse));
sb.Append(AppendIntValue(broken));
sb.Append(AppendIntValue(diagnosticsMode));
sb.Append(")");
cmd.CommandText = sb.ToString();
cmd.Parameters.AddWithValue("@userTags", userTags);
cmd.ExecuteNonQuery();
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void ProcessDigitalInSensor(int id, int sensorId, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var digitalInSensorsCmd = GetSQLCommand(true))
{
try
{
var sb = new StringBuilder("SELECT SerialNumber, ");
sb.Append("SettingMode, ");
sb.Append("ScaleMultiplier, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("eId, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("UserTags, ");
sb.Append("MeasurementUnit, ");
sb.Append("FilterClass ");
sb.Append("from [dbo].[SensorsDigitalIn] WHERE Id = ");
sb.Append(Convert.ToInt16(sensorId).ToString());
digitalInSensorsCmd.CommandText = sb.ToString();
using (var digitalInSensorsDs = Connection.QueryDataSet(digitalInSensorsCmd))
{
if (digitalInSensorsDs.Tables.Count <= 0 || digitalInSensorsDs.Tables[0].Rows.Count <= 0) return;
var serialNumber = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["SerialNumber"]);
var settingMode = Convert.ToInt32(digitalInSensorsDs.Tables[0].Rows[0]["SettingMode"]);
var scaleMultiplier = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["ScaleMultiplier"]);
var lastModified = Convert.ToDateTime(digitalInSensorsDs.Tables[0].Rows[0]["LastModified"]);
var lastModifiedBy = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["LastModifiedBy"]);
var eId = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["eId"]);
var isoCode = string.Empty;
var isoChannelName = string.Empty;
var userCode = string.Empty;
var userChannelName = string.Empty;
var userValue1 = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["UserValue1"]);
var userValue2 = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["UserValue2"]);
var userValue3 = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["UserValue3"]);
var userTags = new byte[0];
if (digitalInSensorsDs.Tables[0].Rows[0]["UserTags"].GetType().Name != "DBNull")
{
userTags = (byte[])digitalInSensorsDs.Tables[0].Rows[0]["UserTags"];
}
var measurementUnit = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["MeasurementUnit"]);
var filterClass = Convert.ToString(digitalInSensorsDs.Tables[0].Rows[0]["FilterClass"]);
InsertIntoNewSensorsDigitalInAndSensorsTables(
id,
//sensorsDigitalInId,
serialNumber,
settingMode,
scaleMultiplier,
lastModified,
lastModifiedBy,
eId,
isoCode,
isoChannelName,
userCode,
userChannelName,
userValue1,
userValue2,
userValue3,
userTags,
measurementUnit,
filterClass,
dbName
);
}
}
finally
{
digitalInSensorsCmd.Connection.Dispose();
}
}
}
private void InsertIntoNewSensorsDigitalInAndSensorsTables(
int id,
//int sensorsDigitalInId,
string serialNumber,
int settingMode,
string scaleMultiplier,
DateTime lastModified,
string lastModifiedBy,
string eId,
string isoCode,
string isoChannelName,
string userCode,
string userChannelName,
string userValue1,
string userValue2,
string userValue3,
byte[] userTags,
string measurementUnit,
string filterClass,
string dbName
)
{
ResetLocalConnectionStringDb(dbName);
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] ON;";
cmd.ExecuteNonQuery();
var sb = new StringBuilder("INSERT INTO [dbo].[Sensors] (id, SensorType, SerialNumber) VALUES (");
sb.Append(id);
sb.Append(", ");
sb.Append(Convert.ToInt16(SensorConstants.SensorType.DigitalIn));
sb.Append(", N'");
sb.Append(serialNumber);
sb.Append("')");
cmd.CommandText = sb.ToString();
cmd.ExecuteNonQuery();
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] OFF;";
cmd.ExecuteNonQuery();
sb = new StringBuilder("INSERT INTO [dbo].[SensorsDigitalIn] (");
sb.Append("SensorId, ");
sb.Append("SettingMode, ");
sb.Append("ScaleMultiplier, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("eId, ");
sb.Append("IsoCode, ");
sb.Append("IsoChannelName, ");
sb.Append("UserCode, ");
sb.Append("UserChannelName, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("UserTags,");
sb.Append("MeasurementUnit, ");
sb.Append("FilterClass, ");
sb.Append("DoNotUse, ");
sb.Append("Broken ");
sb.Append(") ");
sb.Append("VALUES (");
//sb.Append(sensorsDigitalInId); //The first should not be preceded by a comma
sb.Append(id); //The first should not be preceded by a comma
sb.Append(AppendIntValue(settingMode));
sb.Append(AppendStringValue(scaleMultiplier));
sb.Append(AppendDateTimeValue(lastModified));
sb.Append(AppendStringValue(lastModifiedBy));
sb.Append(AppendStringValue(eId));
sb.Append(AppendStringValue(isoCode));
sb.Append(AppendStringValue(isoChannelName));
sb.Append(AppendStringValue(userCode));
sb.Append(AppendStringValue(userChannelName));
sb.Append(AppendStringValue(userValue1));
sb.Append(AppendStringValue(userValue2));
sb.Append(AppendStringValue(userValue3));
sb.Append(AppendParameter("@userTags"));
sb.Append(AppendStringValue(measurementUnit));
sb.Append(AppendStringValue(filterClass));
sb.Append(AppendIntValue(0)); //DoNotUse
sb.Append(AppendIntValue(0)); //Broken
sb.Append(")");
cmd.CommandText = sb.ToString();
cmd.Parameters.AddWithValue("@userTags", userTags);
cmd.ExecuteNonQuery();
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void ProcessDigitalOutSensor(int id, int sensorId, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var digitalOutSensorsCmd = GetSQLCommand(true))
{
try
{
var sb = new StringBuilder("SELECT SerialNumber, ");
sb.Append("DelayMS, ");
sb.Append("OutputMode, ");
sb.Append("LimitDuration, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("Version, ");
sb.Append("DurationMSFloat, ");
sb.Append("UserTags ");
sb.Append("from [dbo].[SensorsDigitalOut] WHERE Id = ");
sb.Append(Convert.ToInt16(sensorId).ToString());
digitalOutSensorsCmd.CommandText = sb.ToString();
using (var digitalOutSensorsDs = Connection.QueryDataSet(digitalOutSensorsCmd))
{
if (digitalOutSensorsDs.Tables.Count <= 0 || digitalOutSensorsDs.Tables[0].Rows.Count <= 0) return;
var serialNumber = Convert.ToString(digitalOutSensorsDs.Tables[0].Rows[0]["SerialNumber"]);
var delayMS = Convert.ToDouble(digitalOutSensorsDs.Tables[0].Rows[0]["DelayMS"]);
var outputMode = Convert.ToInt32(digitalOutSensorsDs.Tables[0].Rows[0]["OutputMode"]);
var limitDuration = Convert.ToBoolean(digitalOutSensorsDs.Tables[0].Rows[0]["LimitDuration"]) ? 1 : 0;
var lastModified = Convert.ToDateTime(digitalOutSensorsDs.Tables[0].Rows[0]["LastModified"]);
var lastModifiedBy = Convert.ToString(digitalOutSensorsDs.Tables[0].Rows[0]["LastModifiedBy"]);
var version = Convert.ToInt32(digitalOutSensorsDs.Tables[0].Rows[0]["Version"]);
var durationMSFloat = Convert.ToDouble(digitalOutSensorsDs.Tables[0].Rows[0]["DurationMSFloat"]);
var userTags = new byte[0];
if (digitalOutSensorsDs.Tables[0].Rows[0]["UserTags"].GetType().Name != "DBNull")
{
userTags = (byte[])digitalOutSensorsDs.Tables[0].Rows[0]["UserTags"];
}
InsertIntoNewSensorsDigitalOutAndSensorsTables(
id,
//sensorsDigitalOutId,
serialNumber,
outputMode,
delayMS,
limitDuration,
durationMSFloat,
lastModified,
lastModifiedBy,
version,
userTags,
dbName
);
}
}
finally
{
digitalOutSensorsCmd.Connection.Dispose();
}
}
}
private void InsertIntoNewSensorsDigitalOutAndSensorsTables(
int id,
//int sensorsDigitalOutId,
string serialNumber,
int outputMode,
double delayMS,
int limitDuration,
double durationMSFloat,
DateTime lastModified,
string lastModifiedBy,
int version,
byte[] userTags,
string dbName
)
{
ResetLocalConnectionStringDb(dbName);
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] ON;";
cmd.ExecuteNonQuery();
var sb = new StringBuilder("INSERT INTO [dbo].[Sensors] (id, SensorType, SerialNumber) VALUES (");
sb.Append(id);
sb.Append(", ");
sb.Append(Convert.ToInt16(SensorConstants.SensorType.DigitalOut));
sb.Append(", N'");
sb.Append(serialNumber);
sb.Append("')");
cmd.CommandText = sb.ToString();
cmd.ExecuteNonQuery();
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] OFF;";
cmd.ExecuteNonQuery();
sb = new StringBuilder("INSERT INTO [dbo].[SensorsDigitalOut] (");
sb.Append("SensorId, ");
sb.Append("OutputMode, ");
sb.Append("DelayMS, ");
sb.Append("LimitDuration, ");
sb.Append("DurationMSFloat, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("Version, ");
sb.Append("UserTags, ");
sb.Append("DoNotUse, ");
sb.Append("Broken ");
sb.Append(") ");
sb.Append("VALUES (");
//sb.Append(sensorsDigitalOutId); //The first should not be preceded by a comma
sb.Append(id); //The first should not be preceded by a comma
sb.Append(AppendIntValue(outputMode));
sb.Append(AppendDoubleValue(delayMS));
sb.Append(AppendIntValue(limitDuration));
sb.Append(AppendDoubleValue(durationMSFloat));
sb.Append(AppendDateTimeValue(lastModified));
sb.Append(AppendStringValue(lastModifiedBy));
sb.Append(AppendIntValue(version));
sb.Append(AppendParameter("@userTags"));
sb.Append(AppendIntValue(0)); //DoNotUse
sb.Append(AppendIntValue(0)); //Broken
sb.Append(")");
cmd.CommandText = sb.ToString();
cmd.Parameters.AddWithValue("@userTags", userTags);
cmd.ExecuteNonQuery();
}
finally
{
cmd.Connection.Dispose();
}
}
}
private void ProcessSquibSensor(int id, int sensorId, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var squibSensorsCmd = GetSQLCommand(true))
{
try
{
var sb = new StringBuilder("SELECT SerialNumber, ");
sb.Append("BypassCurrentFilter, ");
sb.Append("BypassVoltageFilter, ");
sb.Append("DelayMS, ");
sb.Append("DurationMS, ");
sb.Append("FireMode, ");
sb.Append("ISOCode, ");
sb.Append("MeasurementType, ");
sb.Append("SquibOutputCurrent, ");
sb.Append("SquibToleranceLow, ");
sb.Append("SquibToleranceHigh, ");
sb.Append("LimitDuration, ");
sb.Append("ArticleId, ");
sb.Append("Version, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("UserTags ");
sb.Append("from [dbo].[SensorsSquib] WHERE Id = ");
sb.Append(Convert.ToInt16(sensorId).ToString());
squibSensorsCmd.CommandText = sb.ToString();
using (var squibSensorsDs = Connection.QueryDataSet(squibSensorsCmd))
{
if (squibSensorsDs.Tables.Count <= 0 || squibSensorsDs.Tables[0].Rows.Count <= 0) return;
var serialNumber = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["SerialNumber"]);
var bypassCurrentFilter = Convert.ToBoolean(squibSensorsDs.Tables[0].Rows[0]["BypassCurrentFilter"]) ? 1 : 0;
var bypassVoltageFilter = Convert.ToBoolean(squibSensorsDs.Tables[0].Rows[0]["BypassVoltageFilter"]) ? 1 : 0;
var delayMS = Convert.ToDouble(squibSensorsDs.Tables[0].Rows[0]["DelayMS"]);
var durationMS = Convert.ToDouble(squibSensorsDs.Tables[0].Rows[0]["DurationMS"]);
var fireMode = Convert.ToInt32(squibSensorsDs.Tables[0].Rows[0]["FireMode"]);
var isoCode = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["ISOCode"]);
var isoChannelName = string.Empty;
var userCode = string.Empty;
var userChannelName = string.Empty;
var measurementType = Convert.ToInt32(squibSensorsDs.Tables[0].Rows[0]["MeasurementType"]);
var squibOutputCurrent = Convert.ToDouble(squibSensorsDs.Tables[0].Rows[0]["SquibOutputCurrent"]);
var squibToleranceLow = Convert.ToDouble(squibSensorsDs.Tables[0].Rows[0]["SquibToleranceLow"]);
var squibToleranceHigh = Convert.ToDouble(squibSensorsDs.Tables[0].Rows[0]["SquibToleranceHigh"]);
var limitDuration = Convert.ToBoolean(squibSensorsDs.Tables[0].Rows[0]["LimitDuration"]) ? 1 : 0;
var articleId = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["ArticleId"]);
var version = Convert.ToInt32(squibSensorsDs.Tables[0].Rows[0]["Version"]);
var lastModified = Convert.ToDateTime(squibSensorsDs.Tables[0].Rows[0]["LastModified"]);
var lastModifiedBy = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["LastModifiedBy"]);
var userValue1 = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["UserValue1"]);
var userValue2 = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["UserValue2"]);
var userValue3 = Convert.ToString(squibSensorsDs.Tables[0].Rows[0]["UserValue3"]);
var userTags = new byte[0];
if (squibSensorsDs.Tables[0].Rows[0]["UserTags"].GetType().Name != "DBNull")
{
userTags = (byte[])squibSensorsDs.Tables[0].Rows[0]["UserTags"];
}
InsertIntoNewSensorsSquibAndSensorsTables(
id,
//sensorsDigitalOutId,
serialNumber,
bypassCurrentFilter,
bypassVoltageFilter,
delayMS,
durationMS,
fireMode,
isoCode,
isoChannelName,
userCode,
userChannelName,
measurementType,
squibOutputCurrent,
squibToleranceLow,
squibToleranceHigh,
limitDuration,
articleId,
version,
lastModified,
lastModifiedBy,
userValue1,
userValue2,
userValue3,
userTags,
dbName
);
}
}
finally
{
squibSensorsCmd.Connection.Dispose();
}
}
}
private void InsertIntoNewSensorsSquibAndSensorsTables(
int id,
//int sensorsDigitalOutId,
string serialNumber,
int bypassCurrentFilter,
int bypassVoltageFilter,
double delayMS,
double durationMS,
int fireMode,
string isoCode,
string isoChannelName,
string userCode,
string userChannelName,
int measurementType,
double squibOutputCurrent,
double squibToleranceLow,
double squibToleranceHigh,
int limitDuration,
string articleId,
int version,
DateTime lastModified,
string lastModifiedBy,
string userValue1,
string userValue2,
string userValue3,
byte[] userTags,
string dbName
)
{
ResetLocalConnectionStringDb(dbName);
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] ON;";
cmd.ExecuteNonQuery();
var sb = new StringBuilder("INSERT INTO [dbo].[Sensors] (id, SensorType, SerialNumber) VALUES (");
sb.Append(id);
sb.Append(", ");
sb.Append(Convert.ToInt16(SensorConstants.SensorType.Squib));
sb.Append(", N'");
sb.Append(serialNumber);
sb.Append("')");
cmd.CommandText = sb.ToString();
cmd.ExecuteNonQuery();
cmd.CommandText = $"SET IDENTITY_INSERT [dbo].[Sensors] OFF;";
cmd.ExecuteNonQuery();
sb = new StringBuilder("INSERT INTO [dbo].[SensorsSquib] (");
sb.Append("SensorId, ");
sb.Append("BypassCurrentFilter, ");
sb.Append("BypassVoltageFilter, ");
sb.Append("DelayMS, ");
sb.Append("DurationMS, ");
sb.Append("FireMode, ");
sb.Append("IsoCode, ");
sb.Append("IsoChannelName, ");
sb.Append("UserCode, ");
sb.Append("UserChannelName, ");
sb.Append("MeasurementType, ");
sb.Append("SquibOutputCurrent, ");
sb.Append("SquibToleranceLow, ");
sb.Append("SquibToleranceHigh, ");
sb.Append("LimitDuration, ");
sb.Append("ArticleId, ");
sb.Append("Version, ");
sb.Append("LastModified, ");
sb.Append("LastModifiedBy, ");
sb.Append("UserValue1, ");
sb.Append("UserValue2, ");
sb.Append("UserValue3, ");
sb.Append("UserTags, ");
sb.Append("DoNotUse, ");
sb.Append("Broken ");
sb.Append(") ");
sb.Append("VALUES (");
//sb.Append(sensorsDigitalOutId); //The first should not be preceded by a comma
sb.Append(id); //The first should not be preceded by a comma
sb.Append(AppendIntValue(bypassCurrentFilter));
sb.Append(AppendIntValue(bypassVoltageFilter));
sb.Append(AppendDoubleValue(delayMS));
sb.Append(AppendDoubleValue(durationMS));
sb.Append(AppendIntValue(fireMode));
sb.Append(AppendStringValue(isoCode));
sb.Append(AppendStringValue(isoChannelName));
sb.Append(AppendStringValue(userCode));
sb.Append(AppendStringValue(userChannelName));
sb.Append(AppendIntValue(measurementType));
sb.Append(AppendDoubleValue(squibOutputCurrent));
sb.Append(AppendDoubleValue(squibToleranceLow));
sb.Append(AppendDoubleValue(squibToleranceHigh));
sb.Append(AppendIntValue(limitDuration));
sb.Append(AppendStringValue(articleId));
sb.Append(AppendIntValue(version));
sb.Append(AppendDateTimeValue(lastModified));
sb.Append(AppendStringValue(lastModifiedBy));
sb.Append(AppendStringValue(userValue1));
sb.Append(AppendStringValue(userValue2));
sb.Append(AppendStringValue(userValue3));
sb.Append(AppendParameter("@userTags"));
sb.Append(AppendIntValue(0)); //DoNotUse
sb.Append(AppendIntValue(0)); //Broken
sb.Append(")");
cmd.CommandText = sb.ToString();
cmd.Parameters.AddWithValue("@userTags", userTags);
cmd.ExecuteNonQuery();
}
finally
{
cmd.Connection.Dispose();
}
}
}
private string AppendIntValue(int value)
{
var sb = new StringBuilder(", ");
sb.Append(value.ToString());
return sb.ToString();
}
private string AppendDoubleValue(double value)
{
var sb = new StringBuilder(", ");
sb.Append(value.ToString());
return sb.ToString();
}
private string AppendLongValue(long value)
{
var sb = new StringBuilder(", ");
sb.Append(value.ToString());
return sb.ToString();
}
private string AppendStringValue(string value)
{
var sb = new StringBuilder(", N'");
sb.Append(value);
sb.Append("'");
return sb.ToString();
}
private string AppendDateTimeValue(DateTime value)
{
return AppendStringValue(value.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
private string AppendParameter(string value)
{
var sb = new StringBuilder(", ");
sb.Append(value);
return sb.ToString();
}
private void MoveStaticGroupsToGroupsTable(SetStatusDelegate SetStatus, ref List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
//Get all static Groups from PRE2.0 db
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectsCmd = GetSQLCommand(true))
{
try
{
GetAllGroups(testObjectsCmd, null, false);
using (var groupsDs = Connection.QueryDataSet(testObjectsCmd))
{
if (groupsDs.Tables.Count <= 0 || groupsDs.Tables[0].Rows.Count <= 0) return;
var totalGroupCount = groupsDs.Tables[0].Rows.Count;
var count = 0;
var idToOrigSerialNumberMapping = new Dictionary<int, string>();
var serialNumberToIdMapping = new Dictionary<string, int>();
foreach (DataRow groupsDr in groupsDs.Tables[0].Rows)
{
count++;
var statusDisplayName = Convert.ToString(groupsDr["OrigSerialNumber"]);
if (string.IsNullOrWhiteSpace(statusDisplayName))
{
statusDisplayName = Convert.ToString(groupsDr["TestObjectName"]);
}
var groupStatusString = "Adding static Group " + count + "/" + totalGroupCount + " (" + statusDisplayName + ")";
SetStatus(groupStatusString);
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var groupsCmd = GetSQLCommand(true))
{
try
{
var displayName = Convert.ToBoolean(groupsDr["Embedded"]) ?
Convert.ToString(groupsDr["OrigSerialNumber"]) :
Convert.ToString(groupsDr["TestObjectName"]);
var description = GetTestObjectTemplateDescription(Convert.ToString(groupsDr["TemplateName"]), dbName);
//Insert it into the Groups table
var groupId = InsertIntoGroupsTable(groupsCmd,
Convert.ToString(groupsDr["TestObjectName"]),
displayName,
description,
Convert.ToBoolean(groupsDr["Embedded"]),
Convert.ToDateTime(groupsDr["LastModified"]),
Convert.ToString(groupsDr["LastModifiedBy"]),
null //Some will get updated later when we are sure the static Group is in the db
);
if (Convert.ToBoolean(groupsDr["Embedded"]) && !Convert.ToBoolean(groupsDr["SysBuilt"]))
{
//This is an embedded, non-Added, Group
idToOrigSerialNumberMapping[groupId] = displayName;
}
else if (!Convert.ToBoolean(groupsDr["Embedded"]))
{
//This is a static Group
serialNumberToIdMapping[Convert.ToString(groupsDr["TestObjectName"])] = groupId;
}
//Migrate from TestObjectHardware to GroupHardware
BuildGroupHardware(Convert.ToString(groupsDr["TestObjectName"]), groupId, dbName);
//Migrate from TestSetupObjects to TestSetupGroups
BuildTestSetupGroup(Convert.ToString(groupsDr["TestObjectName"]), groupId, out var testObjectType, out var position, dbName);
//Insert all of this Group's required channels into the Channels table
InsertGroupChannelsIntoChannelsTable(
Convert.ToString(groupsDr["TestObjectName"]),
groupId,
Convert.ToString(groupsDr["TemplateName"]),
Convert.ToString(groupsDr["LastModifiedBy"]),
Convert.ToDateTime(groupsDr["LastModified"]),
Convert.ToBoolean(groupsDr["Embedded"]),
SetStatus,
groupStatusString,
testObjectType,
position,
ref groupChannelHelpers,
dbName);
//Update any Level Triggers associated with this Group
UpdateLevelTriggers(Convert.ToString(groupsDr["TestObjectName"]), groupChannelHelpers, dbName);
}
finally
{
groupsCmd.Connection.Dispose();
}
}
}
//Now set the StaticGroupId field as appropriate
foreach (var idToOrigSerialNumberPair in idToOrigSerialNumberMapping
.Where(x => serialNumberToIdMapping.ContainsKey(x.Value)))
{
UpdateStaticGroupId(idToOrigSerialNumberPair.Key, serialNumberToIdMapping[idToOrigSerialNumberPair.Value], dbName);
}
//Set the DisplayOrder (of the Groups in a Test Setup) in TestSetupGroups
//Get all of the TestSetupIds from the TestSetups table
SetGroupDisplayOrder(dbName);
}
}
finally
{
testObjectsCmd.Connection.Dispose();
}
}
}
private void SetGroupDisplayOrder(string dbName)
{
ResetLocalConnectionStringDb(dbName);
using (var testSetupsGetCmd = GetSQLCommand(true))
{
try
{
testSetupsGetCmd.CommandType = CommandType.StoredProcedure;
testSetupsGetCmd.CommandText = "sp_TestSetupsGet";
var testSetupReader = testSetupsGetCmd.ExecuteReader();
while (testSetupReader.Read())
{
var testSetupId = Convert.ToInt32(testSetupReader["TestSetupId"]);
var groupIdMinChannelDisplayOrderDictionary = new Dictionary<int, int>();
//Get all embedded Groups in this Test Setup
using (var testSetupGroupsCmd = GetSQLCommand(true))
{
try
{
testSetupGroupsCmd.CommandType = CommandType.StoredProcedure;
testSetupGroupsCmd.CommandText = "sp_TestSetupGroupsGet";
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.NVarChar) { Value = testSetupId });
var testSetupGroupsReader = testSetupGroupsCmd.ExecuteReader();
while (testSetupGroupsReader.Read())
{
var groupId = Convert.ToInt32(testSetupGroupsReader["GroupId"]);
//Get the minimum TestSetupOrder from all of this embedded Group's channels and add it to an ordered list
using (var minChannelTestSetupOrderCmd = GetSQLCommand(true))
{
try
{
minChannelTestSetupOrderCmd.CommandType = CommandType.Text;
minChannelTestSetupOrderCmd.CommandText = "SELECT MIN(TestSetupOrder) FROM Channels WHERE GroupId=" + groupId;
var minTestSetupOrder = 0;
try
{
minTestSetupOrder = Convert.ToInt32(minChannelTestSetupOrderCmd.ExecuteScalar());
}
catch
{
//Just let minTestSetupOrder be 0, then all of the channel-less Groups will
//be grouped together at the top of the list in the Test Setup
}
groupIdMinChannelDisplayOrderDictionary[groupId] = minTestSetupOrder;
}
finally
{
minChannelTestSetupOrderCmd.Connection.Dispose();
}
}
}
}
finally
{
testSetupGroupsCmd.Connection.Dispose();
}
}
//Update each Group's DisplayOrder field in the TestSetupGroups table
var displayOrderCount = 0;
foreach (KeyValuePair<int, int> item in groupIdMinChannelDisplayOrderDictionary.OrderBy(x => x.Value))
{
displayOrderCount++;
using (var testSetupGroupsUpdateCmd = GetSQLCommand(true))
{
try
{
testSetupGroupsUpdateCmd.CommandType = CommandType.Text;
testSetupGroupsUpdateCmd.CommandText = "UPDATE TestSetupGroups SET DisplayOrder = " + displayOrderCount +
" WHERE GroupId = " + item.Key + " AND TestSetupId = " + testSetupId;
testSetupGroupsUpdateCmd.ExecuteNonQuery();
}
finally
{
testSetupGroupsUpdateCmd.Connection.Dispose();
}
}
}
}
}
finally
{
testSetupsGetCmd.Connection.Dispose();
}
}
}
private void UpdateStaticGroupId(int embeddedGroupId, int staticGroupId, string dbName)
{
//Set the StaticGroupId field of the embedded Group in the Groups table to staticGroupId
ResetLocalConnectionStringDb(dbName);
var serialNumber = string.Empty;
var displayName = string.Empty;
var description = string.Empty;
var embedded = false;
var lastModified = DateTime.Now;
var lastModifiedBy = string.Empty;
using (var groupCmd = GetSQLCommand(true))
{
try
{
groupCmd.CommandType = CommandType.StoredProcedure;
groupCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupsGet.ToString();
#region params
groupCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = embeddedGroupId });
#endregion params
using (var reader = groupCmd.ExecuteReader())
{
while (reader.Read()) //shouldn't be a while
{
serialNumber = Convert.ToString(reader["SerialNumber"]);
displayName = Convert.ToString(reader["DisplayName"]);
description = Convert.ToString(reader["Description"]);
embedded = Convert.ToBoolean(reader["Embedded"]);
lastModified = Convert.ToDateTime(reader["LastModified"]);
lastModifiedBy = Convert.ToString(reader["LastModifiedBy"]);
}
reader.Close();
}
}
finally
{
groupCmd.Connection.Dispose();
}
}
using (var groupCmd = GetSQLCommand(true))
{
try
{
groupCmd.CommandType = CommandType.StoredProcedure;
groupCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupsUpdate.ToString();
#region params
groupCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = embeddedGroupId });
groupCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 255) { Value = serialNumber });
groupCmd.Parameters.Add(new SqlParameter("@DisplayName", SqlDbType.NVarChar, 255) { Value = displayName });
groupCmd.Parameters.Add(new SqlParameter("@Description", SqlDbType.NVarChar, 255) { Value = description });
groupCmd.Parameters.Add(new SqlParameter("@Embedded", SqlDbType.Bit) { Value = embedded });
groupCmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = lastModified });
groupCmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 50) { Value = lastModifiedBy });
groupCmd.Parameters.Add(new SqlParameter("@StaticGroupId", SqlDbType.Int) { Value = staticGroupId });
var ExtraProperties = new List<KeyValuePair<string, string>>();
groupCmd.Parameters.Add(new SqlParameter("@ExtraProperties", SqlDbType.NVarChar, -1)
{
Value = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(ExtraProperties)
});
var groupErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupCmd.Parameters.Add(groupErrorNumberParam);
var groupErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
groupCmd.Parameters.Add(groupErrorMessageParam);
#endregion params
groupCmd.ExecuteNonQuery();
}
finally
{
groupCmd.Connection.Dispose();
}
}
}
private void MoveGroupTemplatesToGroupsTable(SetStatusDelegate SetStatus, ref List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
//Get all not SysBuilt, then throw out any embedded
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectTemplatesCmd = GetSQLCommand(true))
{
try
{
GetAllGroupTemplates(testObjectTemplatesCmd, false);
using (var groupTemplatesDs = Connection.QueryDataSet(testObjectTemplatesCmd))
{
var totalGroupCount = groupTemplatesDs.Tables[0].Rows.Count;
var count = 0;
foreach (DataRow groupTemplatesDr in groupTemplatesDs.Tables[0].Rows)
{
count++;
var statusDisplayName = Convert.ToString(groupTemplatesDr["TemplateName"]);
if (string.IsNullOrWhiteSpace(statusDisplayName))
{
statusDisplayName = Convert.ToString(groupTemplatesDr["OrigTemplateName"]);
}
var groupStatusString = "Adding Group from Group Template " + count + "/" + totalGroupCount + " (" + statusDisplayName + ")";
SetStatus(groupStatusString);
//Skip it if it's embedded in a Test Setup because that means a static Group is using it
if (Convert.ToBoolean(groupTemplatesDr["Embedded"]) || Convert.ToString(groupTemplatesDr["TestObjectType"]).StartsWith("NONISO")) continue;
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var groupsCmd = GetSQLCommand(true))
{
try
{
var groupName = Convert.ToString(groupTemplatesDr["TemplateName"]) + "_fromTemplate"; //temp
var groupId = InsertIntoGroupsTable(groupsCmd,
groupName,
groupName,
Convert.ToString(groupTemplatesDr["Description"]),
Convert.ToBoolean(groupTemplatesDr["Embedded"]), //Embedded should always be False here
Convert.ToDateTime(groupTemplatesDr["LastModified"]),
Convert.ToString(groupTemplatesDr["LastModifiedBy"]),
null
);
//Insert all of this unused Group Template's required channels into the Channels table
InsertGroupChannelsIntoChannelsTable(groupName, groupId,
Convert.ToString(groupTemplatesDr["TemplateName"]),
Convert.ToString(groupTemplatesDr["LastModifiedBy"]),
Convert.ToDateTime(groupTemplatesDr["LastModified"]),
false,
SetStatus,
groupStatusString, "?", "?", ref groupChannelHelpers,
dbName);
}
finally
{
groupsCmd.Connection.Dispose();
}
}
}
}
}
finally
{
testObjectTemplatesCmd.Connection.Dispose();
}
}
}
private void MoveAddedGroupsToGroupsTable(SetStatusDelegate SetStatus, ref List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
//Get all Added Groups
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectsCmd = GetSQLCommand(true))
{
try
{
GetAllGroups(testObjectsCmd, null, true);
using (var groupsDs = Connection.QueryDataSet(testObjectsCmd))
{
if (groupsDs.Tables.Count <= 0 || groupsDs.Tables[0].Rows.Count <= 0) return;
var totalGroupCount = groupsDs.Tables[0].Rows.Count;
var count = 0;
foreach (DataRow groupsDr in groupsDs.Tables[0].Rows)
{
count++;
var statusDisplayName = Convert.ToString(groupsDr["OrigSerialNumber"]);
if (string.IsNullOrWhiteSpace(statusDisplayName))
{
statusDisplayName = Convert.ToString(groupsDr["TestObjectName"]);
}
var groupStatusString = "Adding Added Group " + count + "/" + totalGroupCount + " (" + statusDisplayName + ")";
SetStatus(groupStatusString);
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var groupsCmd = GetSQLCommand(true))
{
try
{
var testSetupName = GetTestSetupNameFromEmbeddedGroup(Convert.ToString(groupsDr["TestObjectName"]), dbName);
var origSerialNumber = Convert.ToString(groupsDr["TestObjectName"]);
var startIndex = testSetupName.Length + 1;
var displayName = origSerialNumber.Substring(startIndex, origSerialNumber.Length - startIndex);
var description = GetTestObjectTemplateDescription(Convert.ToString(groupsDr["TemplateName"]), dbName);
//Insert it into the Groups table
var groupId = InsertIntoGroupsTable(groupsCmd,
Convert.ToString(groupsDr["TestObjectName"]),
displayName,
description,
Convert.ToBoolean(groupsDr["Embedded"]),
Convert.ToDateTime(groupsDr["LastModified"]),
Convert.ToString(groupsDr["LastModifiedBy"]),
null
);
//Migrate from TestObjectHardware to GroupHardware
BuildGroupHardware(Convert.ToString(groupsDr["TestObjectName"]), groupId, dbName);
//Migrate from TestSetupObjects to TestSetupGroups
BuildTestSetupGroup(Convert.ToString(groupsDr["TestObjectName"]), groupId, out string testObjectType, out string position, dbName);
//Insert all of this Added Group's channels into the Channels table
InsertGroupChannelsIntoChannelsTable(Convert.ToString(groupsDr["TestObjectName"]),
groupId, Convert.ToString(groupsDr["TemplateName"]),
Convert.ToString(groupsDr["LastModifiedBy"]),
Convert.ToDateTime(groupsDr["LastModified"]),
true,
SetStatus,
groupStatusString,
testObjectType,
position,
ref groupChannelHelpers,
dbName);
//Update any Level Triggers associated with this Group
UpdateLevelTriggers(Convert.ToString(groupsDr["TestObjectName"]), groupChannelHelpers, dbName);
}
finally
{
groupsCmd.Connection.Dispose();
}
}
}
}
}
finally
{
testObjectsCmd.Connection.Dispose();
}
}
}
private void MoveCustomChannelsToChannelCodesTable(SetStatusDelegate SetStatus, string dbName)
{
//Get any Custom Channels from MMEPossibleChannels table and store in ChannelCodes table
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var possibleChannelsCmd = GetSQLCommand(true))
{
try
{
possibleChannelsCmd.CommandType = CommandType.StoredProcedure;
possibleChannelsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_MMEPossibleChannelsGetCustom.ToString();
possibleChannelsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = null });
using (var ds = Connection.QueryDataSet(possibleChannelsCmd))
{
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
var totalCustomChannelCount = ds.Tables[0].Rows.Count;
var count = 0;
foreach (DataRow dr in ds.Tables[0].Rows)
{
count++;
SetStatus("Adding Custom Channel " + count + "/" + totalCustomChannelCount);
bool nonISO = Convert.ToString(dr["TYPE"]).StartsWith("NONISO") && Convert.ToString(dr["TEXT_L1"]).Contains("_X_");
if (nonISO) continue;
var sb = new StringBuilder();
sb.Append(Convert.ToString(dr["TEST_OBJECT"]));
sb.Append(Convert.ToString(dr["POSITION"]));
sb.Append(Convert.ToString(dr["TRANS_MAIN_LOC"]));
sb.Append(Convert.ToString(dr["FINE_LOC_1"]));
sb.Append(Convert.ToString(dr["FINE_LOC_2"]));
sb.Append(Convert.ToString(dr["FINE_LOC_3"]));
sb.Append(Convert.ToString(dr["PHYSICAL_DIMENSION"]));
sb.Append(Convert.ToString(dr["DIRECTION"]));
sb.Append(Convert.ToString(dr["DEFAULT_FILTER_CLASS"]));
var channelName = Convert.ToString(dr["TEXT_L1"]);
//Insert into ChannelCodes table
ResetLocalConnectionStringDb(dbName);
using (var channelCodesCmd = GetSQLCommand(true))
{
try
{
channelCodesCmd.CommandType = CommandType.StoredProcedure;
channelCodesCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_ChannelCodesInsert.ToString();
channelCodesCmd.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar) { Value = sb.ToString() });
channelCodesCmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar) { Value = channelName });
channelCodesCmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.TinyInt) { Value = 1 });
var errorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
channelCodesCmd.Parameters.Add(errorNumberParam);
var errorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
channelCodesCmd.Parameters.Add(errorMessageParam);
var newIdParam = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
channelCodesCmd.Parameters.Add(newIdParam);
channelCodesCmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(errorMessageParam.Value.ToString());
}
}
finally
{
channelCodesCmd.Connection.Dispose();
}
}
}
}
}
}
finally
{
possibleChannelsCmd.Connection.Dispose();
}
}
}
private int InsertIntoGroupsTable(SqlCommand cmd, string groupName, string displayName, string description, bool embedded, DateTime lastModified, string lastModifiedBy,
int? staticGroupId)
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupsInsert.ToString();
cmd.Parameters.Clear();
#region params
cmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 255) { Value = groupName });
cmd.Parameters.Add(new SqlParameter("@DisplayName", SqlDbType.NVarChar, 255) { Value = displayName });
cmd.Parameters.Add(new SqlParameter("@Description", SqlDbType.NVarChar, 255) { Value = description });
cmd.Parameters.Add(new SqlParameter("@Embedded", SqlDbType.Bit) { Value = embedded });
cmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = lastModified });
cmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 50) { Value = lastModifiedBy });
cmd.Parameters.Add(new SqlParameter("@StaticGroupId", SqlDbType.Int) { Value = staticGroupId });
var ExtraProperties = new List<KeyValuePair<string, string>>();
cmd.Parameters.Add(new SqlParameter("@ExtraProperties", SqlDbType.NVarChar, -1)
{
Value = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(ExtraProperties)
});
var newGroupIdParam = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(newGroupIdParam);
var groupErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(groupErrorNumberParam);
var groupErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(groupErrorMessageParam);
#endregion params
cmd.ExecuteNonQuery();
if (int.Parse(groupErrorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(groupErrorMessageParam.Value.ToString());
}
var groupId = int.Parse(newGroupIdParam.Value.ToString());
return groupId;
}
private void BuildGroupHardware(string testObjectName, int groupId, string dbName)
{
//For any row in old TestObjectHardware table with this TestObjectId
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectHardwareCmd = GetSQLCommand(true))
{
try
{
testObjectHardwareCmd.CommandType = CommandType.StoredProcedure;
testObjectHardwareCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectHardwareIdsGet.ToString();
testObjectHardwareCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
using (var testObjectHardwareDs = Connection.QueryDataSet(testObjectHardwareCmd))
{
if (testObjectHardwareDs.Tables.Count <= 0 || testObjectHardwareDs.Tables[0].Rows.Count <= 0) return;
foreach (DataRow testObjectHardwareDr in testObjectHardwareDs.Tables[0].Rows)
{
//Get the DASId and enter it, with the new GroupId into the new GroupHardware table
var dasId = GetDASIdFromSerialNumber(Convert.ToString(testObjectHardwareDr["HardwareId"]), dbName);
InsertIntoGroupHardwareTable(groupId, dasId, dbName);
}
}
}
finally
{
testObjectHardwareCmd.Connection.Dispose();
}
}
}
private void BuildTestSetupGroup(string testObjectName, int groupId, out string testObjectType, out string position, string dbName)
{
testObjectType = "?";
position = "?";
//for any row in old TestSetupObjects table with this TestObjectId
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var TestSetupObjectsCmd = GetSQLCommand(true))
{
try
{
TestSetupObjectsCmd.CommandType = CommandType.StoredProcedure;
TestSetupObjectsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupObjectsGet.ToString();
TestSetupObjectsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
using (var TestSetupObjectsDs = Connection.QueryDataSet(TestSetupObjectsCmd))
{
if (TestSetupObjectsDs.Tables.Count != 1 || TestSetupObjectsDs.Tables[0].Rows.Count != 1) return;
foreach (DataRow TestSetupObjectsDr in TestSetupObjectsDs.Tables[0].Rows)
{
//Get the TestSetupId, DisplayOrder, Position, and TestObjectType and enter it, with the new GroupId into the new TestSetupGroups table
var testSetupId = GetTestSetupIdFromName(Convert.ToString(TestSetupObjectsDr["TestSetupName"]), dbName);
var displayOrder = TestSetupObjectsDr["DisplayOrder"] is DBNull ? -1 : Convert.ToInt32(TestSetupObjectsDr["DisplayOrder"]);
position = Convert.ToString(TestSetupObjectsDr["TestObjectPosition"]);
testObjectType = Convert.ToString(TestSetupObjectsDr["TestObjectType"]);
InsertIntoTestSetupGroupsTable(groupId, testSetupId, displayOrder, position, testObjectType, dbName);
}
}
}
finally
{
TestSetupObjectsCmd.Connection.Dispose();
}
}
}
public class GroupChannelHelper
{
public string TestObjectName { get; set; }
public int GroupId { get; set; }
public long ChannelId { get; set; }
public long MMEChannelType { get; set; }
public long MMEChannelId { get; set; }
}
private void InsertGroupChannelsIntoChannelsTable(string testObjectName, int groupId, string groupTemplateName,
string lastModifiedBy, DateTime lastModified, bool embedded, SetStatusDelegate SetStatus, string groupStatusString,
string testObjectType, string position, ref List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var templateChannelsCmd = GetSQLCommand(true))
{
try
{
//Get all required channels in this Group Template
templateChannelsCmd.CommandType = CommandType.StoredProcedure;
templateChannelsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TemplateChannelsGet.ToString();
templateChannelsCmd.Parameters.Add(new SqlParameter("@TemplateName", SqlDbType.NVarChar) { Value = groupTemplateName });
using (var templateChannelsDs = Connection.QueryDataSet(templateChannelsCmd))
{
var totalChannelCount = templateChannelsDs.Tables[0].Rows.Count;
var count = 0;
foreach (DataRow templateChannelsDr in templateChannelsDs.Tables[0].Rows)
{
count++;
if (!Convert.ToBoolean(templateChannelsDr["Required"])) continue;
var channelStatusString = groupStatusString + "; Adding channel " + count + "/" + totalChannelCount +
" (" + Convert.ToString(templateChannelsDr["NameOfTheChannel"]) + ")";
SetStatus(channelStatusString);
bool nonISO = false;
var mmeChannelId = Convert.ToInt64(templateChannelsDr["MMEChannelId"]);
var mmeChannelType = Convert.ToInt64(templateChannelsDr["MMEChannelType"]);
var testSetupChannelOrder = Convert.ToInt32(templateChannelsDr["DisplayOrder"]);
//Get the settings from the previous db that corresponds to this channel
var sensorName = GetSensorName(testObjectName,
mmeChannelId,
mmeChannelType,
out int? dasId,
out int dasChannelIndex,
out int groupChannelOrder,
dbName);
var storedProcedure = string.Empty;
if (Convert.ToInt32(templateChannelsDr["MMEChannelType"]) == 0)
{
//This is an ISO-defined channel
storedProcedure = DbOperationsEnum.StoredProcedure.sp_MMEPossibleChannelsGet.ToString();
}
else
{
//This is a Custom Channel
storedProcedure = DbOperationsEnum.StoredProcedure.sp_MMEPossibleChannelsGetCustom.ToString();
var type = GetPossibleChannelType(templateChannelsCmd, storedProcedure, mmeChannelId);
if (type == null)
{
continue; //The Custom Channel isn't in the db???????
}
else
{
nonISO = type.StartsWith("NONISO_x_");
}
}
string settings = string.Empty;
if (embedded)
{
var testSetupName = GetTestSetupNameFromEmbeddedGroup(testObjectName, dbName);
settings = GetTestChannelSettings(testSetupName, testObjectName, Convert.ToString(templateChannelsDr["NameOfTheChannel"]), sensorName, dbName);
}
else
{
settings = GetTestObjectChannelSettings(testObjectName, Convert.ToString(templateChannelsDr["NameOfTheChannel"]), sensorName, dbName);
}
//Parse the settings string into individual settings to find Filter
string filter = "?";
var settingsSplit = settings.Split(',');
foreach (var settingPair in settingsSplit)
{
var settingNameAndValue = settingPair.Split('=');
Enum.TryParse(settingNameAndValue[0], out SensorConstants.SensorSettings settingName);
if (settingName == SensorConstants.SensorSettings.CFC)
{
filter = settingNameAndValue[1];
}
else if (settingName == SensorConstants.SensorSettings.Position)
{
position = settingNameAndValue[1];
}
}
var isoCode = GetPossibleChannelISOCode(templateChannelsCmd,
storedProcedure,
mmeChannelId,
testObjectType,
position,
filter);
var isoChannelName = Convert.ToString(templateChannelsDr["NameOfTheChannel"]);
var userCode = string.Empty;
var userChannelName = string.Empty;
if (nonISO)
{
isoCode = string.Empty;
userChannelName = isoChannelName;
isoChannelName = string.Empty;
}
//Get the sensor id from the new database - this assumes that the sensors have already been migrated
int? sensorId = GetSensorId(sensorName, out var sensorType, out double squibOutputCurrent, dbName);
//SensorConstants.SensorSettings.SquibCurrent (18) was not in 1.10 settings, so add it here
if (sensorType == SensorConstants.SensorType.Squib)
{
if (settings.Length > 0)
{
settings = settings + ",";
}
settings = settings + (int)SensorConstants.SensorSettings.SquibCurrent + "=" + squibOutputCurrent;
}
long channelId = InsertIntoChannelsTable(
groupId,
isoCode,
isoChannelName,
userCode,
userChannelName,
dasId,
dasChannelIndex,
groupChannelOrder,
testSetupChannelOrder,
sensorId,
lastModified,
lastModifiedBy,
dbName);
groupChannelHelpers.Add(new GroupChannelHelper()
{
ChannelId = channelId,
GroupId = groupId,
TestObjectName = testObjectName,
MMEChannelId = mmeChannelId,
MMEChannelType = mmeChannelType
});
if (settings.Length > 0)
{
InsertIntoGroupChannelSettingsTable(channelId, settings, sensorType, dbName);
}
}
}
}
finally
{
templateChannelsCmd.Connection.Dispose();
}
}
}
private string GetTestSetupNameFromEmbeddedGroup(string testObjectName, string dbName)
{
var testSetupName = string.Empty;
//Get this Group's Test Setup name
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testSetupObjectsCmd = GetSQLCommand(true))
{
try
{
testSetupObjectsCmd.CommandType = CommandType.StoredProcedure;
testSetupObjectsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupObjectsGet.ToString();
testSetupObjectsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
using (var testSetupObjectsDs = Connection.QueryDataSet(testSetupObjectsCmd))
{
if (testSetupObjectsDs.Tables.Count > 0 && testSetupObjectsDs.Tables[0].Rows.Count > 0)
{
testSetupName = testSetupObjectsDs.Tables[0].Rows[0]["TestSetupName"].ToString();
}
}
}
finally { testSetupObjectsCmd.Connection.Dispose(); }
}
return testSetupName;
}
private string GetTestObjectTemplateDescription(string testObjectTemplateName, string dbName)
{
var description = string.Empty;
//Get this Group's Test Setup name
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectTemplatesCmd = GetSQLCommand(true))
{
try
{
testObjectTemplatesCmd.CommandType = CommandType.StoredProcedure;
testObjectTemplatesCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectTemplatesGet.ToString();
testObjectTemplatesCmd.Parameters.Add(new SqlParameter("@TemplateName", SqlDbType.NVarChar, 255) { Value = testObjectTemplateName });
using (var testSetupObjectsDs = Connection.QueryDataSet(testObjectTemplatesCmd))
{
if (testSetupObjectsDs.Tables.Count > 0 && testSetupObjectsDs.Tables[0].Rows.Count > 0)
{
description = testSetupObjectsDs.Tables[0].Rows[0]["Description"].ToString();
}
}
}
finally { testObjectTemplatesCmd.Connection.Dispose(); }
}
return description;
}
private void UpdateLevelTriggers(string testObjectName, List<GroupChannelHelper> groupChannelHelpers, string dbName)
{
//Update any Level Triggers in this Group with the channelId
var testSetupName = string.Empty;
//Get this Group's Test Setup name
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testSetupObjectsCmd = GetSQLCommand(true))
{
try
{
testSetupObjectsCmd.CommandType = CommandType.StoredProcedure;
testSetupObjectsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupObjectsGet.ToString();
testSetupObjectsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
using (var testSetupObjectsDs = Connection.QueryDataSet(testSetupObjectsCmd))
{
if (testSetupObjectsDs.Tables.Count > 0 && testSetupObjectsDs.Tables[0].Rows.Count > 0)
{
testSetupName = testSetupObjectsDs.Tables[0].Rows[0]["TestSetupName"].ToString();
}
}
}
finally { testSetupObjectsCmd.Connection.Dispose(); }
}
//Get all Level Triggers in this Test Setup
using (var levelTriggersCmd = GetSQLCommand(true))
{
try
{
levelTriggersCmd.CommandType = CommandType.StoredProcedure;
levelTriggersCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_LevelTriggersGet.ToString();
levelTriggersCmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar) { Value = testSetupName });
using (var levelTriggersDs = Connection.QueryDataSet(levelTriggersCmd))
{
foreach (DataRow row in levelTriggersDs.Tables[0].Rows)
{
//Find any Level Triggers in this Group
if (row["TestObjectName"].ToString() == testObjectName)
{
try
{
var testSetupId = GetTestSetupIdFromName(testSetupName, dbName);
var channelId = GetChannelIdFromGroupChannelHelper(groupChannelHelpers, row["TestObjectChannelId"].ToString());
InsertIntoLevelTriggersTable(testSetupId, testSetupName, channelId,
Convert.ToBoolean(row["GreaterThanEnabled"]), Convert.ToDouble(row["GreaterThanEU"]),
Convert.ToBoolean(row["LessThanEnabled"]), Convert.ToDouble(row["LessThanEU"]),
Convert.ToBoolean(row["TriggerInside"]), Convert.ToDouble(row["InsideUpperEU"]), Convert.ToDouble(row["InsideLowerEU"]),
Convert.ToBoolean(row["TriggerOutside"]), Convert.ToDouble(row["OutsideUpperEU"]), Convert.ToDouble(row["OutsideLowerEU"]),
dbName);
}
catch (Exception ex2)
{
APILogger.Log(ex2);
}
}
}
}
}
finally { levelTriggersCmd.Connection.Dispose(); }
}
}
private long GetChannelIdFromGroupChannelHelper(List<GroupChannelHelper> groupChannelHelpers, string testObjectChannelId)
{
foreach (var groupChannelHelper in groupChannelHelpers)
{
var testObjectChannelIdParts = testObjectChannelId.Split('_');
if (testObjectChannelIdParts.Count() > 3)
{
int stringIndex = 1;
while (stringIndex < testObjectChannelIdParts.Count() - 2)
{
testObjectChannelIdParts[0] = testObjectChannelIdParts[0] + "_" + testObjectChannelIdParts[stringIndex];
stringIndex++;
}
testObjectChannelIdParts[1] = testObjectChannelIdParts[stringIndex];
stringIndex++;
testObjectChannelIdParts[2] = testObjectChannelIdParts[stringIndex];
}
if (groupChannelHelper.TestObjectName == testObjectChannelIdParts[0] &&
groupChannelHelper.MMEChannelType == Convert.ToInt64(testObjectChannelIdParts[1]) &&
groupChannelHelper.MMEChannelId == Convert.ToInt64(testObjectChannelIdParts[2]))
{
return groupChannelHelper.ChannelId;
}
}
return 0;
}
private void GetAllGroupTemplates(SqlCommand cmd, bool addedGroupTemplates)
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectTemplatesGet.ToString();
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@TemplateName", SqlDbType.NVarChar) { Value = null });
cmd.Parameters.Add(new SqlParameter("@SysBuilt", SqlDbType.Bit) { Value = false });
}
private void GetAllGroups(SqlCommand cmd, string templateName, bool addedGroups)
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectsGet.ToString();
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar) { Value = null });
cmd.Parameters.Add(new SqlParameter("@TemplateName", SqlDbType.NVarChar) { Value = templateName });
cmd.Parameters.Add(new SqlParameter("@SysBuilt", SqlDbType.Bit) { Value = addedGroups });
}
private int GetDASIdFromSerialNumber(string serialNumber, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var dasCmd = GetSQLCommand(true))
{
try
{
dasCmd.CommandType = CommandType.StoredProcedure;
dasCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_DASGet.ToString();
dasCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 50) { Value = serialNumber });
dasCmd.Parameters.Add(new SqlParameter("@position", SqlDbType.NVarChar, 10) { Value = null });
using (var dasDs = Connection.QueryDataSet(dasCmd))
{
if (dasDs.Tables.Count <= 0 || dasDs.Tables[0].Rows.Count <= 0) return 0;
return Convert.ToInt32(dasDs.Tables[0].Rows[0]["DASId"]);
}
}
finally
{
dasCmd.Connection.Dispose();
}
}
}
private void InsertIntoGroupHardwareTable(int groupId, int dasId, string dbName)
{
ResetLocalConnectionStringDb(dbName);
using (var groupHardwareCmd = GetSQLCommand(true))
{
try
{
groupHardwareCmd.CommandType = CommandType.StoredProcedure;
groupHardwareCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupHardwareInsert.ToString();
groupHardwareCmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = groupId });
groupHardwareCmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
var newGroupHardwareIdParam = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupHardwareCmd.Parameters.Add(newGroupHardwareIdParam);
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupHardwareCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
groupHardwareCmd.Parameters.Add(errorMessage);
groupHardwareCmd.ExecuteNonQuery();
}
finally
{
groupHardwareCmd.Connection.Dispose();
}
}
}
private void InsertIntoTestSetupGroupsTable(int groupId, int testSetupId, int displayOrder, string position, string testObjectType, string dbName)
{
ResetLocalConnectionStringDb(dbName);
using (var testSetupGroupsCmd = GetSQLCommand(true))
{
try
{
testSetupGroupsCmd.CommandType = CommandType.StoredProcedure;
testSetupGroupsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestSetupGroupsInsert.ToString();
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = groupId });
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@DisplayOrder", SqlDbType.Int) { Value = displayOrder });
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@Position", SqlDbType.NVarChar, 1) { Value = position });
testSetupGroupsCmd.Parameters.Add(new SqlParameter("@TestObjectType", SqlDbType.NVarChar, 1) { Value = testObjectType });
var newChannelIdParam = new SqlParameter("@new_id", SqlDbType.BigInt) { Direction = ParameterDirection.Output };
testSetupGroupsCmd.Parameters.Add(newChannelIdParam);
var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
testSetupGroupsCmd.Parameters.Add(errorNumber);
var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
testSetupGroupsCmd.Parameters.Add(errorMessage);
testSetupGroupsCmd.ExecuteNonQuery();
}
finally
{
testSetupGroupsCmd.Connection.Dispose();
}
}
}
private string GetPossibleChannelISOCode(SqlCommand cmd, string storedProcedure, long ID, string testObjectType, string position, string filter)
{
//Get an ISO or Custom Channel from one of the MMEPossibleChannels table and generate an ISOCode
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = storedProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = ID });
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count <= 0 || ds.Tables[0].Rows.Count <= 0) return string.Empty;
var sb = new StringBuilder();
sb.Append(testObjectType);
sb.Append(position);
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["TRANS_MAIN_LOC"]));
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["FINE_LOC_1"]));
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["FINE_LOC_2"]));
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["FINE_LOC_3"]));
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["PHYSICAL_DIMENSION"]));
sb.Append(Convert.ToString(ds.Tables[0].Rows[0]["DIRECTION"]));
sb.Append(filter);
return sb.ToString();
}
}
private string GetPossibleChannelType(SqlCommand cmd, string storedProcedure, long ID)
{
//Get an ISO or Custom Channel from one of the MMEPossibleChannels table and return the TYPE property
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = storedProcedure;
cmd.Parameters.Clear();
cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.NVarChar) { Value = ID });
using (var ds = Connection.QueryDataSet(cmd))
{
if (ds.Tables.Count <= 0 || ds.Tables[0].Rows.Count <= 0) return null;
return Convert.ToString(ds.Tables[0].Rows[0]["TYPE"]);
}
}
private string GetSensorName(string testObjectName, long targetISOChannelId, long targetChannelType, out int? DASId, out int DASChannelIndex, out int groupChannelOrder,
string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectSensorsGet.ToString();
#region params
sensorsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
#endregion params
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (null != sensorsDs && sensorsDs.Tables.Count > 0)
{
foreach (DataRow sensorsDr in sensorsDs.Tables[0].Rows)
{
var splitAtUnderscores = Convert.ToString(sensorsDr["UIChannelID"]).Split('_');
var isoChannel = splitAtUnderscores[splitAtUnderscores.Length - 2];
var isoChannelId = splitAtUnderscores[splitAtUnderscores.Length - 1];
if (Convert.ToInt64(isoChannelId) == targetISOChannelId &&
Convert.ToInt64(isoChannel) == targetChannelType)
{
DASId = Convert.ToInt32(sensorsDr["DasId"]);
if (DASId == 0)
{
DASId = null;
}
DASChannelIndex = Convert.ToInt32(sensorsDr["DasChannelId"]);
if (DASChannelIndex > 0)
{
//It's returned 1-relative so make it 0-relative
DASChannelIndex--;
}
groupChannelOrder = Convert.ToInt32(sensorsDr["ChannelIdx"]);
return Convert.ToString(sensorsDr["SensorId"]);
}
}
}
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
DASId = null;
DASChannelIndex = 0;
groupChannelOrder = -1;
return string.Empty;
}
private int? GetSensorId(string sensorName, out SensorConstants.SensorType sensorType, out double squibOutputCurrent, string dbName)
{
int? sensorId = null;
squibOutputCurrent = 0.0D;
//Get from current db - this assumes that the Sensors and Sensors<x> tables have already been migrated
ResetLocalConnectionStringDb(dbName);
using (var sensorCmd = GetSQLCommand(true))
{
try
{
sensorCmd.CommandType = CommandType.StoredProcedure;
sensorCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsGet.ToString();
#region params
sensorCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null });
sensorCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 50) { Value = sensorName });
#endregion params
sensorCmd.ExecuteNonQuery();
using (var sensorDs = Connection.QueryDataSet(sensorCmd))
{
if (sensorDs == null || sensorDs.Tables == null || sensorDs.Tables.Count != 1 ||
sensorDs.Tables[0].Rows == null || sensorDs.Tables[0].Rows.Count != 1)
{
sensorType = SensorConstants.SensorType.Analog; //Can't return null without making this a nullable type
return null;
}
if (!Enum.TryParse(sensorDs.Tables[0].Rows[0]["SensorType"].ToString(), out sensorType))
{
return null;
}
}
}
finally
{
sensorCmd.Connection.Dispose();
}
}
ResetLocalConnectionStringDb(dbName);
using (var sensorsCmd = GetSQLCommand(true))
{
try
{
sensorsCmd.CommandType = CommandType.StoredProcedure;
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsAnalogGet.ToString();
break;
case SensorConstants.SensorType.DigitalIn:
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalInGet.ToString();
break;
case SensorConstants.SensorType.DigitalOut:
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsDigitalOutGet.ToString();
break;
case SensorConstants.SensorType.Squib:
sensorsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorsSquibGet.ToString();
break;
}
#region params
sensorsCmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null });
sensorsCmd.Parameters.Add(new SqlParameter("@SerialNumber", SqlDbType.NVarChar, 50) { Value = sensorName });
#endregion params
sensorsCmd.ExecuteNonQuery();
using (var sensorsDs = Connection.QueryDataSet(sensorsCmd))
{
if (sensorsDs == null || sensorsDs.Tables == null || sensorsDs.Tables.Count != 1 ||
sensorsDs.Tables[0].Rows == null || sensorsDs.Tables[0].Rows.Count != 1) return null;
sensorId = Convert.ToInt16(sensorsDs.Tables[0].Rows[0]["id"]);
if (sensorType == SensorConstants.SensorType.Squib)
{
squibOutputCurrent = Convert.ToDouble(sensorsDs.Tables[0].Rows[0]["SquibOutputCurrent"]);
}
}
}
finally
{
sensorsCmd.Connection.Dispose();
}
}
return sensorId;
}
private long InsertIntoChannelsTable(int groupId, string isoCode, string isoText, string userCode, string userChannelName, int? dasId,
int dasChannelIndex, int groupChannelOrder, int testSetupChannelOrder, int? sensorId, DateTime lastModified, string lastModifiedBy, string dbName)
{
long channelId = 0;
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var channelsCmd = GetSQLCommand(true))
{
try
{
channelsCmd.CommandType = CommandType.StoredProcedure;
channelsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_ChannelsInsert.ToString();
#region params
channelsCmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = groupId });
channelsCmd.Parameters.Add(new SqlParameter("@ISOCode", SqlDbType.NVarChar, 50) { Value = isoCode });
channelsCmd.Parameters.Add(new SqlParameter("@ISOChannelName", SqlDbType.NVarChar, 255) { Value = isoText });
channelsCmd.Parameters.Add(new SqlParameter("@UserCode", SqlDbType.NVarChar, 50) { Value = userCode });
channelsCmd.Parameters.Add(new SqlParameter("@UserChannelName", SqlDbType.NVarChar, 255) { Value = userChannelName });
channelsCmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
channelsCmd.Parameters.Add(new SqlParameter("@DASChannelIndex", SqlDbType.Int) { Value = dasChannelIndex });
channelsCmd.Parameters.Add(new SqlParameter("@GroupChannelOrder", SqlDbType.Int) { Value = groupChannelOrder });
channelsCmd.Parameters.Add(new SqlParameter("@TestSetupOrder", SqlDbType.Int) { Value = testSetupChannelOrder });
channelsCmd.Parameters.Add(new SqlParameter("@SensorId", SqlDbType.Int) { Value = sensorId });
channelsCmd.Parameters.Add(new SqlParameter("@Disabled", SqlDbType.Bit) { Value = 0 });
channelsCmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = lastModified });
channelsCmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 255) { Value = lastModifiedBy });
var newChannelIdParam = new SqlParameter("@new_id", SqlDbType.BigInt) { Direction = ParameterDirection.Output };
channelsCmd.Parameters.Add(newChannelIdParam);
var channelErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
channelsCmd.Parameters.Add(channelErrorNumberParam);
var channelErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
channelsCmd.Parameters.Add(channelErrorMessageParam);
#endregion params
channelsCmd.ExecuteNonQuery();
if (int.Parse(channelErrorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(channelErrorMessageParam.Value.ToString());
}
channelId = int.Parse(newChannelIdParam.Value.ToString());
}
finally
{
channelsCmd.Connection.Dispose();
}
}
return channelId;
}
private string GetTestObjectChannelSettings(string testObjectName, string channelIdString, string sensorSerialNumber, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectChannelSettingsCmd = GetSQLCommand(true))
{
try
{
testObjectChannelSettingsCmd.CommandType = CommandType.StoredProcedure;
testObjectChannelSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestObjectChannelSettingsGet.ToString();
#region params
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.NVarChar, 255) { Value = channelIdString });
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@Setting", SqlDbType.NVarChar, 255) { Value = null });
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@SensorSerialNumber", SqlDbType.NVarChar, 255) { Value = sensorSerialNumber });
#endregion params
using (var testObjectChannelSettingsDs = Connection.QueryDataSet(testObjectChannelSettingsCmd))
{
if (null != testObjectChannelSettingsDs && testObjectChannelSettingsDs.Tables.Count > 0 &&
null != testObjectChannelSettingsDs.Tables[0].Rows && testObjectChannelSettingsDs.Tables[0].Rows.Count > 0)
{
foreach (DataRow row in testObjectChannelSettingsDs.Tables[0].Rows)
{
var serialNumber = Convert.ToString(row[DbOperations.TestObjectChannelSettings.Fields.SerialNumber.ToString()]);
if (serialNumber == sensorSerialNumber)
{
return Convert.ToString(row["Setting"]);
}
}
}
}
}
finally
{
testObjectChannelSettingsCmd.Connection.Dispose();
}
}
return string.Empty;
}
private string GetTestChannelSettings(string testSetupName, string testObjectName, string channelIdString, string sensorSerialNumber, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var testObjectChannelSettingsCmd = GetSQLCommand(true))
{
try
{
testObjectChannelSettingsCmd.CommandType = CommandType.StoredProcedure;
testObjectChannelSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_TestChannelSettingsGet.ToString();
#region params
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = testSetupName });
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@TestObjectName", SqlDbType.NVarChar, 255) { Value = testObjectName });
testObjectChannelSettingsCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.NVarChar, 255) { Value = channelIdString });
#endregion params
using (var testObjectChannelSettingsDs = Connection.QueryDataSet(testObjectChannelSettingsCmd))
{
if (null != testObjectChannelSettingsDs && testObjectChannelSettingsDs.Tables.Count > 0 &&
null != testObjectChannelSettingsDs.Tables[0].Rows && testObjectChannelSettingsDs.Tables[0].Rows.Count > 0)
{
foreach (DataRow row in testObjectChannelSettingsDs.Tables[0].Rows)
{
if (Convert.ToString(row["TestName"]) == testSetupName &&
Convert.ToString(row["TestObjectName"]) == testObjectName &&
Convert.ToString(row["SensorSerial"]) == sensorSerialNumber)
{
return Convert.ToString(row["Setting"]);
}
}
}
}
}
finally
{
testObjectChannelSettingsCmd.Connection.Dispose();
}
}
return string.Empty;
}
private void InsertIntoGroupChannelSettingsTable(long channelId, string settings, SensorConstants.SensorType sensorType, string dbName)
{
//Parse the settings string into individual settings
var settingsSplit = settings.Split(',');
//For each setting, insert into table
foreach (var settingPair in settingsSplit)
{
var settingNameAndValue = settingPair.Split('=');
Enum.TryParse(settingNameAndValue[0], out SensorConstants.SensorSettings settingName);
//The following were deprecated in 2.1, so convert them based on their sensor type
//so that they match a SettingName in the ChannelSettings table (foreign key)
if (settingName != SensorConstants.SensorSettings.Position)
{
switch (sensorType)
{
case SensorConstants.SensorType.Analog:
if (settingName != SensorConstants.SensorSettings.Range &&
settingName != SensorConstants.SensorSettings.CFC &&
settingName != SensorConstants.SensorSettings.Polarity)
{
continue;
}
if (settingName == SensorConstants.SensorSettings.CFC)
{
settingName = SensorConstants.SensorSettings.FilterClass;
settingNameAndValue[1] = DTS.Common.Classes.Sensors.FilterClass.GetFilterClassSettingFromCFC(settingNameAndValue[1]);
}
break;
case SensorConstants.SensorType.DigitalIn:
if (settingName != SensorConstants.SensorSettings.DIMode &&
settingName != SensorConstants.SensorSettings.DefaultValue &&
settingName != SensorConstants.SensorSettings.ActiveValue)
{
continue;
}
break;
case SensorConstants.SensorType.Squib:
if (settingName != SensorConstants.SensorSettings.SQMode &&
settingName != SensorConstants.SensorSettings.LimitDuration &&
settingName != SensorConstants.SensorSettings.Duration &&
settingName != SensorConstants.SensorSettings.Delay &&
settingName != SensorConstants.SensorSettings.SquibCurrent)
{
continue;
}
switch (settingName)
{
case SensorConstants.SensorSettings.LimitDuration:
settingName = SensorConstants.SensorSettings.SquibLimitDuration;
break;
case SensorConstants.SensorSettings.Duration:
settingName = SensorConstants.SensorSettings.SquibDuration;
break;
case SensorConstants.SensorSettings.Delay:
settingName = SensorConstants.SensorSettings.SquibDelay;
break;
}
break;
case SensorConstants.SensorType.DigitalOut:
if (settingName != SensorConstants.SensorSettings.OutputMode &&
settingName != SensorConstants.SensorSettings.LimitDuration &&
settingName != SensorConstants.SensorSettings.Duration &&
settingName != SensorConstants.SensorSettings.Delay)
{
continue;
}
switch (settingName)
{
case SensorConstants.SensorSettings.LimitDuration:
settingName = SensorConstants.SensorSettings.DigitalOutLimitDuration;
break;
case SensorConstants.SensorSettings.Duration:
settingName = SensorConstants.SensorSettings.DigitalOutDuration;
break;
case SensorConstants.SensorSettings.Delay:
settingName = SensorConstants.SensorSettings.DigitalOutDelay;
break;
}
break;
}
var settingValue = settingNameAndValue[1];
var channelSettingId = GetChannelSettingId(settingName, dbName);
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var groupChannelSettingssCmd = GetSQLCommand(true))
{
try
{
groupChannelSettingssCmd.CommandType = CommandType.StoredProcedure;
groupChannelSettingssCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_GroupChannelSettingsInsert.ToString();
#region params
groupChannelSettingssCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
groupChannelSettingssCmd.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = channelSettingId });
groupChannelSettingssCmd.Parameters.Add(new SqlParameter("@SettingValue", SqlDbType.NVarChar, 255) { Value = settingValue });
var channelErrorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
groupChannelSettingssCmd.Parameters.Add(channelErrorNumberParam);
var channelErrorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
groupChannelSettingssCmd.Parameters.Add(channelErrorMessageParam);
#endregion params
groupChannelSettingssCmd.ExecuteNonQuery();
if (int.Parse(channelErrorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(channelErrorMessageParam.Value.ToString());
}
}
finally
{
groupChannelSettingssCmd.Connection.Dispose();
}
}
}
}
}
private void InsertIntoLevelTriggersTable(int testSetupId, string testSetupName, long channelId,
bool greaterThanEnabled, double greaterThanThresholdEU,
bool lessThanEnabled, double lessThanThresholdEU,
bool insideEnabled, double insideUpperLevelEU, double insideLowerLevelEU,
bool outsideEnabled, double outsideUpperLevelEU, double outsideLowerLevelEU,
string dbName)
{
//Insert into current db
ResetLocalConnectionStringDb(dbName);
using (var levelTriggersCmd = GetSQLCommand(true))
{
try
{
levelTriggersCmd.CommandType = CommandType.StoredProcedure;
levelTriggersCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_LevelTriggersInsert.ToString();
#region params
levelTriggersCmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
levelTriggersCmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = testSetupName });
levelTriggersCmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
levelTriggersCmd.Parameters.Add(new SqlParameter("@GreaterThanEnabled", SqlDbType.Bit) { Value = greaterThanEnabled });
levelTriggersCmd.Parameters.Add(new SqlParameter("@GreaterThanEU", SqlDbType.Float) { Value = greaterThanThresholdEU });
levelTriggersCmd.Parameters.Add(new SqlParameter("@LessThanEnabled", SqlDbType.Bit) { Value = lessThanEnabled });
levelTriggersCmd.Parameters.Add(new SqlParameter("@LessThanEU", SqlDbType.Float) { Value = lessThanThresholdEU });
levelTriggersCmd.Parameters.Add(new SqlParameter("@InsideEnabled", SqlDbType.Bit) { Value = insideEnabled });
levelTriggersCmd.Parameters.Add(new SqlParameter("@InsideUpperEU", SqlDbType.Float) { Value = insideUpperLevelEU });
levelTriggersCmd.Parameters.Add(new SqlParameter("@InsideLowerEU", SqlDbType.Float) { Value = insideLowerLevelEU });
levelTriggersCmd.Parameters.Add(new SqlParameter("@OutsideEnabled", SqlDbType.Bit) { Value = outsideEnabled });
levelTriggersCmd.Parameters.Add(new SqlParameter("@OutsideUpperEU", SqlDbType.Float) { Value = outsideUpperLevelEU });
levelTriggersCmd.Parameters.Add(new SqlParameter("@OutsideLowerEU", SqlDbType.Float) { Value = outsideLowerLevelEU });
var newIdParam = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
levelTriggersCmd.Parameters.Add(newIdParam);
var errorNumberParam = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
levelTriggersCmd.Parameters.Add(errorNumberParam);
var errorMessageParam = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
levelTriggersCmd.Parameters.Add(errorMessageParam);
#endregion params
levelTriggersCmd.ExecuteNonQuery();
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
{
APILogger.Log(errorMessageParam.Value.ToString());
}
}
finally
{
levelTriggersCmd.Connection.Dispose();
}
}
}
private int GetChannelSettingId(SensorConstants.SensorSettings settingName, string dbName)
{
int channelSettingId = 0;
//Get from current db
ResetLocalConnectionStringDb(dbName);
using (var channelSettingsCmd = GetSQLCommand(true))
{
try
{
channelSettingsCmd.CommandType = CommandType.StoredProcedure;
channelSettingsCmd.CommandText = DbOperationsEnum.StoredProcedure.sp_ChannelSettingsGet.ToString();
#region params
channelSettingsCmd.Parameters.Add(new SqlParameter("@SettingName", SqlDbType.NVarChar, 255) { Value = settingName.ToString() });
#endregion params
channelSettingsCmd.ExecuteNonQuery();
using (var channelSettingsDs = Connection.QueryDataSet(channelSettingsCmd))
{
if (channelSettingsDs == null || channelSettingsDs.Tables == null || channelSettingsDs.Tables.Count != 1 ||
channelSettingsDs.Tables[0].Rows == null || channelSettingsDs.Tables[0].Rows.Count != 1) return 0;
channelSettingId = Convert.ToInt16(channelSettingsDs.Tables[0].Rows[0]["Id"]);
}
}
finally
{
channelSettingsCmd.Connection.Dispose();
}
}
return channelSettingId;
}
private int GetTestSetupIdFromName(string testSetupName, string dbName)
{
ResetLocalConnectionStringDb(dbName + "Pre20");
using (var TestSetupCmd = GetSQLCommand(true))
{
try
{
TestSetupCmd.CommandType = CommandType.Text;
TestSetupCmd.CommandText = "SELECT TestSetupId FROM TestSetups WHERE TestSetupName = @TestSetupName";
TestSetupCmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = testSetupName });
using (var TestSetupObjectsDs = Connection.QueryDataSet(TestSetupCmd))
{
if (TestSetupObjectsDs.Tables.Count != 1 || TestSetupObjectsDs.Tables[0].Rows.Count != 1) return 0;
return Convert.ToInt32(TestSetupObjectsDs.Tables[0].Rows[0]["TestSetupId"]);
}
}
finally
{
TestSetupCmd.Connection.Dispose();
}
}
}
/// <summary>
/// updates all g5 vds channels to support HalfBridge Plus sig
/// </summary>
/// <returns></returns>
private bool MigrateVersion66()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
cmd.CommandType = CommandType.Text;
cmd.CommandText =
"SELECT DISTINCT(A.[DASId]) FROM [DAS] as A inner join [DASChannels] as B on A.DASId=B.DASId where A.Type=12";
var dasIds = new List<int>();
var reader = cmd.ExecuteReader();
while (reader.Read())
{
dasIds.Add(Convert.ToInt32(reader["DASId"]));
}
reader.Close();
if (dasIds.Any())
{
var sb = new StringBuilder();
//12431 Cannot run test after 1.4 to 1.10 migration with TDAS G5 VDS.
sb.Append("UPDATE [DASChannels] SET SupportedBridges=140 WHERE SupportedBridges=12 AND DASID in (");
var bNeedComma = false;
foreach (var id in dasIds)
{
if (bNeedComma)
{
sb.Append(", ");
}
sb.Append(id);
bNeedComma = true;
}
sb.Append(")");
cmd.CommandText = sb.ToString();
cmd.ExecuteNonQuery();
}
InsertIntoSqlVersionsTable(cmd, 67, 0);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion65()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION66");
Transaction(cmd, "BEGIN", 66);
ExecuteScript("ALTERTestSetupObjects_66.sql", cmd);
ExecuteScript("sp_TestSetupObjectsGet_66.sql", cmd);
ExecuteScript("sp_TestSetupObjectsInsert_66.sql", cmd);
ExecuteScript("sp_TestSetupObjectsUpdate_66.sql", cmd);
ExecuteScript("sp_TestSetupObjectsUpdateInsert_66.sql", cmd);
log.WriteEntry("Issuing COMMIT TRANSACTION66");
Transaction(cmd, "COMMIT", 66);
InsertIntoSqlVersionsTable(cmd, 66, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION66");
Transaction(cmd, "ROLLBACK", 66);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion63()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION64");
Transaction(cmd, "BEGIN", 64);
log.WriteEntry("Executing script: SensorsDigitalIn_AddMeasurementUnitField.sql");
var scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("SensorsDigitalIn_AddMeasurementUnitField.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInGet.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInGet.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInInsert.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInInsert.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdate.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdate.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdateAll.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdateAll.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdateInsert.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdateInsert.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_DBImportSensorsDigitalInput.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_DBImportSensorsDigitalInput.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: SensorsDigitalIn_AddFilterClassField.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("SensorsDigitalIn_AddFilterClassField.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInGet_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInGet_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInInsert_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInInsert_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdate_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdate_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdateAll_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdateAll_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_SensorsDigitalInUpdateInsert_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_SensorsDigitalInUpdateInsert_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Executing script: sp_DBImportSensorsDigitalInput_64.sql");
scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_DBImportSensorsDigitalInput_64.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Issuing COMMIT TRANSACTION63");
Transaction(cmd, "COMMIT", 64);
InsertIntoSqlVersionsTable(cmd, 64, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION63");
Transaction(cmd, "ROLLBACK", 64);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion62()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION63");
Transaction(cmd, "BEGIN", 63);
log.WriteEntry("Executing script: sp_TemplateChannelsDeleteOne_62.sql");
var scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_TemplateChannelsDeleteOne_62.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Issuing COMMIT TRANSACTION63");
Transaction(cmd, "COMMIT", 63);
InsertIntoSqlVersionsTable(cmd, 63, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION63");
Transaction(cmd, "ROLLBACK", 63);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
log.WriteEntry("Throwing exception due to: " + ex.Message);
throw new Exception(ex.Message, ex);
}
return true;
}
private bool MigrateVersion61()
{
try
{
using (var cmd = GetSQLCommand(true))
{
try
{
log.WriteEntry("Issuing BEGIN TRANSACTION62");
Transaction(cmd, "BEGIN", 62);
log.WriteEntry("Executing script: sp_TestSetupsDelete.sql");
var scriptString = DatabaseMigrationScripts.EmbeddedResource.GetString("sp_TestSetupsDelete.sql");
ExecuteScriptCommand(cmd, scriptString);
log.WriteEntry("Issuing COMMIT TRANSACTION62");
Transaction(cmd, "COMMIT", 62);
InsertIntoSqlVersionsTable(cmd, 62, 0);
}
catch (Exception ex)
{
log.WriteEntry("Issuing ROLLBACK TRANSACTION62");
Transaction(cmd, "ROLLBACK", 62);
throw new Exception(ex.Message, ex);
}
finally
{
cmd.Connection.Dispose();
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return true;
}
private void MigrateVersion60()
{
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = "ALTER TABLE [tblDAS] ADD PositionOnDistributor [smallint] NULL";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
cmd.CommandText = "ALTER TABLE [tblDAS] ADD PositionOnChain [smallint] NULL";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
cmd.CommandText = "ALTER TABLE [tblDAS] ADD Port [smallint] NULL";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
//just using 50 here because existing SerialNumber field is 50 characters
cmd.CommandText = "ALTER TABLE [tblDAS] ADD ParentDAS [nvarchar](50) NULL";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
finally
{
cmd.Connection.Dispose();
}
}
InsertIntoVersionsTable(61, 0);
}
private void MigrateVersion56()
{
using (var cmd = GetCommand())
{
cmd.CommandText = "ALTER TABLE [tblTestObjects] ADD Dirty bit NULL;";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
cmd.CommandText = "ALTER TABLE [tblTestObjects] ADD Complete bit NULL";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
if (_usingMSSQL)
{
cmd.CommandText = "ALTER TABLE [tblTestObjects] ADD ErrorMessage [nvarchar](max) NULL";
ExecuteCommand(cmd);
}
else
{
cmd.CommandText = "ALTER TABLE [tblTestObjects] ADD ErrorMessage [nvarchar](4000) NULL";
ExecuteSQLiteCommand(cmd);
}
cmd.CommandText = "UPDATE tblTestObjects SET Dirty=1, Complete=0, ErrorMessage=''";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
InsertIntoVersionsTable(57, 0);
}
private void MigrateVersion58()
{
CreateSLICE6Db_PrototypeHardware();
InsertIntoVersionsTable(59, 0);
}
/// <summary>
/// adds 2 tables for user settings (defaultproperties and userproperties)
/// 6508 Move test setup defaults from config to the database and make user specific
/// </summary>
private void MigrateVersion57()
{
CreateUserSettingsTableMssql();
InsertIntoVersionsTable(58, 0);
}
/// <summary>
/// increases the size of the Settings column to accomodate more than 255 chars
/// </summary>
private void MigrateVersion59()
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = "ALTER TABLE tblTestSetups ALTER COLUMN Settings nvarchar(max) NOT NULL;";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
InsertIntoVersionsTable(60, 0);
}
/// <summary>
/// creates defaultproperties and userproperties with keys, FKs, and indices
/// appropriate for Mssql
/// </summary>
private void CreateUserSettingsTableMssql()
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = @"CREATE TABLE [DefaultProperties](
[PropertyId] [int] NOT NULL,
[PropertyName] [nvarchar](255) NOT NULL,
[DefaultValue] [nvarchar](255) NOT NULL,
CONSTRAINT [PK_DefaultProperties] PRIMARY KEY CLUSTERED
(
[PropertyId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] ";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
using (var sql = GetCommand())
{
try
{
sql.CommandText = @"CREATE TABLE [dbo].[UserProperties](
[UserId] [int] NOT NULL,
[PropertyId] [int] NOT NULL,
[PropertyValue] [nvarchar](max) NOT NULL,
CONSTRAINT [IX_UserSettings] UNIQUE NONCLUSTERED
(
[UserId] ASC,
[PropertyId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
sql.CommandText =
@"ALTER TABLE [dbo].[UserProperties] WITH CHECK ADD CONSTRAINT [FK_UserProperties_DataPROUsers] FOREIGN KEY([UserId])
REFERENCES [dbo].[DataPROUsers] ([ID])";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
sql.CommandText =
@"ALTER TABLE [dbo].[UserProperties] CHECK CONSTRAINT [FK_UserProperties_DataPROUsers]";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
sql.CommandText =
@"ALTER TABLE [dbo].[UserProperties] WITH CHECK ADD CONSTRAINT [FK_UserProperties_DefaultProperties] FOREIGN KEY([PropertyId])
REFERENCES [dbo].[DefaultProperties] ([PropertyId])";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
sql.CommandText =
@"ALTER TABLE [dbo].[UserProperties] CHECK CONSTRAINT [FK_UserProperties_DefaultProperties]";
if (_usingMSSQL)
{
ExecuteCommand(sql);
}
else
{
ExecuteSQLiteCommand(sql);
}
}
finally
{
sql.Connection.Dispose();
}
}
}
/// <summary>
/// Sets software zeroing method to NONE for IRTRACC with Cal Factor
/// Migrates version 54 to 55
/// http://fogbugz/fogbugz/default.asp?9734
/// </summary>
private void MigrateVersion54()
{
using (var cmdQRY = GetCommand())
{
try
{
//Get all Calibrations
cmdQRY.CommandText = "SELECT * from tblSensorCalibrations";
using (var ds = QueryDataSet(cmdQRY))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
var nonLinear =
Convert.ToBoolean(dr[SensorDB.SensorCalibrationFields.NonLinear.ToString()]);
// only need to find the nonlinears
if (nonLinear)
{
var serialNumber =
Convert.ToString(dr[SensorDB.SensorCalibrationFields.SerialNumber.ToString()]);
var calDate =
Convert.ToDateTime(dr[SensorDB.SensorCalibrationFields.CalibrationDate.ToString()]);
var modifyDate =
Convert.ToDateTime(dr[SensorDB.SensorCalibrationFields.ModifyDate.ToString()]);
var cr = Convert.ToString(
dr[SensorDB.SensorCalibrationFields.CalibrationRecords.ToString()]);
var excitationRecords = cr.Split(new[] { "__x__" }, StringSplitOptions.None);
for (var i = 0; i < excitationRecords.Length; i++)
{
// split record into fields
var calRecordFields = excitationRecords[i].Split(',');
// Only need the IRTRACC with Cal factor records
if (calRecordFields[(int)SensorDB.SensorCalibrationRecordFields.Poly].StartsWith(
"IRTraccCalFactor"))
using (var cmdEX = GetSQLCommand())
{
try
{
cmdEX.CommandText =
"UPDATE tblSensorCalibrations SET ZeroMethod='None,-0.05,-0.02' where SerialNumber=@SerialNumber AND CalibrationDate=@CalibrationDate AND ModifyDate=@ModifyDate";
CreateParam(cmdEX, "@SerialNumber", SqlDbType.NVarChar, serialNumber);
CreateParam(cmdEX, "@CalibrationDate", SqlDbType.DateTime, calDate);
CreateParam(cmdEX, "@ModifyDate", SqlDbType.DateTime, modifyDate);
if (_usingMSSQL)
{
ExecuteCommand(cmdEX);
}
else
{
ExecuteSQLiteCommand(cmdEX);
}
}
finally
{
cmdEX.Connection.Dispose();
}
}
}
}
}
}
}
finally
{
cmdQRY.Connection.Dispose();
}
}
InsertIntoVersionsTable(55, 0);
}
private void MigrateVersion55()
{
if (_usingMSSQL)
{
using (var sql = GetCommand())
{
try
{
sql.CommandText = "ALTER TABLE tblSensors ALTER COLUMN Comment nvarchar(255) NULL;";
ExecuteCommand(sql);
}
finally
{
sql.Connection.Dispose();
}
}
}
InsertIntoVersionsTable(56, 0);
}
/// <summary>
/// Creates Prototype Hardware for SLICE6
/// </summary>
private void MigrateVersion52()
{
CreateSLICE6_PrototypeHardware();
InsertIntoVersionsTable(53, 0);
}
/// <summary>
/// as part of migration from 52 to 53 users have to be moved into a new table
/// this handles that portion of the migration
/// </summary>
private void MigrateUsers()
{
var users = new List<UserMigrationHelper>();
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = @"SELECT [UserName],[DisplayName],[Password],[IUIItemPermissions],[IUIItemVisibility],[Role],[LastModified],[LastModifiedBy],[Version],[LocalOnly],[UserTags] from [tblUsers]";
using (var ds = Connection.QueryDataSet(cmd))
{
users.AddRange(from DataRow row in ds.Tables[0].Rows select new UserMigrationHelper(row));
}
}
finally
{
cmd.Connection.Dispose();
}
}
if (users.Any())
{
var uiItems = new List<string>();
foreach (var user in users.Where(x => x.Permissions.Any()))
{
using (var e = user.Permissions.GetEnumerator())
{
while (e.MoveNext())
{
if (!uiItems.Contains(e.Current.Key))
{
uiItems.Add(e.Current.Key);
}
}
}
}
if (uiItems.Any())
{
InsertIUIItems(uiItems.ToArray());
}
var lookup = GetPermissionsLookup();
foreach (var user in users)
{
user.Commit(lookup);
}
}
using (var cmd = GetCommand())
{
try
{
cmd.CommandText = @"DROP TABLE [tblUsers]";
if (_usingMSSQL)
{
ExecuteCommand(cmd);
}
else
{
ExecuteSQLiteCommand(cmd);
}
}
finally
{
cmd.Connection.Dispose();
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink