/// <summary>
/// Can be invoked multiple times - completed only once and only if state is <see cref="EkProcessStateEnum.Started"/>.
/// </summary>
public void CompleteTransaction(TransactionStatusEnum transactionStatus)
{
lock (_stateLocker)
{
if (State != EkProcessStateEnum.Started)
{
return;
}
State = EkProcessStateEnum.TransactionCompleted;
}
try
{
if (_transaction != null)
{
// transaction
if (transactionStatus == TransactionStatusEnum.Completed)
{
_transaction.CompletionStatus = TransactionCompletionStatusEnum.Success;
}
TransactionManager.Current.EndTransaction(_transaction, transactionStatus);
}
Log.Info(LogContextEnum.Workflow, "Process completed.");
}
catch (Exception ex)
{
Log.Error(LogContextEnum.Workflow, "Process completion failed.", ex);
}
}
public TransactionInfo(string id, decimal amount, string currency, DateTime date, TransactionStatusEnum status)
{
Id = id;
Amount = amount;
Currency = currency;
Date = date;
Status = status;
}
public void EndTransaction(
TransactionBase transaction,
TransactionStatusEnum status)
{
Assure.ArgumentNotNull(transaction, nameof(transaction));
transaction.Status = status;
transaction.LocalEndedOn = DateTime.Now;
SaveTransactionForSendingAsync(transaction);
}
public TransactionUpdaterService(ILogger logger, IMapper mapper, int accountId, int transactionId, IAccountRepositoryAsync accountRepo, ITransactionRepositoryAsync transRepo, TransactionStatusEnum status, string server500Error, string closedComment = null)
{
this._logger = logger;
this._mapper = mapper;
this._accountId = accountId;
this._transactionId = transactionId;
this._accountRepo = accountRepo;
this._transRepo = transRepo;
this._status = status;
this._server500Error = server500Error;
this._closedComment = closedComment;
}
public TransactionCreatorService(ILogger logger, IMapper mapper, int accountId, decimal amount, DateTime date, IAccountRepositoryAsync accountRepo, ITransactionRepositoryAsync transRepo, TransactionStatusEnum status, TransactionTypeEnum type, string server500Error)
{
this._logger = logger;
this._mapper = mapper;
this._accountId = accountId;
this._amount = amount;
this._date = date;
this._accountRepo = accountRepo;
this._transRepo = transRepo;
this._status = status;
this._type = type;
this._server500Error = server500Error;
}
public AccountTransactionDomainEntity With(
ITransactionOwner from,
ITransactionOwner to,
decimal amount,
TransactionTypeEnum type,
TransactionStatusEnum status,
ITransactionOwner transactionOwner)
{
var transactionType = coreContext.Query <ITransactionTypeRepository>()
.GetByKey(type.ToString());
var transactionStatus = coreContext.Query <ITransactionStatusRepository>()
.GetByKey(status.ToString());
return(With(from, to, amount, transactionType, transactionStatus, transactionOwner));
}
public TransactionOrderDomainEntity With(
TransactionTypeEnum type,
string orderDescription,
DateTime operationDate,
AccountDomainEntity fromAccount,
AccountDomainEntity toAccount,
decimal amount,
TransactionStatusEnum orderStatus)
{
if (fromAccount.AccountType.AccountTypeId != toAccount.AccountType.AccountTypeId)
{
throw new AccountManagementException.TransactionOrderCouldNotHasDifferentAccountTypes(string.
Format("FromAccountType: {0} - ToAccountType: {1}", fromAccount.AccountType.AccountTypeName, toAccount.AccountType.AccountTypeName));
}
var transactionType = coreContext.Query <ITransactionTypeRepository>().GetByKey(type.ToString());
var transactionStatus = coreContext.Query <ITransactionStatusRepository>().GetByKey(orderStatus.ToString());
return(With(transactionType, orderDescription, operationDate, fromAccount, toAccount, amount, transactionStatus));
}
public ActionResult GetByStatus(TransactionStatusEnum status)
{
return(Ok(JsonConvert.SerializeObject(_transactionManager.GetByStatus(status))));
}
public async Task <IEnumerable <TransactionView> > GetAsync(TransactionStatusEnum status) => await Get(new TransactionFilter(status : status));
public void ChangeNowConverterEnumToStringTest(string expected, TransactionStatusEnum value)
{
Assert.AreEqual(expected, TransactionStatusEnumConverter.EnumToString(value));
}
public void ChangeNowConverterStringToEnumTests(string value, TransactionStatusEnum expected)
{
Assert.AreEqual(expected, TransactionStatusEnumConverter.StringToEnum(value));
}
public List <Transaction> GetByStatus(TransactionStatusEnum status)
{
return(_unitOfWork.TransactionRepository.GetByStatus(status));
}
public List<TransactionPayment> SearchTransactionPayments(DateTime? startTime, DateTime? endTime, string memberEmail, TransactionStatusEnum? os, PaymentStatusEnum? ps)
{
throw new NotImplementedException();
}
public void SetStatus(TransactionStatusEnum transactionStatus)
{
TransactionStatus = coreContext.Query <ITransactionStatusRepository>().GetByKey(transactionStatus.ToString());
}
public static int ToInt(this TransactionStatusEnum transactionStatus)
{
return(Convert.ToInt32(transactionStatus));
}
public List<RecurringPayment> SearchRecurringPayments(bool showHidden, long memberId, long initialTransactionPaymentId, TransactionStatusEnum? initialTransactionPaymentStatus)
{
throw new NotImplementedException();
}
public static string EnumToString(TransactionStatusEnum status)
{
return(status.ToString().ToLower());
}
public List <Transaction> GetByStatus(TransactionStatusEnum status)
{
return(_dbContext.Transactions.Where(t => t.Status == (int)status).ToList());
}
public async Task <DigitalAccountTransactionModel> UpdateStatusAsync(DigitalAccountTransactionModel digitalAccountTransaction, TransactionStatusEnum status)
{
digitalAccountTransaction.Status = status;
digitalAccountTransaction.ReleaseDate = DateTime.Now;
return(await _digitalAccountTransactionRepository.UpdateAsync(digitalAccountTransaction));
}
