396 lines
17 KiB
C#
396 lines
17 KiB
C#
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 System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Sarand.Net.Standard.Dbas.Interfaces
|
|
{
|
|
//=======================================================================
|
|
public abstract class SaInterfaceConsole_Dbas : SaInterfaceConsole
|
|
{
|
|
//-------------------------------------------------------------------
|
|
// Data members.
|
|
private SaInterfaceMgr_Dbas interfaceMgr = null;
|
|
|
|
//-------------------------------------------------------------------
|
|
// Static initialisation.
|
|
static SaInterfaceConsole_Dbas()
|
|
{
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Construction.
|
|
protected SaInterfaceConsole_Dbas(ISacsDatabase database)
|
|
{
|
|
Database = database;
|
|
interfaceMgr = new SaInterfaceMgr_Dbas(this);
|
|
}
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
if (interfaceMgr != null) interfaceMgr.Dispose(); interfaceMgr = null;
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Properties.
|
|
internal ISacsDatabase Database { get; set; }
|
|
public override bool DatabaseIsValid { get { return interfaceMgr.DatabaseIsValid; } }
|
|
public override bool CanUpdateDatabase { get { return interfaceMgr.CanUpdateDatabase; } }
|
|
|
|
//-------------------------------------------------------------------
|
|
// M a n a g e I n t e r f a c e s
|
|
//-------------------------------------------------------------------
|
|
// Manage interfaces - returns true if changes made.
|
|
public override bool ManageInterfaces(String interfaceContext, bool userCanManageInterfaces, bool userCanProcessInterfaces, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
MaintainInterfacesFn?.Invoke(this, interfaceContext, userCanManageInterfaces, userCanProcessInterfaces, dbUpdateInfo);
|
|
return false;
|
|
}
|
|
// Method to display Interface management dialog.
|
|
protected delegate bool MaintainInterfacesFunction(SaInterfaceConsole codeTypeConsole, String interfaceContext, bool userCanManageInterfaces, bool userCanProcessInterfaces, DbUpdateInfo dbUpdateInfo);
|
|
protected abstract MaintainInterfacesFunction MaintainInterfacesFn { get; }
|
|
|
|
//-------------------------------------------------------------------
|
|
// I n t e r f a c e M a n a g e m e n t
|
|
//-------------------------------------------------------------------
|
|
// Interface management.
|
|
public override SysId CreateInterface(String context, SaInterfaceCategory interfaceCategory, short interfaceType, String code, String caption, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
SaInterface interfaceObj = interfaceMgr.CreateInterface(context, interfaceCategory, interfaceType);
|
|
interfaceObj.Code = code;
|
|
interfaceObj.Caption = caption;
|
|
if (!interfaceMgr.InsertInterface(interfaceObj, dbUpdateInfo))
|
|
{
|
|
SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
return null;
|
|
}
|
|
return interfaceObj.Id;
|
|
}
|
|
public override bool UpdateInterface(SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!interfaceMgr.UpdateInterface(interfaceObj, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
return true;
|
|
}
|
|
|
|
// Clear configuration options, data items, processes etc.
|
|
public override bool ClearDependentData(SaInterface interfaceObj, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
throw new NotImplementedException();
|
|
//return OK;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Retrieve interfaces.
|
|
public override SaInterface GetInterface(SaInterface.Params prmInterface)
|
|
{
|
|
return interfaceMgr.GetInterface(prmInterface);
|
|
}
|
|
public override SaInterface GetInterfaceById(SysId interfaceId)
|
|
{
|
|
return interfaceMgr.GetInterfaceById(interfaceId);
|
|
}
|
|
public override ColumnDfn GetInterfaceColumnDfn(SaInterface.Column columnId, string caption = "", int width = 0)
|
|
{
|
|
return interfaceMgr.GetInterfaceColumnDfn(columnId, caption, width);
|
|
}
|
|
public override long GetInterfaceCount(SaInterface.Params prmInterface)
|
|
{
|
|
return interfaceMgr.GetInterfaceCount(prmInterface);
|
|
}
|
|
public override List<SaInterface> GetInterfaceList(SaInterface.Params prmInterface)
|
|
{
|
|
return interfaceMgr.GetInterfaceList(prmInterface);
|
|
}
|
|
public override DbResultSet ExecuteInterfaceQuery(List<ColumnDfn> columns, SaInterface.Params prm)
|
|
{
|
|
return interfaceMgr.ExecuteInterfaceQuery(columns, prm);
|
|
}
|
|
public override DataValue GetInterfaceDataValue(ColumnDfn column, NamedValue.Map values)
|
|
{
|
|
return interfaceMgr.GetInterfaceDataValue(column, values);
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Conversion between Interface Category & Type and the equivalent database Id (if only one exists).
|
|
public override SysId GetInterfaceIdForContextCategoryType(String context, SaInterfaceCategory interfaceCategory, short interfaceType)
|
|
{
|
|
ClearErrorState();
|
|
SaInterface.Params prmInterface = new SaInterface.Params();
|
|
prmInterface.Context = context;
|
|
prmInterface.InterfaceCategory = interfaceCategory;
|
|
prmInterface.InterfaceTypesIncluded.Add(interfaceType);
|
|
prmInterface.ActiveOnly = false;
|
|
prmInterface.StatusCat = SaInterface.StatusCat.Any;
|
|
SaInterface interfaceObj = interfaceMgr.GetInterface(prmInterface);
|
|
if (interfaceObj != null)
|
|
return interfaceObj.Id;
|
|
return null;
|
|
}
|
|
// Conversion between Interface Category & Code and the equivalent database Id (if only one exists).
|
|
public override SysId GetInterfaceIdForContextCategoryCode(String context, SaInterfaceCategory interfaceCategory, String code)
|
|
{
|
|
ClearErrorState();
|
|
SaInterface.Params prmInterface = new SaInterface.Params();
|
|
prmInterface.Context = context;
|
|
prmInterface.InterfaceCategory = interfaceCategory;
|
|
prmInterface.Code = code;
|
|
prmInterface.ActiveOnly = false;
|
|
prmInterface.StatusCat = SaInterface.StatusCat.Any;
|
|
SaInterface interfaceObj = interfaceMgr.GetInterface(prmInterface);
|
|
if (interfaceObj != null)
|
|
return interfaceObj.Id;
|
|
return null;
|
|
}
|
|
public override SaInterfaceCategory GetCategoryForInterfaceId(SysId interfaceId)
|
|
{
|
|
SaInterface interfaceObj = interfaceMgr.GetInterfaceById(interfaceId);
|
|
if (interfaceObj != null)
|
|
return interfaceObj.Category;
|
|
return SaInterfaceCategory.Unknown;
|
|
}
|
|
public override String GetCodeForInterfaceId(SysId interfaceId)
|
|
{
|
|
SaInterface interfaceObj = interfaceMgr.GetInterfaceById(interfaceId);
|
|
if (interfaceObj != null)
|
|
return interfaceObj.Code;
|
|
return String.Empty;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// I n t e r f a c e P r o c e s s e s
|
|
//---------------------------------------------------------------
|
|
// Identify the highest sequence currently in use for an interface.
|
|
public override int GetMaxProcessSequence(SysId interfaceId, SaInterfaceProcessDirection processDirection, bool completedOnly = true)
|
|
{
|
|
ClearErrorState();
|
|
int sequence = interfaceMgr.GetMaxProcessSequenceForInterface(interfaceId, processDirection);
|
|
if (interfaceMgr.HasErrorState())
|
|
SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
return sequence;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Create new process and imediately store details on database (status set to 'In Progress').
|
|
public override SaInterfaceProcess StartInterfaceProcess(SysId interfaceId, SaInterfaceProcessDirection eDirection, String batchRef, DateTime batchAt, int sequence, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!interfaceMgr.InterfaceExistsById(interfaceId))
|
|
{
|
|
SetErrorState("Unable to create process - interface does not exist");
|
|
return null;
|
|
}
|
|
SaInterfaceProcess interfaceProcess = interfaceMgr.CreateInterfaceProcess(interfaceId, eDirection, batchRef, sequence);
|
|
interfaceProcess.ProcessAt = DateTime.Now;
|
|
interfaceProcess.BatchAt = batchAt;
|
|
interfaceProcess.Status = SaStatus.InProgress;
|
|
if (!interfaceMgr.InsertInterfaceProcess(interfaceProcess, dbUpdateInfo))
|
|
{
|
|
interfaceProcess = null;
|
|
SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
}
|
|
return interfaceProcess;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Retrieve a process using its identity (restricted by interface).
|
|
public override SaInterfaceProcess GetInterfaceProcess(SysId interfaceId, SysId interfaceProcessId)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceProcess interfaceProcess = interfaceMgr.GetInterfaceProcessById(interfaceProcessId);
|
|
if (interfaceMgr.HasErrorState())
|
|
{
|
|
SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
interfaceProcess = null;
|
|
}
|
|
if (interfaceProcess != null && !interfaceProcess.InterfaceId.Equals(interfaceId))
|
|
{
|
|
SetErrorState("Process does not match interface");
|
|
interfaceProcess = null;
|
|
}
|
|
return interfaceProcess;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Update the details for a process.
|
|
public override bool StoreInterfaceProcess(SaInterfaceProcess interfaceProcess, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!SysId.IsValid(interfaceProcess.Id))
|
|
{
|
|
// Insert interface process.
|
|
if (!interfaceMgr.InsertInterfaceProcess(interfaceProcess, dbUpdateInfo))
|
|
return SetErrorState("Failed to insert process - " + interfaceMgr.ErrorStateMessage);
|
|
}
|
|
else
|
|
{
|
|
// Update interface process.
|
|
if (!interfaceMgr.UpdateInterfaceProcess(interfaceProcess, dbUpdateInfo))
|
|
return SetErrorState("Failed to update process - " + interfaceMgr.ErrorStateMessage);
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// I n t e r f a c e P r o c e s s M e s s a g e s
|
|
//---------------------------------------------------------------
|
|
public override bool LogInterfaceProcessMessage(SysId interfaceProcessId, DbUpdateInfo dbUpdateInfo, String message, SaMessageLevel messageLevel = SaMessageLevel.Info, String filename = "", int lineNumber = 0, ItemId itemId = null)
|
|
{
|
|
ClearErrorState();
|
|
if (!interfaceMgr.InterfaceProcessExistsById(interfaceProcessId)) return SetErrorState("Invalid interface process id supplied");
|
|
if (StringUtil.IsEmpty(message)) return true;
|
|
|
|
// Create and store process message.
|
|
SaInterfaceProcessMessage interfaceProcessMessage = interfaceMgr.CreateInterfaceProcessMessage(interfaceProcessId);
|
|
interfaceProcessMessage.Message = message;
|
|
interfaceProcessMessage.Level = messageLevel;
|
|
interfaceProcessMessage.Filename = filename;
|
|
interfaceProcessMessage.LineNumber = lineNumber;
|
|
interfaceProcessMessage.ItemId = itemId;
|
|
if (!interfaceMgr.InsertInterfaceProcessMessage(interfaceProcessMessage, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
|
|
return OK;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// I n t e r f a c e D a t a I t e m s
|
|
//---------------------------------------------------------------
|
|
public override bool ItemHasDataItems(ItemId itemId)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.ItemIdsIncluded.Add(itemId);
|
|
return (interfaceMgr.GetInterfaceDataItemCount(prmInterfaceDataItem) > 0);
|
|
}
|
|
public override bool InterfaceDataItemExistsByRef(SysId interfaceId, SaInterfaceProcessDirection processDirection, short itemType, String externalReference)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemType = itemType;
|
|
prmInterfaceDataItem.ExternalReference = externalReference;
|
|
return (interfaceMgr.GetInterfaceDataItemCount(prmInterfaceDataItem) > 0);
|
|
}
|
|
public override SaInterfaceDataItem CreateInterfaceDataItem(SysId interfaceId, SaInterfaceProcessDirection processDirection, ItemId itemId, String externalReference)
|
|
{
|
|
ClearErrorState();
|
|
return interfaceMgr.CreateInterfaceDataItem(interfaceId, processDirection, itemId, externalReference);
|
|
}
|
|
public override SaInterfaceDataItem GetInterfaceDataItem(SysId interfaceDataItemId)
|
|
{
|
|
ClearErrorState();
|
|
return interfaceMgr.GetInterfaceDataItemById(interfaceDataItemId);
|
|
}
|
|
public override SaInterfaceDataItem GetInterfaceDataItemByItemRef(SysId interfaceId, SaInterfaceProcessDirection processDirection, ItemId itemId, String externalReference)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemIdsIncluded.Add(itemId);
|
|
prmInterfaceDataItem.ExternalReference = externalReference;
|
|
return interfaceMgr.GetInterfaceDataItem(prmInterfaceDataItem);
|
|
}
|
|
public override SaInterfaceDataItem GetInterfaceDataItemByRef(SysId interfaceId, SaInterfaceProcessDirection processDirection, short itemType, String externalReference)
|
|
{
|
|
// Fails if more than 1 matching data item.
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemType = itemType;
|
|
prmInterfaceDataItem.ExternalReference = externalReference;
|
|
return interfaceMgr.GetInterfaceDataItem(prmInterfaceDataItem);
|
|
}
|
|
public override SaInterfaceDataItem GetInterfaceDataItemByItem(SysId interfaceId, SaInterfaceProcessDirection processDirection, ItemId itemId)
|
|
{
|
|
// Fails if more than 1 matching data item.
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemIdsIncluded.Add(itemId);
|
|
return interfaceMgr.GetInterfaceDataItem(prmInterfaceDataItem);
|
|
}
|
|
public override List<SaInterfaceDataItem> GetInterfaceDataItemsByItem(SysId interfaceId, SaInterfaceProcessDirection processDirection, ItemId itemId)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemIdsIncluded.Add(itemId);
|
|
return interfaceMgr.GetInterfaceDataItemList(prmInterfaceDataItem);
|
|
}
|
|
public override List<SaInterfaceDataItem> GetInterfaceDataItemsByRef(SysId interfaceId, SaInterfaceProcessDirection processDirection, short itemType, String externalReference)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.InterfaceId = interfaceId;
|
|
prmInterfaceDataItem.Direction = processDirection;
|
|
prmInterfaceDataItem.ItemType = itemType;
|
|
prmInterfaceDataItem.ExternalReference = externalReference;
|
|
return interfaceMgr.GetInterfaceDataItemList(prmInterfaceDataItem);
|
|
}
|
|
public override bool StoreInterfaceDataItem(SaInterfaceDataItem interfaceDataItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (interfaceDataItem == null) return SetErrorState("data item must be supplied");
|
|
if (!SysId.IsValid(interfaceDataItem.Id))
|
|
{
|
|
if (!interfaceMgr.InsertInterfaceDataItem(interfaceDataItem, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
}
|
|
else
|
|
{
|
|
if (!interfaceMgr.UpdateInterfaceDataItem(interfaceDataItem, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
}
|
|
return true;
|
|
}
|
|
public override bool StoreInterfaceDataItems(List<SaInterfaceDataItem> interfaceDataItems, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
foreach (SaInterfaceDataItem interfaceDataItem in interfaceDataItems)
|
|
{
|
|
StoreInterfaceDataItem(interfaceDataItem, dbUpdateInfo);
|
|
if (HasErrorState()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
public override bool ClearInterfaceDataItem(SaInterfaceDataItem interfaceDataItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!interfaceMgr.DeleteInterfaceDataItem(interfaceDataItem, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
return true;
|
|
}
|
|
public override bool ClearInterfaceDataItems(ItemId itemId, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
SaInterfaceDataItem.Params prmInterfaceDataItem = new SaInterfaceDataItem.Params();
|
|
prmInterfaceDataItem.ItemIdsIncluded.Add(itemId);
|
|
foreach (SaInterfaceDataItem interfaceDataItem in interfaceMgr.GetInterfaceDataItemList(prmInterfaceDataItem))
|
|
{
|
|
if (!ClearInterfaceDataItem(interfaceDataItem, dbUpdateInfo))
|
|
return SetErrorState(interfaceMgr.ErrorStateMessage);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
}
|
|
//=======================================================================
|
|
}
|