650 lines
30 KiB
C#
650 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Sarand.Net.Standard.Base.App;
|
|
using Sarand.Net.Standard.Base.Core;
|
|
using Sarand.Net.Standard.Base.Bus;
|
|
using Sarand.Net.Standard.Base.UpdateLog;
|
|
using Sarand.Net.Standard.Base.Dbas;
|
|
using Sarand.Net.Standard.Dbas.Base;
|
|
using Sarand.Net.Standard.Dbas.UpdateLog.Internal;
|
|
using System.Data.Common;
|
|
using Sarand.Net.Standard.Dbas.Data;
|
|
using Sarand.Net.Standard.Base.Utils;
|
|
|
|
namespace Sarand.Net.Standard.Dbas.UpdateLog
|
|
{
|
|
//=======================================================================
|
|
internal class SaUpdateLogMgr_Dbas : SaUpdateLogMgr
|
|
{
|
|
//-------------------------------------------------------------------
|
|
// Data members.
|
|
|
|
//-------------------------------------------------------------------
|
|
// Static initialisation.
|
|
static SaUpdateLogMgr_Dbas ()
|
|
{
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Construction.
|
|
internal SaUpdateLogMgr_Dbas (SaUpdateLogConsole_Dbas updateLogConsole) :
|
|
base(updateLogConsole)
|
|
{
|
|
Database = updateLogConsole.Database;
|
|
DbInfo = new DbDataItem.DatabaseInfo(updateLogConsole.Database);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Properties.
|
|
public String TableName_UpdateLog { get { return SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate); } }
|
|
internal ISacsDatabase Database { get; }
|
|
private DbDataItem.DatabaseInfo DbInfo { get; }
|
|
public override bool DatabaseIsValid { get { return (Database != null && Database.GetTableNames().Contains(TableName_UpdateLog)); } }
|
|
public override bool CanUpdateDatabase { get { return DatabaseIsValid; } }
|
|
|
|
//*******************************************************************
|
|
// U p d a t e L o g E n t r i e s
|
|
//*******************************************************************
|
|
// Utilities.
|
|
private String GetUpdateLogEntryFilter (SaUpdateLogEntry updateLogEntry)
|
|
{
|
|
return GetUpdateLogEntryFilter(updateLogEntry.ItemId, updateLogEntry.Attribute, updateLogEntry.Logged);
|
|
}
|
|
private String GetUpdateLogEntryFilter (ItemId itemId, String attribute, DateTime logged)
|
|
{
|
|
ClearErrorState();
|
|
if (!ItemId.IsValid(itemId)) return "1=0";
|
|
if (StringUtil.IsEmpty(attribute)) return "1=0";
|
|
// Update Log Entry identifying values.
|
|
SaUpdateLogEntry.Params prmLogEntry = new SaUpdateLogEntry.Params();
|
|
prmLogEntry.IncludedItemIds.Add(itemId);
|
|
prmLogEntry.IncludedAttributes.Add(attribute);
|
|
prmLogEntry.Logged = logged;
|
|
return GetLogEntryQueryFilter(prmLogEntry).Concat(" And ", "(", ")");
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update Log Entry exists.
|
|
public override bool LogEntryExists (SaUpdateLogEntry updateLogEntry)
|
|
{
|
|
return LogEntryExists(updateLogEntry.ItemId, updateLogEntry.Attribute, updateLogEntry.Logged);
|
|
}
|
|
public override bool LogEntryExists (ItemId itemId, String attribute, DateTime logged)
|
|
{
|
|
ClearErrorState();
|
|
if (!ItemId.IsValid(itemId)) return false;
|
|
if (StringUtil.IsEmpty(attribute)) return false;
|
|
return GetUpdateLogEntryCount(GetUpdateLogEntryFilter(itemId, attribute, logged)) == 1;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Get Log Entry.
|
|
private SaUpdateLogEntry GetUpdateLogEntry (String filter)
|
|
{
|
|
ClearErrorState();
|
|
if (GetUpdateLogEntryCount(filter) != 1) return null;
|
|
SaUpdateLogEntry logEntry = null;
|
|
// Query data.
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
|
|
dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, filter);
|
|
logEntry = CreateLogEntry(new ItemId(dbUpdateLog._ItemType, new SysId(dbUpdateLog._ItemId)), dbUpdateLog._Attribute);
|
|
PopulateFrom(dbUpdateLog, logEntry);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SaLogger.Warn(GetType().Name + ".GetUpdateLog\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
|
|
}
|
|
}
|
|
return logEntry;
|
|
}
|
|
public override SaUpdateLogEntry GetLogEntry (ItemId itemId, String attribute, DateTime logged)
|
|
{
|
|
ClearErrorState();
|
|
if (!ItemId.IsValid(itemId)) return null;
|
|
if (StringUtil.IsEmpty(attribute)) return null;
|
|
return GetUpdateLogEntry(GetUpdateLogEntryFilter(itemId, attribute, logged));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Create UpdateLog.
|
|
public override SaUpdateLogEntry CreateLogEntry (ItemId itemId, String attribute)
|
|
{
|
|
ClearErrorState();
|
|
return new SaUpdateLogEntry_Dbas(itemId, attribute, DateTime.Now, 0);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Validate UpdateLog.
|
|
public override bool IsValidLogEntryData (SaUpdateLogEntry.Data logEntryData, SaUpdateLogEntry.ErrField errField)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.IsValidLogEntryData(logEntryData, errField)) return false;
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Log updates.
|
|
public override bool LogUpdates (SaUpdateLogItemMonitor updateLogItemMonitor, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (updateLogItemMonitor == null) return SetErrorState("Invalid item update monitor");
|
|
if (updateLogItemMonitor.ItemType < 1) return SetErrorState("Invalid item type");
|
|
if (!SysId.IsValid(updateLogItemMonitor.ItemId)) return SetErrorState("Invalid item Id");
|
|
if (!DatabaseIsValid) return SetErrorState("Update Log is not supported");
|
|
if (!CanUpdateDatabase) return SetErrorState("Database cannot be updated");
|
|
|
|
// Force initialisation of SaDbQuery DBMS type.
|
|
DbQuery dbQry = new DbQuery(Database.DbmsType);
|
|
|
|
// Retrieve list of attribute updates to be recorded:
|
|
List<SaUpdateLogItemMonitor.AttrData> updatedAttributes = updateLogItemMonitor.AttrUpdates;
|
|
if (updatedAttributes.Count < 1) return true;
|
|
DateTime now = DateTime.Now;
|
|
DateTime logged = DateTime.Now;
|
|
|
|
// Build query details to insert new entries in update log:
|
|
List<String> updateLogQueries = new List<string>();
|
|
String qryPrefix = "INSERT INTO "+TableName_UpdateLog;
|
|
|
|
// Add the column names:
|
|
List<String> columnNames = new List<string>();
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Flags, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateHost, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateBy, false));
|
|
columnNames.Add(SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateHost, false));
|
|
qryPrefix += " (" + columnNames.Concat(",") + ")";
|
|
|
|
// Add the column values.
|
|
foreach (SaUpdateLogItemMonitor.AttrData attrData in updatedAttributes)
|
|
{
|
|
// Data values.
|
|
String dataBefore = attrData.ValueBefore.ToString();
|
|
String dataAfter = attrData.ValueAfter.ToString();
|
|
|
|
// Prepare list of column values:
|
|
List<String> columnValue = new List<string>();
|
|
columnValue.Add(updateLogItemMonitor.ItemType.ToString());
|
|
columnValue.Add(SysId.ToString(updateLogItemMonitor.ItemId));
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(DbQuery.FormatForCondition(attrData.Name)) + "'");
|
|
columnValue.Add(DbQuery.FormatDateTimeForCondition(logged, true, true));
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(dataBefore.Left((int)SaUpdateLogDbDfn.GetColTextLen(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore))) + "'");
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(dataAfter.Left((int)SaUpdateLogDbDfn.GetColTextLen(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter))) + "'");
|
|
columnValue.Add("''"); // Notes
|
|
columnValue.Add("0"); // Flags.
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(SacsSystem.GetStatusCode(SaStatus.Logged)) + "'");
|
|
// Create stamp.
|
|
columnValue.Add(DbQuery.FormatDateTimeForCondition(now, true, true));
|
|
columnValue.Add(SysId.ToString(dbUpdateInfo.UserId, "0"));
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(dbUpdateInfo.Host) + "'");
|
|
// Update stamp.
|
|
columnValue.Add(DbQuery.FormatDateTimeForCondition(now, true, true));
|
|
columnValue.Add(SysId.ToString(dbUpdateInfo.UserId, "0"));
|
|
columnValue.Add("'" + DbQuery.FormatForCondition(dbUpdateInfo.Host) + "'");
|
|
|
|
// Construct and add the query for this insert:
|
|
updateLogQueries.Add(qryPrefix + " VALUES(" + columnValue.Concat(",") + ")");
|
|
}
|
|
|
|
// Execute the query to insert update log entries.
|
|
if (!updateLogQueries.IsEmpty())
|
|
{
|
|
// Turn off display of database exceptions during update logging.
|
|
bool ddDisplayErrorsPrev = Database.DisplayErrors;
|
|
Database.DisplayErrors = false;
|
|
// MS Access only allows a single statement to be executed at a time.
|
|
bool executeStatementsSeparately = true;
|
|
if (executeStatementsSeparately)
|
|
{
|
|
foreach (String query in updateLogQueries)
|
|
{
|
|
SaLogger.Debug(GetType().Name + ".LogUpdates Query: " + query);
|
|
Database.ExecuteNonQuery(query);
|
|
if (Database.HasErrorState())
|
|
SetErrorState("Failed to insert update log entries - " + Database.ErrorStateMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
String query = updateLogQueries.Concat(";");
|
|
SaLogger.Debug(GetType().Name + ".LogUpdates Query: " + query);
|
|
Database.ExecuteNonQuery(query);
|
|
if (Database.HasErrorState())
|
|
SetErrorState("Failed to insert update log entries - " + Database.ErrorStateMessage);
|
|
}
|
|
Database.DisplayErrors = ddDisplayErrorsPrev;
|
|
}
|
|
return !HasErrorState();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Insert item.
|
|
public override bool InsertLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidLogEntry(logEntry)) return false;
|
|
//if (logEntry.Id.IsValid()) return SetErrorState(ErrorMessage.ValiditemId);
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
|
|
PopulateTo(dbUpdateLog, logEntry, dbUpdateInfo);
|
|
if (SaAttrUpdate_Db.FieldsNonId.Contains("Id"))
|
|
{
|
|
// Update Log has no Id.
|
|
//dbUpdateLog._Id = SysId.ToInt(Database.GetNextId("SaAttrUpdate", dbUpdateInfo));
|
|
}
|
|
dbUpdateLog.ExecuteInsertCommand(dbCommand);
|
|
//logEntry.Id = new SysId(dbUpdateLog._Id);
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return !HasErrorState();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update item.
|
|
public override bool UpdateLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidLogEntry(logEntry)) return false;
|
|
//if (!logEntry.Id.IsValid()) return SetErrorState(ErrorMessage.InvalidItemId);
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve item.
|
|
dbConnection.Open();
|
|
SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
|
|
dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, GetUpdateLogEntryFilter(logEntry));
|
|
// Update item.
|
|
PopulateTo(dbUpdateLog, logEntry, dbUpdateInfo);
|
|
dbUpdateLog.ExecuteUpdateCommand(dbCommand);
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return !HasErrorState();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Delete item.
|
|
public override bool LogEntryCanBeDeleted (SaUpdateLogEntry logEntry)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.LogEntryCanBeDeleted(logEntry)) return false;
|
|
return true;
|
|
}
|
|
public override bool DeleteLogEntry (SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!LogEntryCanBeDeleted(logEntry)) return false;
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve item.
|
|
dbConnection.Open();
|
|
SaAttrUpdate_Db dbUpdateLog = new SaAttrUpdate_Db(DbInfo);
|
|
dbUpdateLog.PopulateFrom(dbCommand, aliasUpdateLog, GetUpdateLogEntryFilter(logEntry));
|
|
// Delete item.
|
|
dbCommand.CommandType = System.Data.CommandType.Text;
|
|
dbCommand.CommandText = "DELETE FROM " + SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate) + " WHERE " + GetUpdateLogEntryFilter(logEntry) + ";";
|
|
dbCommand.ExecuteNonQuery();
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return !HasErrorState();
|
|
}
|
|
public override bool ClearLogEntriesForItem (ItemId itemId, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!ItemId.IsValid(itemId)) return SetErrorState("Item Id must be specified");
|
|
String colItemType = SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType);
|
|
String colItemId = SaUpdateLogDbDfn.GetColumnName(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId);
|
|
String query = "Delete From "+TableName_UpdateLog+" WHERE "+colItemType+"="+itemId.Type.ToString()+" AND "+colItemId+"="+SysId.ToString(itemId.Id);
|
|
Database.ExecuteNonQuery(query);
|
|
if (Database.HasErrorState())
|
|
SetErrorState("Failed to clear update log entries - " + Database.ErrorStateMessage);
|
|
return !HasErrorState();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Copy data properties to and from database.
|
|
private void PopulateTo (SaAttrUpdate_Db dbUpdateLog, SaUpdateLogEntry logEntry, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
dbUpdateLog._ItemType = logEntry.ItemId.Type;
|
|
dbUpdateLog._ItemId = SysId.ToInt(logEntry.ItemId.Id);
|
|
dbUpdateLog._Attribute = logEntry.Attribute;
|
|
dbUpdateLog._Logged = logEntry.Logged;
|
|
dbUpdateLog._DataBefore = logEntry.DataBefore;
|
|
dbUpdateLog._DataAfter = logEntry.DataAfter;
|
|
// Common properties.
|
|
dbUpdateLog._Notes = logEntry.Notes;
|
|
dbUpdateLog._Status = SacsSystem.GetStatusCode(logEntry.Status);
|
|
dbUpdateLog._Flags = (short)logEntry.Flags;
|
|
if (!SysId.IsValid(logEntry.Id))
|
|
{
|
|
dbUpdateLog._CreateOn = DateTime.Now;
|
|
dbUpdateLog._CreateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbUpdateLog._CreateHost = dbUpdateInfo.Host;
|
|
}
|
|
dbUpdateLog._UpdateOn = DateTime.Now;
|
|
dbUpdateLog._UpdateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbUpdateLog._UpdateHost = dbUpdateInfo.Host;
|
|
}
|
|
private void PopulateFrom (SaAttrUpdate_Db dbUpdateLog, SaUpdateLogEntry logEntry)
|
|
{
|
|
//logEntry.ItemId = new ItemId(dbUpdateLog._ItemType, new SysId(dbUpdateLog._ItemId);
|
|
//logEntry.Attribute = dbUpdateLog._Attribute;
|
|
//logEntry.Logged = dbUpdateLog._Logged;
|
|
logEntry.DataBefore = dbUpdateLog._DataBefore;
|
|
logEntry.DataAfter = dbUpdateLog._DataAfter;
|
|
// Common properties.
|
|
logEntry.Notes = dbUpdateLog._Notes;
|
|
logEntry.Status = SacsSystem.GetStatusForCode(dbUpdateLog._Status);
|
|
logEntry.SetCreateStamp(dbUpdateLog._CreateOn, new SysId(dbUpdateLog._CreateBy), dbUpdateLog._CreateHost);
|
|
logEntry.SetUpdateStamp(dbUpdateLog._UpdateOn, new SysId(dbUpdateLog._UpdateBy), dbUpdateLog._UpdateHost);
|
|
logEntry.AcceptChanges();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// UpdateLog column definitions.
|
|
private static readonly String aliasUpdateLog = "aUpdLog";
|
|
private void SetUpdateLogColDfn
|
|
(ColumnDfn col, String caption, int width, SaUpdateLogDbDfn.ColumnIdx dbCol,
|
|
ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
|
|
String alias = "", String prefix = "")
|
|
{
|
|
if (String.IsNullOrEmpty(alias) && SaUpdateLogDbDfn.GetTableForColumn(dbCol) == SaUpdateLogDbDfn.TableIdx.SaAttrUpdate)
|
|
alias = aliasUpdateLog;
|
|
col.Set(caption, width, (int)dbCol, prefix + SaUpdateLogDbDfn.GetColumnName(dbCol, false), SaUpdateLogDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
|
|
}
|
|
public override ColumnDfn GetLogEntryColumnDfn (SaUpdateLogEntry.Column columnId, string caption = "", int width = 0)
|
|
{
|
|
ColumnDfn columnDfn = new ColumnDfn((int)columnId,caption,width);
|
|
switch (columnId)
|
|
{
|
|
case SaUpdateLogEntry.Column.Pos:
|
|
SetUpdateLogColDfn(columnDfn, "Pos", 45, SaUpdateLogDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
|
|
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
|
|
columnDfn.ReadOnly = true;
|
|
columnDfn.Resizable = false;
|
|
break;
|
|
case SaUpdateLogEntry.Column.ItemType:
|
|
SetUpdateLogColDfn(columnDfn, "Item type", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.ItemType_Desc:
|
|
SetUpdateLogColDfn(columnDfn, "Item type", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Attribute:
|
|
SetUpdateLogColDfn(columnDfn, "Attribute", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Logged:
|
|
SetUpdateLogColDfn(columnDfn, "Logged", 110, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.DateTime);
|
|
columnDfn.TimeFormat = "HH:mm:ss";
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Logged_Date:
|
|
SetUpdateLogColDfn(columnDfn, "Logged", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Logged_Time:
|
|
SetUpdateLogColDfn(columnDfn, "Logged", 100, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, ColumnAlignment.Center, DataValue.DataType.Time);
|
|
columnDfn.TimeFormat = "HH:mm:ss";
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.DataBefore:
|
|
SetUpdateLogColDfn(columnDfn, "Value before", 120, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.DataAfter:
|
|
SetUpdateLogColDfn(columnDfn, "Value after", 120, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Notes:
|
|
SetUpdateLogColDfn(columnDfn, "Notes", 240, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes);
|
|
break;
|
|
case SaUpdateLogEntry.Column.Status:
|
|
SetUpdateLogColDfn(columnDfn, "Status", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Status_Desc:
|
|
SetUpdateLogColDfn(columnDfn, "Status", 90, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Status_Ind:
|
|
SetUpdateLogColDfn(columnDfn, "Status", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
|
|
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.CreateOn_Date:
|
|
SetUpdateLogColDfn(columnDfn, "Created", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.CreateBy:
|
|
SetUpdateLogColDfn(columnDfn, "Modified by", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, ColumnAlignment.Center, DataValue.DataType.Long);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.CreateBy_Name:
|
|
SetUpdateLogColDfn(columnDfn, "Modified by", 120, SaUpdateLogDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.String);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.UpdateOn_Date:
|
|
SetUpdateLogColDfn(columnDfn, "Updated", 80, SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SaUpdateLogEntry.Column.Hidden:
|
|
SetUpdateLogColDfn(columnDfn, "", 0, SaUpdateLogDbDfn.ColumnIdx.Unknown);
|
|
columnDfn.Hidden = true;
|
|
break;
|
|
}
|
|
if (!String.IsNullOrEmpty(caption))
|
|
columnDfn.Caption = caption;
|
|
if (width > 0)
|
|
columnDfn.Width = width;
|
|
return columnDfn;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// UpdateLog query filter.
|
|
public override List<string> GetLogEntryQueryFilter (SaUpdateLogEntry.Params prm)
|
|
{
|
|
List<String> filter = new List<String>();
|
|
|
|
// Item Ids.
|
|
List<String> filterItemId = new List<String>();
|
|
String colItemType = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, aliasUpdateLog);
|
|
String colItemId = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, aliasUpdateLog);
|
|
foreach (ItemId itemId in prm.IncludedItemIds)
|
|
{
|
|
filterItemId.Add(colItemType + "=" + itemId.Type.ToString() + " And " + colItemId + "=" + SysId.ToString(itemId.Id));
|
|
}
|
|
if (filterItemId.Count > 0)
|
|
filter.Add(filterItemId.Concat(" Or ", "(", ")"));
|
|
|
|
// Attributes.
|
|
String colAttribute = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, aliasUpdateLog);
|
|
if (prm.IncludedAttributes.Count > 0)
|
|
filter.Add(colAttribute + " IN (" + DbQuery.FormatForIn(prm.IncludedAttributes, true, true) + ")");
|
|
|
|
// Logged at.
|
|
String colLogged = SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog);
|
|
if (DateUtil.IsValid(prm.Logged))
|
|
filter.Add(colLogged + "=" + DbQuery.FormatDateTimeForCondition(prm.LoggedFrom, true, true));
|
|
else
|
|
{
|
|
if (DateUtil.IsValid(prm.LoggedFrom))
|
|
filter.Add(colLogged + ">=" + DbQuery.FormatDateTimeForCondition(prm.LoggedFrom, true, true));
|
|
if (DateUtil.IsValid(prm.LoggedTo))
|
|
filter.Add(colLogged + "<=" + DbQuery.FormatDateTimeForCondition(prm.LoggedTo, true, true));
|
|
}
|
|
|
|
if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
|
|
return filter;
|
|
}
|
|
// UpdateLog sort columns.
|
|
public List<String> GetUpdateLogSortColumns (SaUpdateLogEntry.Params prm)
|
|
{
|
|
// Sort sequence:
|
|
List<String> sortColumnNames = new List<String>();
|
|
foreach (var columnDfn in prm.SortColumns)
|
|
{
|
|
// Need to ensure correct alias used for UpdateLog columns in case of conflict.
|
|
String sortCol = String.Empty;
|
|
if (SaUpdateLogDbDfn.GetTableForColumn((SaUpdateLogDbDfn.ColumnIdx)columnDfn.DbColumn) == SaUpdateLogDbDfn.TableIdx.SaAttrUpdate)
|
|
{
|
|
sortCol = SaUpdateLogDbDfn.GetColumnNameQual((SaUpdateLogDbDfn.ColumnIdx)columnDfn.DbColumn, aliasUpdateLog);
|
|
}
|
|
else
|
|
{
|
|
sortCol = columnDfn.DataName;
|
|
if (!StringUtil.IsEmpty(columnDfn.SortDataName))
|
|
{
|
|
sortCol = columnDfn.SortDataName;
|
|
}
|
|
}
|
|
if (!sortCol.IsEmpty())
|
|
{
|
|
DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
|
|
sortColumnNames.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
|
|
}
|
|
}
|
|
sortColumnNames.RemoveBlanks();
|
|
if (sortColumnNames.IsEmpty())
|
|
{
|
|
// Default sort columns:
|
|
sortColumnNames.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog) + " DESC");
|
|
}
|
|
return sortColumnNames;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// UpdateLog count.
|
|
private long GetUpdateLogEntryCount (String filter)
|
|
{
|
|
ClearErrorState();
|
|
return Database.GetRowCount(SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate) + " As " + aliasUpdateLog, filter);
|
|
}
|
|
public override long GetLogEntryCount (SaUpdateLogEntry.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
return GetUpdateLogEntryCount(GetLogEntryQueryFilter(prm).Concat(" AND ", "(", ")"));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update Log Entry list.
|
|
public override List<SaUpdateLogEntry> GetLogEntryList (SaUpdateLogEntry.Params prm)
|
|
{
|
|
List<SaUpdateLogEntry> logEntries = new List<SaUpdateLogEntry>();
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_UpdateLog, aliasUpdateLog);
|
|
SaAttrUpdate_Db dbLogEntry = new SaAttrUpdate_Db(DbInfo);
|
|
qry.Columns.AddRange(dbLogEntry.ExistingColumnNames);
|
|
qry.Filters.AddRange(GetLogEntryQueryFilter(prm));
|
|
qry.OrderBy.AddRange(GetUpdateLogSortColumns(prm));
|
|
// Query data.
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
|
|
using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
|
|
{
|
|
while (dbDataReader.Read())
|
|
{
|
|
dbLogEntry = new SaAttrUpdate_Db(DbInfo);
|
|
dbLogEntry.PopulateFrom(dbDataReader);
|
|
SaUpdateLogEntry logEntry = CreateLogEntry(new ItemId(dbLogEntry._ItemType,new SysId(dbLogEntry._ItemId)),dbLogEntry._Attribute);
|
|
PopulateFrom(dbLogEntry, logEntry);
|
|
logEntries.Add(logEntry);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SaLogger.Warn(GetType().Name + ".GetLogEntryList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
|
|
}
|
|
}
|
|
return logEntries;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update Log Entry query.
|
|
public override DbResultSet ExecuteLogEntryQuery (List<ColumnDfn> columns, SaUpdateLogEntry.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
|
|
//---------------------------------------------------------------------
|
|
// Construct query.
|
|
DbQuery query = new DbQuery(Database.DbmsType);
|
|
query.Tables.Add(SaUpdateLogDbDfn.GetTableName(SaUpdateLogDbDfn.TableIdx.SaAttrUpdate), aliasUpdateLog);
|
|
|
|
// Add columns as defined in query list.
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.ItemType) || columns.HasId((int)SaUpdateLogEntry.Column.ItemType_Desc))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemType, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.ItemId))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_ItemId, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.Attribute) || columns.HasId((int)SaUpdateLogEntry.Column.DataBefore) || columns.HasId((int)SaUpdateLogEntry.Column.DataAfter))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Attribute, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.Logged) || columns.HasId((int)SaUpdateLogEntry.Column.Logged_Date) || columns.HasId((int)SaUpdateLogEntry.Column.Logged_Time))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Logged, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.DataBefore))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataBefore, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.DataAfter))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_DataAfter, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.Notes))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Notes, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.Status) || columns.HasId((int)SaUpdateLogEntry.Column.Status_Desc) || columns.HasId((int)SaUpdateLogEntry.Column.Status_Ind))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_Status, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.CreateOn_Date))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateOn, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.CreateBy) || columns.HasId((int)SaUpdateLogEntry.Column.CreateBy_Name))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_CreateBy, aliasUpdateLog));
|
|
if (columns.HasId((int)SaUpdateLogEntry.Column.UpdateOn_Date))
|
|
query.Columns.Add(SaUpdateLogDbDfn.GetColumnNameQual(SaUpdateLogDbDfn.ColumnIdx.SaAttrUpdate_UpdateOn, aliasUpdateLog));
|
|
|
|
//---------------------------------------------------------------------
|
|
// Populate filter.
|
|
query.Filters.AddRange(GetLogEntryQueryFilter(prm));
|
|
|
|
// Configure sort sequence.
|
|
foreach (String sortColumn in GetUpdateLogSortColumns(prm))
|
|
query.OrderBy.Add(sortColumn);
|
|
|
|
//---------------------------------------------------------------------
|
|
//return new DbResultSet_DataTableReader(Database, query.BuildQuery(prm.ResultsPaging));
|
|
return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
}
|
|
//=======================================================================
|
|
}
|