public PublishTransaction(Guid accountId, decimal value, ETransactionType type)
{
AccountId = accountId;
Date = DateTime.Now;
Value = value;
Type = type;
}
public TransactionEvent(Guid accountId, DateTime date, decimal value, ETransactionType type)
{
AccountId = accountId;
Date = date;
Value = value;
Type = type;
}
public TransactionsListDTO GetAndFilterTransactions(
DateTime dateFrom,
DateTime dateTo,
ETransactionType transactionType,
Guid accountId)
{
var transactions = _transactionRepository.GetTransactions(dateFrom, dateTo, transactionType, accountId);
if (!transactions.Any())
{
return(new TransactionsListDTO());
}
var transactionsList = new TransactionsListDTO(
accountId,
transactions.First().AccountBalanceBefore,
transactions.Last().AccountBalanceAfter);
foreach (var item in transactions)
{
transactionsList.Transactions.Add(
new TransactionDTO(
item.CreateDate.ToString("dd/MM/yyyy HH:mm:ss"),
item.Description,
item.Value));
}
return(transactionsList);
}
public Transaction(Guid id, decimal valueTransaction, ETransactionType transactionType)
{
AccountId = id;
DateTransaction = DateTime.Now;
ValueTransaction = valueTransaction;
Type = transactionType;
}
/// <summary>
/// Initializes a new instance of the <see cref="Transaction"/> class.
/// </summary>
/// <param name="amount">The amount to be used for the transaction</param>
/// <param name="transactionType">The type of the transaction.</param>
/// <param name="accounts">The accounts involved in the transaction.</param>
public Transaction(double amount, ETransactionType transactionType, params Account[] accounts)
{
Amount = amount;
TransactionType = transactionType;
Accounts = new Account[accounts.Length];
Array.Copy(accounts, Accounts, accounts.Length);
}
public AnonymousTransaction(Oid id, DateTime timestamp, ETransactionType transactionType, double amount, string memo) : base(id)
{
TransactionType = transactionType;
Amount = amount;
Timestamp = timestamp;
Memo = memo;
}
public CreateTransaction(Guid accountId, decimal value, ETransactionType type, DateTime date)
{
AccountId = accountId;
Date = date;
Value = value;
Type = type;
}
public Transaction(ETransactionType transactionType, decimal value, Guid accountId)
{
TransactionType = transactionType;
Value = value;
CreateAt = DateTime.Now;
AccountId = accountId;
}
//----------------------------------------------------------------------------------------------
internal Transaction AddTransaction(Oid accountId, ETransactionType transactionType, double amount, string memo = null)
{
var transaction = new Transaction(GetNextOid(), DateTime.UtcNow, accountId, transactionType, amount, memo);
Context.Transactions.Add(transaction.Id, transaction);
return(transaction);
}
public Transaction(ETransactionType transctionType, DateTime transactionDate, long checkNum, double transactionValue, string description)
{
TransctionType = transctionType;
TransactionDate = transactionDate;
CheckNum = checkNum;
TransactionValue = transactionValue;
Description = description;
}
//----------------------------------------------------------------------------------------------
private static EAuthorizations GetRequiredAuthorizationsByTransactionType(ETransactionType transactionType)
{
if (RequiredAuthorizationsByTransactionType.TryGetValue(transactionType, out var authorizations))
{
return(authorizations);
}
return(EAuthorizations.Update);
}
public TransactionCategory(string name, ETransactionType transactionType)
{
Name = name;
TransactionType = transactionType;
AddNotifications(new Contract()
.Requires()
.HasMaxLen(Name, 40, "TransactionCategory.Name", "O nome de uma categoria de transação deve ter no máximo 40 caracteres")
.HasMinLen(Name, 3, "TransactionCategory.Name", "O nome de uma categoria de transação deve ter no mínimo 3 caracteres")
);
}
public TransactionsListDTO GetTransactions(
DateTime dateFrom,
DateTime dateTo,
ETransactionType transactionType,
Guid accountId)
{
var transactionService = new TransactionsFilterService(_transactionRepository);
return(transactionService.GetAndFilterTransactions(dateFrom, dateTo, transactionType, accountId));
}
public static Expression <Func <Transaction, bool> > GetTransactions(
DateTime dateFrom,
DateTime dateTo,
ETransactionType transactionType,
Guid accountId)
{
return(x =>
x.CreateDate >= dateFrom &&
x.CreateDate <= dateTo &&
x.TransactionType == transactionType &&
x.AccountId == accountId);
}
public static Transaction GetLastBySubscription(long oidSuscription, ETransactionType transType, EEstado[] status,
bool childs, int sessionCode = -1)
{
CriteriaEx criteria = new CriteriaEx();
criteria.Orders = new OrderList();
criteria.Orders.NewOrder("Created", ListSortDirection.Descending, typeof(Transaction));
TransactionList list = TransactionList.GetBySubscription(oidSuscription, transType, status, criteria, childs);
return((list.Count > 0) ? Get(list[0].Oid, childs, sessionCode) : null);
}
public static Transaction GetBySubscription(long oidSuscription, ETransactionType transType, EEstado[] status, bool childs, int sessionCode = -1)
{
QueryConditions conditions = new QueryConditions
{
Oid = oidSuscription,
EntityType = ETipoEntidad.Subscription,
Transaction = TransactionInfo.New(),
Status = status
};
conditions.Transaction.ETransactionType = transType;
return(Get(SELECT(conditions), childs, -1));
}
public string GetType(ETransactionType type)
{
switch (type)
{
case ETransactionType.Authentication: return("3");
case ETransactionType.Preauthorization: return("16");
case ETransactionType.PreauthCharge: return("7");
case ETransactionType.PreauthCancelation: return("18");
default: return(string.Empty);
}
}
public Transaction(
Guid accountId,
string description,
ETransactionType transactionType,
decimal value,
decimal accountBalanceAfter,
decimal accountBalanceBefore)
{
AccountId = accountId;
CreateDate = DateTime.Now;
Description = description;
TransactionType = transactionType;
Value = value;
AccountBalanceAfter = accountBalanceAfter;
AccountBalanceBefore = accountBalanceBefore;
}
public static TransactionList GetBySubscription(long oidSuscription, ETransactionType transType, EEstado[] status, CriteriaEx criteria, bool childs)
{
QueryConditions conditions = new QueryConditions
{
Oid = oidSuscription,
EntityType = ETipoEntidad.Subscription,
Transaction = TransactionInfo.New(),
Status = status,
PagingInfo = criteria.PagingInfo,
Filters = criteria.Filters,
Orders = criteria.Orders
};
conditions.Transaction.ETransactionType = transType;
return(GetList(SELECT(conditions), childs));
}
public Transaction(Account sourceAccount, Account targetAccount, decimal amount, ETransactionType type)
{
if (amount <= 0)
{
AddNotification(new Notification("Valor", "O valor precisa ser maior que 0"));
}
AddNotifications(
new Contract()
.Requires()
.IsNotNull(sourceAccount, "ContaOrigem", "Conta origem inválida")
.IsNotNull(targetAccount, "ContaDestino", "Conta destino inválida")
);
SourceAccount = sourceAccount;
TargetAccount = targetAccount;
Amount = amount;
Type = type;
}
//----------------------------------------------------------------------------------------------
private static string GetTransactionAuthorizationExceptionMessage(string username,
string accountNumber,
ETransactionType transactionType,
double amount)
{
string message;
if (TransactionMessagePatterns.TryGetValue(transactionType, out string messagePattern))
{
message = string.Format(messagePattern,
username,
accountNumber,
amount);
}
else
{
message = "Transaction failed";
}
return(message);
}
public IEnumerable <TransactionVieweModel> GetTransactionsByType(ETransactionType type, DateTime startDate, DateTime endDate)
{
List <Transaction> transactions = null;
if (startDate == null && endDate != null && endDate != default(DateTime))
{
transactions = context.Transaction.Where(x => x.Type == (int)type && x.Date <= endDate.Date).ToList();
}
if (startDate != null && startDate != default(DateTime) && endDate == null)
{
transactions = context.Transaction.Where(x => x.Type == (int)type && x.Date >= startDate.Date).ToList();
}
if (startDate != null && startDate != default(DateTime) && endDate != null && endDate != default(DateTime))
{
transactions = context.Transaction.Where(x => x.Type == (int)type && x.Date >= startDate.Date && x.Date <= endDate.Date).ToList();
}
//if ((startDate == null || startDate == default(DateTime)) && (endDate == null || endDate == default(DateTime)))
// transactions = context.Transaction.Where(x => x.Type == (int)type).ToList();
List <TransactionVieweModel> transactionsViewResult = null;
if (transactions != null)
{
transactionsViewResult = new List <TransactionVieweModel>();
foreach (var transaction in transactions)
{
var viewModel = MarketMapper.Mapper.Map <Transaction, TransactionVieweModel>(transaction);
transactionsViewResult.Add(viewModel);
}
}
return(transactionsViewResult);
}
public async Task AddTransaction(Guid walletId, ETransactionType transactionType, Amount amount, string description)
{
var wallet = await walletReadOnlyRepository.GetWallet(walletId);
if (wallet == null)
{
return;
}
Transaction transaction = null;
if (transactionType == ETransactionType.Credit)
{
transaction = new CreditTransaction(amount, description, DateTime.Now);
}
else if (transactionType == ETransactionType.Debit)
{
transaction = new DebitTransaction(amount, description, DateTime.Now);
}
wallet.AddTransaction(transaction);
await Save(wallet);
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="pTransaction"></param>
public CTransaction(CTransaction pTransaction)
{
Quantity = pTransaction.Quantity;
Client = pTransaction.Client;
TransactionType = pTransaction.TransactionType;
}
public Transaction(Oid id, DateTime timestamp, Oid accountId, ETransactionType transactionType, double amount, string memo)
: base(id, timestamp, transactionType, amount, memo)
{
AccountId = accountId;
}
public void InsufficientFundsError(int userId, decimal amount, decimal currentAmount, ETransactionType transactionType)
{
#region fixture setup
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var mockClientRepository = new Mock <IClientRepository>();
var appConfig = new AppConfiguration(20000);
mockClientRepository.Setup(p => p.FindByIdAsync(userId)).ReturnsAsync(new Client()
{
ClientId = userId, CurrentAmount = currentAmount
});
mockClientRepository.Setup(p => p.GetAccountBalanceAsync(userId)).ReturnsAsync(currentAmount);
#endregion
_transactionService = new BL.Services.TransactionService(appConfig, mockClientRepository.Object, fixture.Freeze <ITransactionRepository>());
var result = _transactionService.SubmitTransactionAsync(new Transaction()
{
ClientId = userId, Amount = amount, TransactionType = transactionType
});
Assert.AreEqual(result.Result.TransactionError, ETransactionError.InsuficientFunds);
}
public IEnumerable <Transaction> GetTransactions(DateTime dateFrom, DateTime dateTo, ETransactionType transactionType, Guid accountId)
{
return(_context.Transactions
.AsNoTracking()
.Where(TransactionQueries.GetTransactions(dateFrom, dateTo, transactionType, accountId))
.OrderBy(x => x.CreateDate));
}
public static Transaction GetByTransactionID(string transactionID, ETipoEntidad entityType, ETransactionType transType, EEstado[] status, bool childs)
{
QueryConditions conditions = new QueryConditions
{
EntityType = entityType,
Transaction = TransactionInfo.New(),
Status = status
};
conditions.Transaction.TransactionID = transactionID;
conditions.Transaction.ETransactionType = transType;
return(Get(SELECT(conditions), childs));
}
// CONSTRUCTORS
public TransactionType()
{
this.Value = new ETransactionType();
}
public TransactionType(ETransactionType value)
{
this.Value = value;
}
/////////////////////////////////////////////////////////////////////////////
public Transaction(string _sName, ETransactionType _eType, double _fValue, EAccountType _eAccountType, EAccountType _eAccountType2)
: this(_sName, _eType, _fValue, _eAccountType, _eAccountType2, 0, 0)
{
}
/////////////////////////////////////////////////////////////////////////////
public Transaction()
{
m_sName = "";
m_lValue = 0;
m_eType = ETransactionType.eNoOp;
}
/////////////////////////////////////////////////////////////////////////////
public Transaction(string _sName, ETransactionType _eType, double _fValue, EAccountType _eAccountType, EAccountType _eAccountType2, JulianDay lStartDateLimit, JulianDay lEndDateLimit)
{
m_sName = _sName;
m_lValue = (tMillicents)(_fValue * 1000.0);
m_eType = _eType;
}
