eDosStationFull/syncEdosLocal/Program.cs

660 lines
34 KiB
C#
Raw Permalink Normal View History

2026-08-18 12:15:26 +02:00
using System.Runtime.InteropServices;
using LSWLib;
using System;
using System.Data;
using System.Data.SqlClient;
using System.Text;
using spl = LSWLib.CLog;
namespace syncEdosLocal
{
class cResult
{
const string className = "cResult";
public DateTime timestamp;
public int VisitsNew, VisitsSkipped, VisitsAddedExits, VisitsAddedEntries;
public int ID_Visit_Min, ID_Visit_Max;
public int Persons, Tasks;
public string ErrorMessage;
System.Data.SqlClient.SqlCommand cmd;
spl spLog;
internal int ID_Station;
public cResult(int? iID_station, SqlConnection co, spl Log)
{
if (iID_station.HasValue) ID_Station = iID_station.Value; else ID_Station = -1;
ErrorMessage = string.Empty;
VisitsNew = VisitsSkipped = VisitsAddedExits = VisitsAddedEntries = 0;
ID_Visit_Min = int.MaxValue; ID_Visit_Max = int.MinValue;
Persons = Tasks = 0;
spLog = Log;
MakeCmd(co);
}
public override string ToString()
{
return $"Success: {VisitsNew} new , {VisitsAddedEntries} Added Entries, {VisitsAddedExits} Added Exits, {VisitsSkipped} skipped";
}
private void MakeCmd(SqlConnection co)
{
cmd = new System.Data.SqlClient.SqlCommand("[syncLoc].[SyncStatusUpdate]", co) { CommandType = System.Data.CommandType.StoredProcedure };
cmd.Parameters.AddRange(new System.Data.SqlClient.SqlParameter[] {
new System.Data.SqlClient.SqlParameter("ID_Station",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("TimeStamp",SqlDbType.DateTime,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("New",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("Entries",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("Exits",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("Skipped",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("ErrorMessage",SqlDbType.VarChar,512,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("ID_Visit_Min",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("ID_Visit_Max",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("Persons",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
,new System.Data.SqlClient.SqlParameter("Tasks",SqlDbType.Int,0,System.Data.ParameterDirection.Input,false,0,0,null,System.Data.DataRowVersion.Default,null)
});
}
public void Write()
{
const string module = "Write";
string step = null;
try
{
spLog.SeverityReset();
timestamp = DateTime.Now;
if (ID_Station > 0)
{
cmd.Parameters["ID_Station"].Value = ID_Station;
cmd.Parameters["TimeStamp"].Value = timestamp;
cmd.Parameters["New"].Value = VisitsNew;
cmd.Parameters["Entries"].Value = VisitsAddedEntries;
cmd.Parameters["Exits"].Value = VisitsAddedEntries;
cmd.Parameters["Skipped"].Value = VisitsSkipped;
cmd.Parameters["ErrorMessage"].Value = ErrorMessage;
cmd.Parameters["ID_Visit_Min"].Value = ID_Visit_Min;
cmd.Parameters["ID_Visit_Max"].Value = ID_Visit_Max;
cmd.Parameters["Persons"].Value = Persons;
cmd.Parameters["Tasks"].Value = Tasks;
ConnectionState cs = cmd.Connection.State;
if (cs != ConnectionState.Open) cmd.Connection.Open();
cmd.ExecuteNonQuery();
if (cs != ConnectionState.Open) cmd.Connection.Close();
spLog.WriteSplunkLog(module,step, spLog.splunkSeverity ); ;
}
}
catch (System.Exception ex)
{
spLog.setErrorException(ex);
spLog.WriteException(module,step, ex);
}
}
internal void CheckVisitID(int iD_Visit)
{
if (ID_Visit_Max < iD_Visit) ID_Visit_Max = iD_Visit;
if (ID_Visit_Min > iD_Visit) ID_Visit_Min = iD_Visit;
}
}
class Program
{
//[DllImport("kernel32.dll")] static extern IntPtr GetConsoleWindow();
//[DllImport("user32.dll")] static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
//const int SW_HIDE = 0;
//const int SW_SHOW = 5;
const string moduleName = "syncEdosLocal";
public static string pcName;
public static int Verbose;
public static DataSet ds = null;
static System.Data.SqlClient.SqlInfoMessageEventHandler iMessage = new SqlInfoMessageEventHandler(Connection_InfoMessage);
static bool error = false;
static bool warning = false;
static StringBuilder messages = null;
static string splunkMessage = string.Empty;
static spl spLog;
static LSWLib.Bulker Bulker;
static cResult Result;
static System.IO.StreamWriter oStream;
public static int? CreateStationID(SqlConnection eDosLocalCon, SqlConnection eDosCon)
{
var c1 = eDosCon.State;
if (c1 != ConnectionState.Open) eDosCon.Open();
var c2 = eDosLocalCon.State;
if (c2 != ConnectionState.Open) eDosLocalCon.Open();
int? StationID = Bulker.SqlCommands.ExecProcScalar("Get Station ID", eDosCon, "GetNewID_LocalStation", true, ref error) as int?;
if (StationID.HasValue)
{
Bulker.SqlCommands.ExecProcScalar("Set Station ID", eDosLocalCon, $"SetNewID_LocalStation {StationID.Value}", true, ref error);
}
else StationID = null;
if (c2 != ConnectionState.Open) eDosLocalCon.Close();
if (c1 != ConnectionState.Open) eDosCon.Close();
return StationID;
}
public static void UpdateRemoteReturns(SqlConnection eDosLocalCon)
{
const string taskName = "UpdateRemoteReturns";
var oldState = eDosLocalCon.State;
if (oldState == ConnectionState.Closed) eDosLocalCon.Open();
using (var cmd = new System.Data.SqlClient.SqlCommand("[syncloc].[UpdateRemoteReturns]", eDosLocalCon))
{
spLog.KvClear();
cmd.CommandType = CommandType.StoredProcedure;
if (!string.IsNullOrEmpty(pcName)) cmd.Parameters.AddWithValue("@pcnr", pcName);
spLog.KvAddCommand(spl.skeys.sqlQuery, cmd);
try
{
cmd.ExecuteNonQuery();
spLog.WriteSplunkLog(taskName, null, spl.iseverity.info);
}
catch (System.Exception ex)
{
spLog.WriteException( taskName, null, ex);
}
}
}
public static bool DoorloopToDo(System.Data.SqlClient.SqlConnection fromConnection, string toConstr, System.Data.SqlClient.SqlInfoMessageEventHandler im, ref bool error, ref bool warning)
{
const string module = "DoorloopToDo";
string step = null;
int ciIgnoreError = -1;
bool ignorederror = false;
ds = new DataSet();
DataTable dtTables = new DataTable("Tables");
ds.Tables.Add(dtTables);
DataTable dtActions = new DataTable("Actions");
ds.Tables.Add(dtActions);
{
using (var cmd = new System.Data.SqlClient.SqlCommand("syncloc.SynchroToLocalTables", fromConnection))
{
spLog.KvClear();
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter pa = new SqlParameter("@withIgnoreError", true);
cmd.Parameters.Add(pa);
spLog.KvAddCommand(spl.skeys.sqlQuery, cmd);
using (var ncta = new System.Data.SqlClient.SqlDataAdapter(cmd))
{
try
{
step = "LoadTables";
ncta.Fill(dtTables);
int r = dtTables.Rows.Count;
ciIgnoreError = dtTables.Columns.IndexOf("ignoreError");
spLog.KvAdd(spl.skeys.recordsAffected, r);
spLog.WriteSplunkLog(module,step,spl.iseverity.info);
}
catch (System.Exception ex)
{
spLog.TableErrorToLog(dtTables);
spLog.WriteException(module,step,ex);
}
}
}
spLog.KvClear();
dtTables.PrimaryKey = new DataColumn[] { dtTables.Columns["object_id"] };
step = "SynchroToLocalActions";
using (var cmd = new System.Data.SqlClient.SqlCommand("syncloc.SynchroToLocalActions", fromConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
using (var ncta = new System.Data.SqlClient.SqlDataAdapter(cmd))
{
try
{
ncta.Fill(dtActions);
spLog.KvAdd(spl.skeys.recordsAffected, dtActions.Rows.Count);
spLog.WriteSplunkLog(module,step,spl.iseverity.info);
}
catch (System.Exception ex)
{
spLog.WriteException(module, step, ex);
}
}
}
dtActions.PrimaryKey = new DataColumn[] { dtActions.Columns["object_id"], dtActions.Columns["Type"], dtActions.Columns["r"] };
dtActions.ParentRelations.Add(new DataRelation("pObject", dtTables.Columns["object_id"], dtActions.Columns["object_id"]));
StringBuilder sqlCmdsActivate = null;
StringBuilder sqlCmdsDeActivate = null;
string Task = string.Empty;
string dest = string.Empty;
string qry = string.Empty;
step = "SynchroToLocalTablesUpdate";
using (System.Data.SqlClient.SqlConnection toConnection = new SqlConnection(toConstr))
{
spLog.KvClear();
spLog.KvAdd(toConnection);
toConnection.InfoMessage += im;
toConnection.Open();
if (toConnection.State == ConnectionState.Open)
using (var ucmd = new System.Data.SqlClient.SqlCommand("syncloc.SynchroToLocalTablesUpdate", fromConnection))
{
ucmd.CommandType = CommandType.StoredProcedure;
SqlParameter pa = new SqlParameter("ID_Station", SqlDbType.Int, 4); ucmd.Parameters.Add(pa); pa.Value = Result.ID_Station;
pa = new SqlParameter("OBJECT_ID", SqlDbType.Int, 4); pa.Value = Result.ID_Station; ucmd.Parameters.Add(pa);
pa = new SqlParameter("lastRecords", SqlDbType.Int, 4); ucmd.Parameters.Add(pa);
pa = new SqlParameter("constraintsDeactivated", SqlDbType.Bit); ucmd.Parameters.Add(pa);
pa = new SqlParameter("constraintsActivated", SqlDbType.Bit); ucmd.Parameters.Add(pa);
pa = new SqlParameter("syncError", SqlDbType.Bit); ucmd.Parameters.Add(pa);
if (fromConnection.State == ConnectionState.Closed) fromConnection.Open();
foreach (DataRow rtr in dtTables.Rows)
{
ucmd.Parameters["OBJECT_ID"].Value = (int)rtr[0];
string src = rtr[1].ToString();
dest = rtr[2].ToString();
var x = rtr.GetChildRows(dtActions.ParentRelations[0]);
Task = $"Table {dest}";
oStream?.WriteLine($"*** Step {rtr[1].ToString()}");
if (x.Length > 0)
{
sqlCmdsActivate = new StringBuilder();
sqlCmdsDeActivate = new StringBuilder();
foreach (DataRow aa in x)
{
sqlCmdsDeActivate.Append($" {aa["ActionDeActivate"].ToString()};");
sqlCmdsActivate.Append($" {aa["ActionActivate"].ToString()};");
}
}
else
{
sqlCmdsActivate = sqlCmdsDeActivate = null;
}
int res = 0;
step = "Deactivate";
if (sqlCmdsDeActivate != null)
using (var cmd = new System.Data.SqlClient.SqlCommand(sqlCmdsDeActivate.ToString(), toConnection) { CommandType= CommandType.Text })
{
try
{
spLog.SeverityReset();
spLog.KvAddCommand(spl.skeys.sqlQuery, cmd);
res = cmd.ExecuteNonQuery();
messages.AppendLine($"Success:Query={sqlCmdsDeActivate.ToString()}");
ucmd.Parameters["constraintsDeactivated"].Value = true;
spLog.WriteSplunkLog(module,step,spl.iseverity.info );
}
catch (System.Exception ex)
{
error = true;
messages.AppendLine(spLog.splunkError);
ucmd.Parameters["constraintsDeactivated"].Value = false;
spLog.WriteException(module,step, ex);
}
}
error = false;
int cnt = 0;
step = "GetColumnsQuery";
try
{
qry = LSWLib.SqlCommands.getColumnsQry(fromConnection, src);
spLog?.KvAdd(spl.skeys.sqlQuery, qry);
spLog?.WriteSplunkLog(module, step, spl.iseverity.info);
} catch (System.Exception ex)
{
qry = null;
spLog?.WriteException(module,step,ex);
}
spLog.KvClear();
SqlConnection[] curDests = new SqlConnection[] { toConnection };
step = "BulkTask";
ignorederror = false;
if (!string.IsNullOrEmpty(qry))
{
spLog?.KvAdd(spl.skeys.sqlQuery, qry);
cnt = Bulker.Execute(step, fromConnection, curDests, qry, CommandType.Text, dest, 0, ref error);
ucmd.Parameters["lastRecords"].Value = cnt;
if (dest.Contains("PersonInfo"))
Result.Persons = cnt;
else if (dest.Contains("TaskInfo")) Result.Tasks = cnt;
if (error && ciIgnoreError >= 0 && rtr[ciIgnoreError] is bool && (bool)rtr[ciIgnoreError])
{
error = false;
ignorederror = true;
spLog.WriteSplunkLogM(step, spl.iseverity.err);
}
else spLog.WriteSplunkLogM(step, spl.iseverity.info);
}
spLog.KvClear();
step = "Deactivate";
if (sqlCmdsActivate != null)
using (var cmd = new System.Data.SqlClient.SqlCommand(sqlCmdsActivate.ToString(), toConnection))
{
cmd.CommandType = CommandType.Text;
spLog.KvClear();
spLog.KvAddCommand(spl.skeys.sqlQuery, cmd);
try
{
spLog.SeverityReset();
res = cmd.ExecuteNonQuery();
messages.AppendLine($"Success:Query={sqlCmdsActivate.ToString()}");
ucmd.Parameters["constraintsActivated"].Value = true;
spLog?.WriteSplunkLog(module,step,spl.iseverity.info);
}
catch (System.Exception ex)
{
error = true;
ucmd.Parameters["constraintsActivated"].Value = false;
messages.AppendLine(spLog.splunkError);
spLog.WriteException(module,step,ex);
}
}
ucmd.Parameters["syncError"].Value = error | ignorederror;
try
{
spLog.KvClear();
spLog.KvAddCommand(spl.skeys.sqlQuery, ucmd);
ucmd.ExecuteNonQuery();
}
catch (System.Exception ex)
{
spLog.WriteException(module, step, ex);
}
if (error) break;
}
}
}
}
return error;
}
static void Main(string[] args)
{
const string module = "Main";
string step = null;
bool hasConsole;
Verbose = -1;
hasConsole = LSWLib.Util.hasConsole();
if (hasConsole)
{
Verbose = 1;
for (int ai = 0; ai < args.Length; ai++)
{
if (args[ai][0] == '-' && args[ai].Length > 1)
{
switch (args[ai][1])
{
case 's': Verbose = 0; break;
case 'v': Verbose = 1; break;
}
}
}
}
else Verbose = 0;
if (Verbose > 0)
{
LSWLib.Util.ShowConsoleWindow();
oStream = new System.IO.StreamWriter(System.Console.OpenStandardOutput());
}
else
{
oStream = null; // new System.IO.StreamWriter( System.IO.Stream.Null);
LSWLib.Util.HideConsoleWindow();
}
pcName = System.Environment.MachineName;
spLog = new spl(moduleName, hourlyLog:true);
Bulker = new LSWLib.Bulker(spLog, false);
messages = Bulker.messages;
messages.AppendLine(spLog.GetStartInfoString());
//Sync need both
var SourceCoStr = new SqlConnectionStringBuilder(System.Configuration.ConfigurationManager.ConnectionStrings["eDosConnectionString"].ConnectionString);
var LocalCoStr = new SqlConnectionStringBuilder(System.Configuration.ConfigurationManager.ConnectionStrings["LocalConnectionString"].ConnectionString);
SourceCoStr.TrustServerCertificate = LocalCoStr.TrustServerCertificate = true;
SourceCoStr.ApplicationName = LocalCoStr.ApplicationName = "eDosSync";
SourceCoStr.WorkstationID = LocalCoStr.WorkstationID = Environment.MachineName;
string reDos = string.Empty;
string reDosLocal = string.Empty;
step = "init";
try
{
using (var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey("SOFTWARE\\WOW6432Node\\Microsoft\\MSSQLServer\\Client\\ConnectTo"))
{
reDos = key.GetValue("eDos").ToString();
reDosLocal = key.GetValue("eDosLocal").ToString();
}
}
catch (System.Exception ex)
{
spLog?.WriteException(module,step,ex);
messages.AppendLine($"Error reading reg key");
}
spLog?.KvAdd(spl.skeys.sqlConnection, SourceCoStr.ConnectionString);
spLog?.WriteSplunkLogM( step, spl.iseverity.info);
messages.AppendLine($"Remote {SourceCoStr.DataSource} db {SourceCoStr.InitialCatalog} Logon= { SourceCoStr.UserID} alias:{ reDos }");
messages.AppendLine($"Local {LocalCoStr.DataSource} db {LocalCoStr.InitialCatalog} Logon= { LocalCoStr.UserID} alias:{ reDosLocal }");
oStream?.WriteLine($"Opening {LocalCoStr.ConnectionString}");
try
{
using (System.Data.SqlClient.SqlConnection eDosLocalCon = new SqlConnection(LocalCoStr.ConnectionString))
{
step = "Get Station";
eDosLocalCon.Open();
int? StationID = Bulker.SqlCommands.ExecProcScalar("Get Station ID", eDosLocalCon, "GetID_LocalStation", true, ref error) as int?;
if (!StationID.HasValue)
{
oStream?.WriteLine($"No stationID for this computer [{Environment.MachineName}]");
}
else
{
Result = new cResult(StationID, eDosLocalCon, spLog);
using (System.Data.SqlClient.SqlConnection eDosCon = new SqlConnection(SourceCoStr.ConnectionString))
{
eDosCon.InfoMessage += Connection_InfoMessage;
step = "DoorloopToDo";
DoorloopToDo(eDosCon, LocalCoStr.ConnectionString, iMessage, ref error, ref warning);
step = "DoorloopVisits";
DoorloopVisits(eDosLocalCon, eDosCon, Bulker.spLog, ref error);
}
Result.Write();
}
if (eDosLocalCon != null) UpdateRemoteReturns(eDosLocalCon);
}
}
catch (System.Exception ex)
{
oStream?.WriteLine($"Opening fail {ex.Message}");
error = true;
spLog.WriteException(module, step, ex);
}
if (error) goto final;
final:
messages.AppendLine($"Process:End,tm={System.DateTime.Now.ToString("yyyy-MM-ddTHH:mm")}, Errors={error}, Warnings={warning}");
//System.Diagnostics.Debug.WriteLine(messages.ToString());
oStream?.WriteLine(messages.ToString());
//var smtpFrom = System.Configuration.ConfigurationManager.AppSettings["smtpFrom"];
//var smtpServer = System.Configuration.ConfigurationManager.AppSettings["smtpServer"];
//int smtpPort = 25;
//if (int.TryParse(System.Configuration.ConfigurationManager.AppSettings["smtpPort"], out int newSMTPPort)) smtpPort = newSMTPPort; ;
//using (System.Net.Mail.MailMessage m = new System.Net.Mail.MailMessage())
//{
// m.From = new System.Net.Mail.MailAddress(smtpFrom);
// m.To.Add("lvandenb@sckcen.be");
// m.Subject = "SynceDosLocal " + (error ? "Error" : "No errors") + (warning ? " Warnings" : "");
// m.IsBodyHtml = true;
// m.Body = Bulker.htmlLog.ToString();
// using (var mc = new System.Net.Mail.SmtpClient(smtpServer, smtpPort)) { mc.Send(m); }
//}
spLog.CloseSplunkLog();
if (error) Environment.Exit(1);
else Environment.Exit(1);
}
static void DoorloopVisits(SqlConnection coLocal, SqlConnection coCentral, spl spLog, ref bool error)
{
const string module = "Doorloop Visits";
string step = "start";
oStream?.WriteLine(module);
//int VisitsNew = 0, VisitsAddedEntries = 0, VisitsAddedExits = 0, VisitsSkipped = 0;
spLog.WriteSplunkLog(module,step, spl.iseverity.info);
DataSet1 ds = new DataSet1();
DataSet1.CentralVisitsRow cr;
try
{
using (var localTA = new DataSet1TableAdapters.LocalVisitsTableAdapter())
using (var centralTA = new DataSet1TableAdapters.CentralVisitsTableAdapter())
{
localTA.Connection = coLocal;
centralTA.Connection = coCentral;
centralTA.ClearBeforeFill = false;
localTA.Fill(ds.LocalVisits);
spLog.KvAdd(spl.skeys.recordsAffected, ds.LocalVisits.Rows.Count);
foreach (DataSet1.LocalVisitsRow lr in ds.LocalVisits.Rows)
{
step = "CheckVisit";
Result.CheckVisitID(lr.ID_Visit); //min max
cr = ds.CentralVisits.FindByID_StationID_Visit(lr.ID_Station, lr.ID_Visit);
if (cr == null)
centralTA.Fill(ds.CentralVisits, lr.ID_Station, lr.ID_Visit);
cr = ds.CentralVisits.FindByID_StationID_Visit(lr.ID_Station, lr.ID_Visit);
if (cr == null)
{
Result.VisitsNew++;
copyrow(lr, ds.CentralVisits);
if ((lr.VisitStatus & 1) > 0) { lr.syncedEntry = true; Result.VisitsAddedEntries++; }
if ((lr.VisitStatus & 2) > 0) { lr.syncedExit = true; Result.VisitsAddedExits++; }
}
else switch (cr.VisitStatus)
{
case 3: lr.syncedEntry = lr.syncedExit = true; Result.VisitsSkipped++; break;
case 1: if ((lr.VisitStatus & 2) == 2) { copyExit(lr, cr); lr.syncedEntry = lr.syncedExit = true; Result.VisitsAddedExits++; } break;
case 2: if ((lr.VisitStatus & 1) == 1) { copyEntry(lr, cr); lr.syncedEntry = lr.syncedExit = true; Result.VisitsAddedEntries++; } break;
}
}
step = "Update";
localTA.Update(ds.LocalVisits);
centralTA.Update(ds.CentralVisits);
}
step = "done";
spLog.KvAdd(spl.skeys.recordsAffected, Result.VisitsNew);
spLog?.WriteSplunkLog(module,step, spl.iseverity.info);
spLog.KvClear();
}
catch (System.Exception ex)
{
error = true;
Result.ErrorMessage = ex.Message;
spLog.WriteException( module, step, ex);
}
ds.Dispose();
}
private static void copyEntry(DataSet1.LocalVisitsRow lr, DataSet1.CentralVisitsRow cr)
{
const string module = "copyEntry";
try
{
cr["ID_Station"] = lr["ID_Station"];
cr["ID_Visit"] = lr["ID_Visit"];
cr["Inst_CODE"] = lr["Inst_CODE"];
cr["PersID"] = lr["PersID"];
cr["ID_Task"] = lr["ID_Task"];
cr["EntryTime"] = lr["EntryTime"];
cr["ID_EPD"] = lr["ID_EPD"];
cr["isBG"] = lr["isBG"];
cr["ENTRY_EPD_CLOCK"] = lr["ENTRY_EPD_CLOCK"];
cr["epdType"] = lr["epdType"];
}
catch (System.Exception ex)
{
spLog?.WriteException(module, null, ex);
}
}
private static void copyExit(DataSet1.LocalVisitsRow lr, DataSet1.CentralVisitsRow cr)
{
#pragma warning disable CS0219 // The variable 'module' is assigned but its value is never used
const string module = "copyExit";
#pragma warning restore CS0219 // The variable 'module' is assigned but its value is never used
try
{
cr["ReturnTime"] = lr["ReturnTime"];
cr["Hp10Dose"] = lr["Hp10Dose"];
cr["Hp07Dose"] = lr["Hp07Dose"];
cr["Hp10Total"] = lr["Hp10Total"];
cr["Hp07Total"] = lr["Hp07Total"];
cr["Hp10Peak"] = lr["Hp10Peak"];
cr["Hp07Peak"] = lr["Hp07Peak"];
cr["Hp10Time"] = lr["Hp10Time"];
cr["Hp07Time"] = lr["Hp07Time"];
cr["QualityData"] = lr["QualityData"];
cr["K1"] = lr["K1"];
cr["K2"] = lr["K2"];
cr["K3"] = lr["K3"];
cr["K4"] = lr["K4"];
cr["K5"] = lr["K5"];
cr["K6"] = lr["K6"];
cr["SG"] = lr["SG"];
cr["BC"] = lr["BC"];
cr["FB"] = lr["FB"];
cr["HG"] = lr["HG"];
cr["alarmStatus"] = lr["alarmStatus"];
cr["otherAlarms"] = lr["otherAlarms"];
cr["errorStatus"] = lr["errorStatus"];
cr["operatingStatus"] = lr["operatingStatus"];
cr["isAlarm"] = lr["isAlarm"];
cr["isAlarmCleared"] = lr["isAlarmCleared"];
cr["ENTRY_EPD_CLOCK"] = lr["ENTRY_EPD_CLOCK"];
cr["EXIT_EPD_CLOCK"] = lr["EXIT_EPD_CLOCK"];
cr["TIME_LOST"] = lr["TIME_LOST"];
cr["eDosBatteryWarning"] = lr["eDosBatteryWarning"];
cr["eDosDose07Warning"] = lr["eDosDose07Warning"];
cr["eDosDose07Alarm"] = lr["eDosDose07Alarm"];
cr["eDosRate07Warning"] = lr["eDosRate07Warning"];
cr["eDosRate07Alarm"] = lr["eDosRate07Alarm"];
cr["eDosDose10Warning"] = lr["eDosDose10Warning"];
cr["eDosDose10Alarm"] = lr["eDosDose10Alarm"];
cr["eDosRate10Warning"] = lr["eDosRate10Warning"];
cr["eDosRate10Alarm"] = lr["eDosRate10Alarm"];
}
catch (System.Exception ex)
{
spLog?.WriteException(moduleName, null, ex);
}
}
private static DataSet1.CentralVisitsRow copyrow(DataSet1.LocalVisitsRow lr, DataSet1.CentralVisitsDataTable centralVisits)
{
DataSet1.CentralVisitsRow cr = centralVisits.NewCentralVisitsRow();
#pragma warning disable CS0219 // The variable 'module' is assigned but its value is never used
const string module = "copyExit";
#pragma warning restore CS0219 // The variable 'module' is assigned but its value is never used
try
{
foreach (DataColumn sc in lr.Table.Columns)
if (lr.Table.Columns.Contains(sc.ColumnName)) cr[sc.ColumnName] = lr[sc.ColumnName];
centralVisits.AddCentralVisitsRow(cr);
}
catch (System.Exception ex)
{
spLog?.WriteException(moduleName, null, ex);
}
return cr;
}
private static void Connection_InfoMessage(object sender, System.Data.SqlClient.SqlInfoMessageEventArgs e)
{
spLog?.Connection_InfoMessageLog(e, ref messages);
}
}
}