public Transaction(IProcessExecutionContext executionContext, IAgentFactory agentFactory, ITransactionFeeListFactory transactionFeeListFactory, ITransactionContextFactory transactionContextFactory,
ICustomerFactory customerFactory, ITransactionDeficienciesFactory transactionDeficienciesFactory, IDocumentService documentService, IEvidenceService evidenceService,
ILocationFactory locationFactory, IRequirementEvaluator requirementEvaluator, ITransactionHistoryFactory transactionHistoryFactory, ITransactionService transactionService,
ITransactionType transactionType, ITransactionRecord record)
: base(record.RecordType, record.Id)
{
this.ExecutionContext = executionContext ?? throw new ArgumentNullException("executionContext");
this.AgentFactory = agentFactory ?? throw new ArgumentNullException("agentFactory");
this.TransactionFeeListFactory = transactionFeeListFactory ?? throw new ArgumentNullException("transactionFeeListFactory");
this.TransactionContextFactory = transactionContextFactory ?? throw new ArgumentNullException("transactionContextFactory");
this.CustomerFactory = customerFactory ?? throw new ArgumentNullException("customerFactory");
this.TransactionDeficienciesFactory = transactionDeficienciesFactory ?? throw new ArgumentNullException("transactionDeficienciesFactory");
this.DocumentService = documentService ?? throw new ArgumentNullException("documentService");
this.EvidenceService = evidenceService ?? throw new ArgumentNullException("evidenceService");
this.LocationFactory = locationFactory ?? throw new ArgumentNullException("locationFactory");
this.RequirementEvaluator = requirementEvaluator ?? throw new ArgumentNullException("requirementEvaluator");
this.TransactionHistoryFactory = transactionHistoryFactory ?? throw new ArgumentNullException("transactionHistoryFactory");
this.TransactionService = transactionService ?? throw new ArgumentNullException("transactionService");
this.TransactionType = transactionType ?? throw new ArgumentNullException("transactionType");
this.Name = record.Name;
this.ReferenceNumber = record.ReferenceNumber;
this.PricingDate = record.PricingDate ?? DateTime.Now.Date;
this.InitiatingProcessId = record.InitiatingProcessId ?? throw new ArgumentNullException("InitiatingProcessId");
this.CurrentProcessId = record.CurrentProcessId ?? throw new ArgumentNullException("CurrentProcessId");
this.CurrentStepId = record.CurrentStepId ?? throw new ArgumentNullException("CurrentStepId");
this.ContextRecordId = record.ContextRecordId ?? throw new ArgumentNullException("contextRecordId");
this.CustomerId = record.CustomerId ?? throw new ArgumentNullException("customerId");
this.InitiatingAgentId = record.InitiatingAgentId ?? throw new ArgumentNullException("initiatingAgentId");
this.InitiatingLocationId = record.InitiatingLocationId ?? throw new ArgumentNullException("initiatingLocationId");
}
public TransactionRecord(Utility.TransactionType transactionType)
{
myTransaction = ITransactionRecord.GenerateNewTransactionData();
if (myTransaction != null)
{
myTransaction.ID = ITransactionRecord.GenerateNewID();
myTransaction.TimeStamp = DateTime.Now;
myTransaction.TransactionType = (int)transactionType;
myTransaction.TransactionCode = (int)Utility.TransactionCodes.SUCCESS;
}
}
public TransactionEventArgs(ITransactionRecord transaction)
{
_transaction = transaction;
}
private ITransaction buildTransaction(IProcessExecutionContext executionContext, ITransactionRecord record)
{
if (record.TransactionTypeId is null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.TransactionMissingTypeId);
}
var transactionType = this.RegisteredTransactionTypes.Where(t => t.Id == record.TransactionTypeId.Id).FirstOrDefault();
if (transactionType == null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.TransactionTypeNotFound);
}
// Create a new Transaction object and pass in all the factories and record services needed to load related data as needed.
ITransaction transaction = new Transaction(executionContext, this.AgentFactory, this.TransactionFeeListFactory, this.TransactionContextFactory, this.CustomerFactory,
this.TransactionDeficienciesFactory, this.DocumentService, this.EvidenceService, this.LocationFactory, this.RequirementEvaluator, this.TransactionHistoryFactory,
this as ITransactionService, transactionType, record);
return(transaction);
}
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;
}
}
public void appendTransaction(ITransactionRecord transaction)
{
_history.Add(transaction);
onTransactionCommitted?.Invoke(this, new TransactionEventArgs(transaction));
}
