/// <summary>
/// Builds a new Transaction Service preloaded with all available Transaction Type configurations.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="cacheTimeOut">Sets amount of time to cache the transaction service to service future build requests. When null, caching is not used.</param>
/// <returns></returns>
public ITransactionService CreateTransactionService(IProcessExecutionContext executionContext, bool useCache = true)
{
try
{
useCache = useCache && executionContext.Cache != null;
if (useCache)
{
if (executionContext.Cache.Exists(CACHE_KEY))
{
executionContext.Trace("Returning Transaction Service from cache.");
return(executionContext.Cache.Get <ITransactionService>(CACHE_KEY));
}
}
IList <ITransactionType> registeredTransactions = new List <ITransactionType>();
var transactionTypeRecords = DataConnector.GetAllTransactionTypeRecords(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Type records.", transactionTypeRecords.Count);
// get all active records that are needed to fully define a transaction type. This includes complex objects for ITransactionProcess
// and ITransactionRequirements as well as simpler objects for transaction groups, authorized channels, authorized roles,
// initial fees, and eligible record contexts.
var processes = getProcesses(executionContext, useCache);
var requirements = getRequirements(executionContext, useCache);
var transactionGroups = DataConnector.GetAllTransactionGroups(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Group records.", transactionGroups.Count);
var authorizedChannels = DataConnector.GetAllTransactionAuthorizedChannels(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Authorized Channel records.", authorizedChannels.Count);
var authorizedRoles = DataConnector.GetAllAuthorizedRoles(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Authorized Role records.", authorizedRoles.Count);
var initialFees = DataConnector.GetAllInitialFees(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Initial Fee records.", initialFees.Count);
var contexts = DataConnector.GetAllTransactionContextTypes(executionContext.DataService);
executionContext.Trace("Retrieved {0} Transaction Type Context records.", contexts.Count);
// Create a new TransactionType object for each transaction type retrieved.
foreach (ITransactionTypeRecord t in transactionTypeRecords)
{
executionContext.Trace("Processing transaction type '{0}'", t.Name);
ISerializedParameters dataRecordConfig = null;
try
{
executionContext.Trace("Parsing Data Record Configuration.");
dataRecordConfig = this.ParameterSerializer.CreateParamters(t.DataRecordConfiguration);
if (!dataRecordConfig.ContainsKey("RecordType"))
{
throw new Exception("Missing RecordType.");
}
if (!dataRecordConfig.ContainsKey("CustomerField"))
{
throw new Exception("Missing Customer Field");
}
if (!dataRecordConfig.ContainsKey("TransactionField"))
{
throw new Exception("Missing Transaction Field");
}
if (!dataRecordConfig.ContainsKey("NameField"))
{
throw new Exception("Missing Name Field");
}
}
catch (Exception ex)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessStepTypeInvalid, ex);
}
registeredTransactions.Add(new TransactionType(
t,
t.Name,
t.DisplayRank,
transactionGroups.Where(r => t.TransactionGroupId != null && r.Id == t.TransactionGroupId.Id).FirstOrDefault(),
t.StartupProcessId ?? throw new Exception("Transaction type is missing a startup process id."),
dataRecordConfig,
authorizedChannels.Where(r => r.ParentId.Id == t.Id).Select(r => r.ChannelId),
authorizedRoles.Where(r => r.ParentId.Id == t.Id).Select(r => r.RoleId),
processes.Where(r => r.TransactionTypeId.Id == t.Id),
requirements.Where(r => r.TransactionTypeId.Id == t.Id),
initialFees.Where(r => r.TransactionTypeId.Id == t.Id).Select(r => r.FeeId),
contexts.Where(r => r.TransactionTypeId.Id == t.Id)));
}
executionContext.Trace("Creating Transaction Service loaded with {0} Transaction Types.", registeredTransactions.Count);
// Create a new transaction service and pass in required factory and record services.
var transactionService = new TransactionService(this.DataConnector, this.AgentFactory, this.TransactionFeeListFactory, this.TransactionContextFactory, this.CustomerFactory, this.TransactionDeficienciesFactory,
this.DocumentService, this.EvidenceService, this.LocationFactory, RequirementEvaluator, this.TransactionHistoryFactory, this.FeeList, registeredTransactions);
if (useCache)
{
var settings = SettingsFactory.CreateSettings(executionContext.Settings);
var cacheTimeout = settings.PlatformServiceCacheTimeout;
executionContext.Cache.Add <ITransactionService>(CACHE_KEY, transactionService, cacheTimeout.Value);
executionContext.Trace("Cached Transaction Service for {0}.", cacheTimeout.Value);
}
executionContext.TrackEvent("TransactionServiceFactory.BuildTransactionService");
return(transactionService);
}
catch (Exception)
{
throw;
}
}
public ITransaction NewTransaction(IProcessExecutionContext executionContext, IWorkSession workSession, ITransactionContext transactionContext, ITransactionType transactionType)
{
try
{
if (executionContext is null)
{
throw new ArgumentNullException("executionContext");
}
if (workSession == null)
{
throw new ArgumentNullException("workSession");
}
if (transactionContext == null)
{
throw new ArgumentNullException("transactionContext");
}
if (transactionType == null)
{
throw new ArgumentNullException("transactionType");
}
if (workSession.Location == null)
{
throw new ArgumentException("WorkSession is missing required Location.");
}
if (workSession.Agent == null)
{
throw new ArgumentException("WorkSession is missing required Agent.");
}
if (transactionContext.Customer == null)
{
throw new ArgumentException("Transaction context is missing required Customer.");
}
var initialProcess = transactionType.AvailableProcesses.Where(r => r.Id == transactionType.StartUpProcessId.Id).FirstOrDefault();
if (initialProcess == null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessNotFound);
}
var initialStep = initialProcess.GetInitialStep();
if (initialStep == null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessStepNotFound);
}
ITransactionRecord transactionRecord = DataConnector.NewTransactionRecord(
executionContext.DataService,
workSession.Agent,
workSession.Location,
transactionContext.Customer,
transactionContext as IRecordPointer <Guid>,
transactionType,
initialProcess,
initialProcess,
initialStep,
transactionType.Name);
executionContext.TrackEvent("Created New Transaction");
var transaction = buildTransaction(executionContext, transactionRecord);
transaction.TransactionHistory.AddToHistory(executionContext, workSession, transaction.CurrentStep, false);
//create transaction fees entries for any items on the initial fee schedule
foreach (var feeId in transactionType.InitialFeeSchedule)
{
var fee = FeeList.GetFee(executionContext, feeId);
transaction.Fees.AddFee(executionContext, workSession, fee);
}
return(transaction);
}
catch (Exception ex)
{
throw ex;
}
}