Sarand/Common-VS2019
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
0491c9f4b060f64a8438c76a94952085495c7e8f
Common-VS2019/SacsStandardDbas/Dbas/Interfaces/SaInterfaceMgr_Dbas-Interfaces.cs
T

600 lines
27 KiB
C#
Raw Blame History

using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.Interfaces;
using Sarand.Net.Standard.Base.Utils;
using Sarand.Net.Standard.Dbas.Data;
using Sarand.Net.Standard.Dbas.Interfaces.Internal;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text.RegularExpressions;
namespace Sarand.Net.Standard.Dbas.Interfaces
{
//=======================================================================
public partial class SaInterfaceMgr_Dbas
{
//*******************************************************************
// I n t e r f a c e s
//*******************************************************************
// Associated data.
public override bool InterfaceHasProcesses(SysId id)
{
ClearErrorState();
String filter = SaInterfaceDbDfn.GetColumnName(SaInterfaceDbDfn.ColumnIdx.SaInterfaceProcess_InterfaceId) + "=" + SysId.ToString(id);
return (Database.GetRowCount(TableName_InterfaceProcess, filter) > 0);
}
public override bool InterfaceHasDataItems(SysId id)
{
ClearErrorState();
String filter = SaInterfaceDbDfn.GetColumnName(SaInterfaceDbDfn.ColumnIdx.SaInterfaceDataItem_InterfaceId) + "=" + SysId.ToString(id);
return (Database.GetRowCount(TableName_InterfaceDataItem, filter) > 0);
}
// Process sequence.
public override int GetMaxProcessSequenceForInterface(SysId interfaceId, SaInterfaceProcessDirection processDirection)
{
ClearErrorState();
if (!SysId.IsValid(interfaceId)) return 0;
List<String> filter = new List<string>();
filter.Add(SaInterfaceDbDfn.GetColumnName(SaInterfaceDbDfn.ColumnIdx.SaInterfaceProcess_InterfaceId) + "=" + SysId.ToString(interfaceId));
filter.Add(SaInterfaceDbDfn.GetColumnName(SaInterfaceDbDfn.ColumnIdx.SaInterfaceProcess_Direction) + "=" + ((int)processDirection).ToString());
DataValue maxSequence = Database.GetRowValue(TableName_InterfaceProcess, "Max(" + SaInterfaceDbDfn.GetColumnName(SaInterfaceDbDfn.ColumnIdx.SaInterfaceProcess_ProcSeq, false) + ")", filter.Concat(" AND ", "(", ")"));
return (maxSequence.IsValid() ? (int)maxSequence.AsLong() : 0);
}
//-------------------------------------------------------------------
// Create Item.
public override SaInterface CreateInterface(String context, SaInterfaceCategory category, short type)
{
ClearErrorState();
return new SaInterface_Dbas(null, context, category, type, 0);
}
private SaInterface CreateInterface(SaInterface_Db dbInterface)
{
ClearErrorState();
SaInterface saInterface = new SaInterface_Dbas(new SysId(dbInterface._Id), dbInterface._Context, (SaInterfaceCategory)dbInterface._Category, dbInterface._Type ?? 0, (ushort)dbInterface._Flags);
PopulateFrom(dbInterface, saInterface);
return saInterface;
}
private SaInterface CreateInterface(DbDataReader dataReader)
{
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
dbInterface.PopulateFrom(dataReader);
return CreateInterface(dbInterface);
}
//-------------------------------------------------------------------
// Item exists.
public override bool InterfaceExistsById(SysId id)
{
ClearErrorState();
if (!SysId.IsValid(id)) return false;
return GetInterfaceCount(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, aliasInterface) + "=" + SysId.ToString(id)) == 1;
}
public override bool InterfaceExistsByCode(String code)
{
ClearErrorState();
if (StringUtil.IsEmpty(code)) return false;
return GetInterfaceCount(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Code, aliasInterface) + "='" + DbQuery.FormatForCondition(code) + "'") == 1;
}
//-------------------------------------------------------------------
// Get Item.
public override SaInterface GetInterface(SaInterface.Params prm)
{
return GetInterface(GetInterfaceQueryFilter(prm).Concat(" AND ", "(", ")"));
}
private SaInterface GetInterface(String filter)
{
ClearErrorState();
if (GetInterfaceCount(filter) != 1) return null;
SaInterface interfaceObj = null;
// Query data.
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
dbInterface.PopulateFrom(dbCommand, aliasInterface, filter);
interfaceObj = CreateInterface(dbInterface);
}
catch (Exception exc)
{
SetErrorState(ErrorMessage.DatabaseQueryException);
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return interfaceObj;
}
public override SaInterface GetInterfaceById(SysId id)
{
ClearErrorState();
if (!SysId.IsValid(id)) return null;
return GetInterface("Id=" + SysId.ToString(id));
}
public override SaInterface GetInterfaceByContextCode(String context, String code)
{
ClearErrorState();
if (StringUtil.IsEmpty(code)) return null;
return GetInterface("Context='" + DbQuery.FormatForCondition(context) + "' And Code='" + DbQuery.FormatForCondition(code) + "'");
}
//-------------------------------------------------------------------
// Validate Item properties.
public override bool IsValidInterfaceData(SaInterface.Data interfaceData, SaInterface.ErrField errField)
{
ClearErrorState();
if (!base.IsValidInterfaceData(interfaceData, errField)) return false;
return true;
}
//-------------------------------------------------------------------
// Insert Item.
public override bool InsertInterface(SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidInterface(interfaceObj)) return false;
if (SysId.IsValid(interfaceObj.Id)) return SetErrorState(ErrorMessage.ValidItemId);
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
PopulateTo(dbInterface, interfaceObj, dbUpdateInfo);
if (SaInterface_Db.FieldsNonId.Contains("Id"))
{
// Generate next Id.
dbInterface._Id = SysId.ToInt(Database.GetNextId(dbInterface.TableName, dbUpdateInfo));
}
dbInterface.ExecuteInsertCommand(dbCommand);
interfaceObj.Id = new SysId(dbInterface._Id);
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Update Item.
public override bool UpdateInterface(SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidInterface(interfaceObj)) return false;
if (!SysId.IsValid(interfaceObj.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
dbInterface.PopulateFrom(dbCommand, aliasInterface, "Id=" + SysId.ToString(interfaceObj.Id));
// Update item.
PopulateTo(dbInterface, interfaceObj, dbUpdateInfo);
dbInterface.ExecuteUpdateCommand(dbCommand);
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Delete Item.
public override bool InterfaceCanBeDeleted(SaInterface interfaceObj)
{
ClearErrorState();
if (!base.InterfaceCanBeDeleted(interfaceObj)) return false;
return true;
}
public override bool DeleteInterface(SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!InterfaceCanBeDeleted(interfaceObj)) return false;
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
dbInterface.PopulateFrom(dbCommand, aliasInterface, "Id=" + SysId.ToString(interfaceObj.Id));
// Delete item.
dbCommand.CommandType = System.Data.CommandType.Text;
dbCommand.CommandText = "DELETE FROM " + TableName_Interface + " WHERE Id=" + SysId.ToString(interfaceObj.Id) + ";";
dbCommand.ExecuteNonQuery();
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Copy data properties to and from database.
private void PopulateTo(SaInterface_Db dbInterface, SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
{
dbInterface._Id = interfaceObj.Id.ToInt();
dbInterface._Context = interfaceObj.Context;
dbInterface._Category = (short)interfaceObj.Category;
dbInterface._Type = interfaceObj.Type;
dbInterface._Code = interfaceObj.Code;
dbInterface._Caption = interfaceObj.Caption;
// Common properties.
dbInterface._Notes = interfaceObj.Notes;
dbInterface._Status = SacsSystem.GetStatusCode(interfaceObj.Status);
dbInterface._Flags = (short)interfaceObj.Flags;
if (!SysId.IsValid(interfaceObj.Id))
{
dbInterface._CreateOn = DateTime.Now;
dbInterface._CreateBy = dbUpdateInfo.UserId.ToInt();
dbInterface._CreateHost = dbUpdateInfo.Host;
}
dbInterface._UpdateOn = DateTime.Now;
dbInterface._UpdateBy = dbUpdateInfo.UserId.ToInt();
dbInterface._UpdateHost = dbUpdateInfo.Host;
}
private void PopulateFrom(SaInterface_Db dbInterface, SaInterface interfaceObj)
{
//interface.Id = new SysId(dbInterface._Id);
//interfaceObj.Context = dbInterface._Context;
//interfaceObj.Category = (SaInterfaceCategory)dbInterface._Category;
//interfaceObj.Type = dbInterface._Type;
interfaceObj.Code = dbInterface._Code;
interfaceObj.Caption = dbInterface._Caption;
// Common properties.
interfaceObj.Notes = dbInterface._Notes;
interfaceObj.Status = SacsSystem.GetStatusForCode(dbInterface._Status);
interfaceObj.SetCreateStamp(dbInterface._CreateOn, new SysId(dbInterface._CreateBy), dbInterface._CreateHost);
interfaceObj.SetUpdateStamp(dbInterface._UpdateOn, new SysId(dbInterface._UpdateBy), dbInterface._UpdateHost);
interfaceObj.AcceptChanges();
}
//-------------------------------------------------------------------
// Column definitions.
private static readonly String aliasInterface = "aInt";
private static readonly String colInterface_ProcessCount = "IntProcessCount";
private static readonly String colInterface_DataItemCount = "IntDataItemCount";
private void SetInterfaceColDfn
(ColumnDfn col, String caption, int width, SaInterfaceDbDfn.ColumnIdx dbCol,
ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
String alias = "", String prefix = "")
{
if (String.IsNullOrEmpty(alias) && SaInterfaceDbDfn.GetTableForColumn(dbCol) == SaInterfaceDbDfn.TableIdx.SaInterface)
alias = aliasInterface;
col.Set(caption, width, (int)dbCol, prefix + SaInterfaceDbDfn.GetColumnName(dbCol, false), SaInterfaceDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
}
public override ColumnDfn GetInterfaceColumnDfn(SaInterface.Column columnId, string caption = "", int width = 0)
{
ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
switch (columnId)
{
case SaInterface.Column.Pos:
SetInterfaceColDfn(columnDfn, "Pos", 45, SaInterfaceDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
columnDfn.ReadOnly = true;
columnDfn.Resizable = false;
break;
// Interface properties.
case SaInterface.Column.Id:
SetInterfaceColDfn(columnDfn, "Id", 60, SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, ColumnAlignment.Right, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
case SaInterface.Column.Context:
SetInterfaceColDfn(columnDfn, "Context", 90, SaInterfaceDbDfn.ColumnIdx.SaInterface_Context);
break;
case SaInterface.Column.Category:
SetInterfaceColDfn(columnDfn, "Category", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Category, ColumnAlignment.Center, DataValue.DataType.Long);
break;
case SaInterface.Column.Category_Desc:
SetInterfaceColDfn(columnDfn, "Category", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Category, ColumnAlignment.Center);
break;
case SaInterface.Column.Type:
SetInterfaceColDfn(columnDfn, "Type", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Type, ColumnAlignment.Center, DataValue.DataType.Long);
break;
case SaInterface.Column.Type_Desc:
SetInterfaceColDfn(columnDfn, "Type", 100, SaInterfaceDbDfn.ColumnIdx.SaInterface_Type, ColumnAlignment.Center);
break;
case SaInterface.Column.Code:
SetInterfaceColDfn(columnDfn, "Code", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Code);
break;
case SaInterface.Column.Caption:
SetInterfaceColDfn(columnDfn, "Caption", 120, SaInterfaceDbDfn.ColumnIdx.SaInterface_Caption);
break;
case SaInterface.Column.Active_Y:
SetInterfaceColDfn(columnDfn, "Active", 60, SaInterfaceDbDfn.ColumnIdx.SaInterface_Flags, ColumnAlignment.Center);
break;
case SaInterface.Column.Active_TickCross:
SetInterfaceColDfn(columnDfn, "Active", 60, SaInterfaceDbDfn.ColumnIdx.SaInterface_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
columnDfn.BoolFormat = ColumnBoolFormat.Tick;
break;
case SaInterface.Column.Active_Ind:
SetInterfaceColDfn(columnDfn, "Active", 60, SaInterfaceDbDfn.ColumnIdx.SaInterface_Flags, ColumnAlignment.Center, DataValue.DataType.TriState);
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
break;
// Derived properties.
case SaInterface.Column.Process_Count:
SetInterfaceColDfn(columnDfn, "Processes", 70, SaInterfaceDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
columnDfn.DataName = colInterface_ProcessCount;
break;
case SaInterface.Column.DataItem_Count:
SetInterfaceColDfn(columnDfn, "Data items", 70, SaInterfaceDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
columnDfn.DataName = colInterface_DataItemCount;
break;
// Common properties.
case SaInterface.Column.Notes:
SetInterfaceColDfn(columnDfn, "Notes", 200, SaInterfaceDbDfn.ColumnIdx.SaInterface_Notes);
break;
case SaInterface.Column.Status:
SetInterfaceColDfn(columnDfn, "Status", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Status, ColumnAlignment.Center);
break;
case SaInterface.Column.Status_Desc:
SetInterfaceColDfn(columnDfn, "Status", 90, SaInterfaceDbDfn.ColumnIdx.SaInterface_Status, ColumnAlignment.Center);
break;
case SaInterface.Column.Status_Ind:
SetInterfaceColDfn(columnDfn, "Status", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
break;
case SaInterface.Column.CreateOn_Date:
SetInterfaceColDfn(columnDfn, "Created", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
columnDfn.ReadOnly = true;
break;
case SaInterface.Column.UpdateOn_Date:
SetInterfaceColDfn(columnDfn, "Updated", 80, SaInterfaceDbDfn.ColumnIdx.SaInterface_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
columnDfn.ReadOnly = true;
break;
}
if (!String.IsNullOrEmpty(caption))
columnDfn.Caption = caption;
if (width > 0)
columnDfn.Width = width;
return columnDfn;
}
//-------------------------------------------------------------------
// Query filter.
public override List<string> GetInterfaceQueryFilter(SaInterface.Params prm)
{
List<String> filter = new List<String>();
// Interface Id.
String colId = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, aliasInterface);
String includedIds = prm.IdsIncluded.Concat(",");
if (!includedIds.IsEmpty())
filter.Add(colId + " IN (" + includedIds + ")");
String excludedIds = prm.IdsExcluded.Concat(",");
if (!excludedIds.IsEmpty())
filter.Add(colId + " NOT IN (" + excludedIds + ")");
String colContext = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Context, aliasInterface);
String colCode = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Code, aliasInterface);
String colCaption = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Caption, aliasInterface);
String colNotes = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Notes, aliasInterface);
// Generic search.
if (!StringUtil.IsBlank(prm.Search))
{
foreach (String search in Regex.Split(prm.Search, "[\\s,;\\-+]+"))
{
if (StringUtil.IsBlank(search)) continue;
String searchForLike = DbQuery.FormatForLike(search, true);
List<String> searchFilter = new List<string>();
searchFilter.Add($"{colContext} LIKE '%{searchForLike}%'");
searchFilter.Add($"{colCode} LIKE '%{searchForLike}%'");
searchFilter.Add($"{colCaption} LIKE '%{searchForLike}%'");
searchFilter.Add($"{colNotes} LIKE '%{searchForLike}%'");
filter.Add(searchFilter.Concat(" OR ", "(", ")"));
}
}
// Context.
if (!StringUtil.IsEmpty(prm.Context))
filter.Add(colContext + "='" + DbQuery.FormatForCondition(prm.Context) + "'");
// Category.
String colCategory = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Category, aliasInterface);
if ((int)prm.InterfaceCategory > 0)
filter.Add(colCategory + "=" + ((int)prm.InterfaceCategory).ToString());
// Type.
String colType = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Type, aliasInterface);
if (prm.InterfaceTypesIncluded.Count > 0)
filter.Add(colType + " In (" + String.Join(",", prm.InterfaceTypesIncluded) + ")");
// Code.
if (!StringUtil.IsEmpty(prm.Code))
filter.Add(colCode + "='" + DbQuery.FormatForCondition(prm.Code) + "'");
// Caption.
if (!StringUtil.IsEmpty(prm.CaptionPartial))
filter.Add(colCaption + " Like '%" + DbQuery.FormatForLike(prm.CaptionPartial) + "%'");
// Interface text - code or caption.
if (!StringUtil.IsEmpty(prm.InterfaceText))
filter.Add(colCode + " Like '%" + DbQuery.FormatForLike(prm.InterfaceText) + "%' Or " + colCaption + " Like '%" + DbQuery.FormatForLike(prm.InterfaceText) + "%'");
// Active flag.
String colFlags = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Flags, aliasInterface);
if (prm.ActiveOnly)
filter.Add(DbQuery.BuildBitMappedFilter(colFlags, SaInterface.Flag_Active, true));
// Status.
String colStatus = SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Status, aliasInterface);
if (prm.StatusCat == SaInterface.StatusCat.ActiveOnly)
filter.Add(colStatus + " In ('" + SacsSystem.GetStatusCode(SaStatus.Active) + "')");
if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
return filter;
}
// Sort columns.
public List<String> GetInterfaceSortColumns(SaInterface.Params prm)
{
// Sort sequence:
List<String> sortColumnNames = new List<String>();
foreach (var columnDfn in prm.SortColumns)
{
// Need to ensure correct alias used for Interface columns in case of conflict.
String sortCol = String.Empty;
if (SaInterfaceDbDfn.GetTableForColumn((SaInterfaceDbDfn.ColumnIdx)columnDfn.DbColumn) == SaInterfaceDbDfn.TableIdx.SaInterface)
{
sortCol = SaInterfaceDbDfn.GetColumnNameQual((SaInterfaceDbDfn.ColumnIdx)columnDfn.DbColumn, aliasInterface);
}
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(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Category, aliasInterface) + " ASC");
sortColumnNames.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Code, aliasInterface) + " ASC");
}
return sortColumnNames;
}
//-------------------------------------------------------------------
// Item count.
private long GetInterfaceCount(String filter)
{
ClearErrorState();
return Database.GetRowCount($"{TableName_Interface} As {aliasInterface}", filter);
}
public override long GetInterfaceCount(SaInterface.Params prm)
{
ClearErrorState();
return GetInterfaceCount(GetInterfaceQueryFilter(prm).Concat(" AND ", "(", ")"));
}
//-------------------------------------------------------------------
// Item list.
public override List<SaInterface> GetInterfaceList(SaInterface.Params prm)
{
ClearErrorState();
List<SaInterface> interfaces = new List<SaInterface>();
DbQuery qry = new DbQuery(Database.DbmsType);
qry.Tables.Add(TableName_Interface, aliasInterface);
SaInterface_Db dbInterface = new SaInterface_Db(DbInfo);
qry.Columns.AddRange(dbInterface.ExistingColumnNames);
qry.Filters.AddRange(GetInterfaceQueryFilter(prm));
qry.OrderBy.AddRange(GetInterfaceSortColumns(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())
interfaces.Add(CreateInterface(dbDataReader));
}
}
catch (Exception exc)
{
SetErrorState(ErrorMessage.DatabaseQueryException);
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return interfaces;
}
//-------------------------------------------------------------------
// Item query.
public override DbResultSet ExecuteInterfaceQuery(List<ColumnDfn> columns, SaInterface.Params prm)
{
ClearErrorState();
//---------------------------------------------------------------------
// Construct query.
DbQuery query = new DbQuery(Database.DbmsType);
query.Tables.Add(TableName_Interface, aliasInterface);
// Add columns as defined in query list.
if (columns.HasId(SaInterface.Column.Id))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, aliasInterface));
if (columns.HasId(SaInterface.Column.Context) || columns.HasId(SaInterface.Column.Type_Desc))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Context, aliasInterface));
if (columns.HasId(SaInterface.Column.Category) || columns.HasId(SaInterface.Column.Category_Desc) || columns.HasId(SaInterface.Column.Type_Desc))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Category, aliasInterface));
if (columns.HasId(SaInterface.Column.Type) || columns.HasId(SaInterface.Column.Type_Desc))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Type, aliasInterface));
if (columns.HasId(SaInterface.Column.Code))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Code, aliasInterface));
if (columns.HasId(SaInterface.Column.Caption))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Caption, aliasInterface));
if (columns.HasId(SaInterface.Column.Active_Y) || columns.HasId(SaInterface.Column.Active_TickCross) || columns.HasId(SaInterface.Column.Active_Ind))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Flags, aliasInterface));
if (columns.HasId(SaInterface.Column.Notes))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Notes, aliasInterface));
if (columns.HasId(SaInterface.Column.Status) || columns.HasId(SaInterface.Column.Status_Desc) || columns.HasId(SaInterface.Column.Status_Ind))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Status, aliasInterface));
if (columns.HasId(SaInterface.Column.CreateOn_Date))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_CreateOn, aliasInterface));
if (columns.HasId(SaInterface.Column.UpdateOn_Date))
query.Columns.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_UpdateOn, aliasInterface));
//---------------------------------------------------------------------
// Process count.
if (columns.HasId(SaInterface.Column.Process_Count))
{
String alias = "IntPrc";
DbQuery queryProcess = new DbQuery(Database.DbmsType);
queryProcess.Tables.Add(TableName_InterfaceProcess, alias);
queryProcess.Columns.Add("Count(*)");
queryProcess.Filters.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterfaceProcess_InterfaceId, alias) + "=" + SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, aliasInterface));
query.Columns.Add("(" + queryProcess.BuildQuery() + ")", colInterface_ProcessCount);
}
//---------------------------------------------------------------------
// Data Item count.
if (columns.HasId(SaInterface.Column.DataItem_Count))
{
String alias = "IntDatItm";
DbQuery queryDataItem = new DbQuery(Database.DbmsType);
queryDataItem.Tables.Add(TableName_InterfaceDataItem, alias);
queryDataItem.Columns.Add("Count(*)");
queryDataItem.Filters.Add(SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterfaceDataItem_InterfaceId, alias) + "=" + SaInterfaceDbDfn.GetColumnNameQual(SaInterfaceDbDfn.ColumnIdx.SaInterface_Id, aliasInterface));
query.Columns.Add("(" + queryDataItem.BuildQuery() + ")", colInterface_DataItemCount);
}
//---------------------------------------------------------------------
// Populate filter.
query.Filters.AddRange(GetInterfaceQueryFilter(prm));
if (prm.IdsIncluded.Count != 1)
{
// Configure sort sequence.
foreach (String sortColumn in GetInterfaceSortColumns(prm))
query.OrderBy.Add(sortColumn);
}
//---------------------------------------------------------------------
//return new DbResultSet_DataTableReader(Database, query.BuildQuery(prm.ResultsPaging));
return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
}
//-------------------------------------------------------------------
}
//=======================================================================
}
Reference in New Issue View Git Blame Copy Permalink