public static List <Entities.Transaction> GetAll(Entities.Portfolio p)
{
List <Entities.Transaction> result = new List <Entities.Transaction>();
string sql = "SELECT * FROM Transactions WHERE PortfolioID=@PortfolioID";
SqlCommand cmdGetAllTransactions = new SqlCommand(sql, Globals.Db.conn);
cmdGetAllTransactions.Parameters.Add("@PortfolioId", SqlDbType.Int).Value = p.PortfolioID;
using (SqlDataReader reader = cmdGetAllTransactions.ExecuteReader())
{
while (reader.Read())
{
int id = (int)reader["Id"];
int portfolioID = (int)reader["portfolioId"];
string type = (string)reader["Type"];
string symbol = (string)reader["Symbol"];
decimal price = (decimal)reader["BuySellPrice"];
int sharesBoughtSold = (int)reader["SharesBoughtSold"];
DateTime date = (DateTime)reader["date"];
Entities.Transaction t = new Entities.Transaction(id, portfolioID, type, symbol, price, sharesBoughtSold, date);
result.Add(t);
}
}
return(result);
}
public void CreateMany(IEnumerable <Transaction> transactions)
{
var entitiesByTransaction = new Dictionary <Transaction, Entities.Transaction>();
foreach (Transaction transaction in transactions)
{
var transactionEntity = new Entities.Transaction
{
CreditAccountId = transaction.CreditAccount.AccountId,
DebitAccountId = transaction.DebitAccount.AccountId,
Amount = transaction.Amount,
At = transaction.At
};
m_dbContext.Transactions.Add(transactionEntity);
entitiesByTransaction.Add(transaction, transactionEntity);
}
m_dbContext.SaveChanges();
foreach (KeyValuePair <Transaction, Entities.Transaction> entityByTransaction in entitiesByTransaction)
{
entityByTransaction.Key.TransactionId = entityByTransaction.Value.TransactionId;
}
}
private async void OnOk()
{
await ValidateAsync();
if (HasErrors)
{
return;
}
Entities.Transaction selectedTransaction = SelectedTransaction;
SelectedTransaction.Payment += UpdatePayment.GetValueOrDefault();
_context.SaveChanges();
UpdatePayment = null;
LoadData();
if (_isByCustomer)
{
Transactions = _originalTransactions.Where(c => c.Customer.Id == SelectedCustomer.Id).ToList();
SelectedTransaction = selectedTransaction;
}
else
{
Transactions = _originalTransactions;
SelectedTransaction = selectedTransaction;
}
UpdateCommand.RaiseCanExecuteChanged();
CalculateTransaction();
DialogHost.CloseDialogCommand.Execute(this, null);
}
public void UpdateTransaction(Guid transactionId, int succeeded, string message)
{
Entities.Transaction transaction = _context.Transactions.FirstOrDefault(t => t.TransactionId == transactionId);
transaction.Status = (Entities.Status)succeeded;
transaction.FailureReason = message;
_context.SaveChanges();
}
private static Entities.Transaction TransactionFromElement(
XElement element,
Dictionary <string, Entities.Account> accountsByShortName,
Dictionary <int, Entities.Transaction> transactionsByIncomingId
)
{
string incomingIdText = GetRequiredAttribute(element, "id").Value;
int incomingId = Int32.Parse(incomingIdText);
string at = GetRequiredAttribute(element, "at").Value;
string creditAccountName = GetRequiredAttribute(element, "credit").Value;
string amount = GetRequiredAttribute(element, "amount").Value;
string debitAccountName = GetRequiredAttribute(element, "debit").Value;
var transaction = new Entities.Transaction
{
At = DateTime.Parse(at),
CreditAccount = accountsByShortName[creditAccountName],
Amount = Decimal.Parse(amount),
DebitAccount = accountsByShortName[debitAccountName]
};
transactionsByIncomingId.Add(incomingId, transaction);
return(transaction);
}
public void Create(Entities.Transaction model)
{
var transactionId = "MX-" + model.Id;
if (GetCurrentTransactions().Any(t => t.Id == transactionId))
{
throw new ArgumentException("Transaktionsnumret finns redan.");
}
var materialType = getMaterialType(model.MaterialTypeId);
var transaction = new Entities.Transaction
{
Id = transactionId,
Name = model.Name,
Description = model.Description,
MaterialTypeId = materialType.Id,
MaterialType = materialType,
MaterialTypeComment = model.MaterialTypeComment,
ShippingDate = model.ShippingDate,
ExpectedWeight = model.ExpectedWeight,
ShippingMethod = model.ShippingMethod,
Supplier = model.Supplier
};
repository.Transactions.Add(transaction);
repository.SaveChanges();
}
public Entities.Transaction Handle(InsertTransactionCommand command)
{
if (command is null)
{
throw new ArgumentNullException(nameof(command));
}
command.Validate();
var account = _accountRepository.GetAccount(command.AccountId);
UpdateValues(command.TransactionType, command.Value, account);
var transaction = new Entities.Transaction
{
TransactionType = command.TransactionType,
Value = command.Value,
Date = command.Date,
AccountId = command.AccountId
};
_transactionRepository.InsertTransaction(transaction);
_accountRepository.UpdateAccount(account);
return(transaction);
}
private static Transaction FromEntity(Entities.Transaction transactionEntity)
{
return(new Transaction
{
TransactionId = transactionEntity.TransactionId,
CreditAccount = FromEntity(transactionEntity.CreditAccount),
DebitAccount = FromEntity(transactionEntity.DebitAccount),
Amount = transactionEntity.Amount,
At = transactionEntity.At
});
}
public async Task <Guid> AddTransaction(TransactionModel transactionModel)
{
Entities.Transaction transaction = _mapper.Map <Entities.Transaction>(transactionModel);
transaction.Date = DateTime.Now;
transaction.Status = 0;
transaction.TransactionId = Guid.NewGuid();
_context.Transactions.Add(transaction);
await _context.SaveChangesAsync();
return(transaction.TransactionId);
}
/// <summary>
/// Creates a new <see cref="Transaction"/> of the given kind.
/// </summary>
/// <param name="orderId">The order id to which the fulfillments belong.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="cancellationToken">Cancellation Token</param>
/// <returns>The new <see cref="Transaction"/>.</returns>
public virtual async Task <Entities.Transaction> CreateAsync(long orderId, Entities.Transaction transaction, CancellationToken cancellationToken = default)
{
var req = PrepareRequest($"orders/{orderId}/transactions.json");
var content = new JsonContent(new
{
transaction = transaction
});
var response = await ExecuteRequestAsync <Entities.Transaction>(req, HttpMethod.Post, cancellationToken, content, "transaction");
return(response.Result);
}
public void Update(Transaction transaction)
{
Entities.Transaction transactionEntity = m_dbContext.Transactions
.Single(t => t.TransactionId == transaction.TransactionId);
transactionEntity.CreditAccountId = transaction.CreditAccount.AccountId;
transactionEntity.DebitAccountId = transaction.DebitAccount.AccountId;
transactionEntity.Amount = transaction.Amount;
transactionEntity.At = transaction.At;
m_dbContext.SaveChanges();
}
public void TestTransactionDelete()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 31, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionService = new TransactionService(loggerFactory, sqliteMemoryWrapper.DbContext);
transactionService.Delete(transactionEntities[0].TransactionId);
List <Transaction> transactions = transactionService.GetAll().ToList();
Assert.AreEqual(1, transactions.Count);
Assert.AreEqual(transactionEntities[1].TransactionId, transactions[0].TransactionId);
Assert.AreEqual(transactionEntities[1].Amount, transactions[0].Amount);
Assert.AreEqual(transactionEntities[1].At, transactions[0].At);
Assert.AreEqual(transactionEntities[1].CreditAccountId, transactions[0].CreditAccount.AccountId);
Assert.AreEqual(transactionEntities[1].DebitAccountId, transactions[0].DebitAccount.AccountId);
}
}
public async Task Handle(PaymentCompletedIntegrationEvent @event)
{
var account = await dbContext.Accounts.Include(x => x.Transactions).FirstOrDefaultAsync(x => x.Id == @event.AccountId);
var trans = new Entities.Transaction {
Amount = @event.Amount, DateTime = @event.PaymentTime
};
account.Transactions.Add(trans);
await dbContext.SaveChangesAsync();
}
private static XElement ElementFromTransaction(Entities.Transaction transaction)
{
var element = new XElement(XName.Get("Transaction"),
new XAttribute(XName.Get("id"), transaction.TransactionId),
new XAttribute(XName.Get("at"), transaction.At),
new XAttribute(XName.Get("credit"), transaction.CreditAccount.Name),
new XAttribute(XName.Get("amount"), transaction.Amount),
new XAttribute(XName.Get("debit"), transaction.DebitAccount.Name)
);
return(element);
}
public void Create(Transaction transaction)
{
var transactionEntity = new Entities.Transaction
{
CreditAccountId = transaction.CreditAccount.AccountId,
DebitAccountId = transaction.DebitAccount.AccountId,
Amount = transaction.Amount,
At = transaction.At
};
m_dbContext.Transactions.Add(transactionEntity);
m_dbContext.SaveChanges();
transaction.TransactionId = transactionEntity.TransactionId;
}
public void Delete(int transactionId)
{
Entities.Transaction transactionEntity =
m_dbContext.Transactions.SingleOrDefault(t => t.TransactionId == transactionId);
if (transactionEntity == null)
{
throw new ArgumentException(
$"No Transaction exists with TransactionId {transactionId}",
nameof(transactionId)
);
}
m_dbContext.Transactions.Remove(transactionEntity);
m_dbContext.SaveChanges();
}
public Transaction Get(int transactionId)
{
Entities.Transaction transactionEntity =
m_dbContext.Transactions
.Include(t => t.CreditAccount)
.Include(t => t.DebitAccount)
.SingleOrDefault(t => t.TransactionId == transactionId);
if (transactionEntity == null)
{
throw new ArgumentException(
$"No Transaction exists with TransactionId {transactionId}",
nameof(transactionId));
}
return(FromEntity(transactionEntity));
}
public bool Add(Entities.Transaction transaction)
{
using (var connection = Helpers.NewConnection())
{
SqlCommand command = new SqlCommand($"INSERT INTO Transactions (Id, Amount, Date, AccountId) VALUES ('{Guid.NewGuid()}',@amount, '{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}', @accountId)", connection);
command.Parameters.AddWithValue("@amount", transaction.Amount);
command.Parameters.AddWithValue("@accountId", transaction.AccountId);
connection.Open();
if (command.ExecuteNonQuery() != 1)
{
return(false);
}
return(true);
}
}
private void addNewBatch(Entities.Transaction transaction, Entities.MaterialType materialType, Entities.LoadingPosition loadingPosition, string username)
{
string transactionId = transaction.Id;
int materialTypeId = materialType.Id;
var batch = new Entities.Batch
{
Id = new Random().Next(1, 100000),
MaterialTypeId = materialTypeId,
MaterialType = materialType,
LoadingPosition = loadingPosition,
StartedAt = DateTime.Now,
StartedBy = username,
StoppedAt = null,
StoppedBy = null,
TransactionId = transactionId,
Transaction = transaction
};
transaction.Batches.Add(batch);
}
public async Task <TransactionDTO> Create([FromBody] TransactionDTO transactionRequestDTO)
{
Entities.Transaction newTransaction = new Entities.Transaction {
WalletName = transactionRequestDTO.WalletName,
Amount = transactionRequestDTO.Amount,
CategoryName = transactionRequestDTO.CategoryName,
Date = transactionRequestDTO.Date,
Note = transactionRequestDTO.Note,
UserId = currentUserId
};
Entities.Transaction res = await transactionService.Create(newTransaction);
return(new TransactionDTO
{
Errors = res.Errors,
WalletName = res.WalletName,
Note = res.Note,
Date = res.Date,
CategoryName = res.CategoryName,
Amount = res.Amount
});
}
public async Task <string> ProcessCardcomTransaction()
{
#region ### IPN Parameters ###
/*
* GET https://localhost:44373/Purchase/ProcessCardcomTransaction?terminalnumber=1000&lowprofilecode=2467a885-1f97-40d5-8b5f-42222ce64c80&Operation=2&DealRespone=0&DealResponse=0&TokenResponse=0&InvoiceResponseCode=0&OperationResponse=0&OperationResponseText=OK&ReturnValue=39.90%7c3%7c1%7c98F41F8F-6F6C-4A0A-A7D4-D719A41A6BD7
*
* ---
*
* terminalnumber=1000
* lowprofilecode=2467a885-1f97-40d5-8b5f-42222ce64c80
* Operation=2
* DealResponse=0
* TokenResponse=0
* InvoiceResponseCode=0
* OperationResponse=0
* OperationResponseText=OK
* ReturnValue=39.90|3|1|98F41F8F-6F6C-4A0A-A7D4-D719A41A6BD7
*/
#endregion
var step = 0;
var transaction = new Entities.Transaction();
var httpResult = "";
var transactionsBLL = new TransactionsBLL();
var ordersBLL = new OrdersBLL();
try
{
LoggerSingleton.Instance.Info("Cardcom", "Process-Transaction", new List <string> {
$"QueryString: {Request.QueryString}"
});
step = 1;
var cardcomManager = new CardcomManager(ConfigSingleton.Instance.CardcomTerminal, ConfigSingleton.Instance.CardcomUserName);
step = 2;
// Collect basic details
transaction.Raw = Request.QueryString?.ToString();
transaction.Code = Request.QueryString["lowprofilecode"];
transaction.StatusCode = Convert.ToInt32(Request.QueryString["OperationResponse"]);
transaction.StatusCodeCard = Convert.ToInt32(Request.QueryString["DealResponse"]);
step = 3;
if (transaction.StatusCode != 0)
{
throw new Exception($"[StatusCode Error] StatusCode {transaction.StatusCode} ({transaction.Code})");
}
step = 4;
// Collect extra details
var detailsResponse = cardcomManager.GetTransactionDetails(transaction.Code);
transaction.StatusCodeDetails = Convert.ToInt32(detailsResponse.Details["ResponseCode"]);
transaction.RawDetails = detailsResponse.Raw;
step = 5;
// add invoice details
transaction.InvoiceStatusCode = Convert.ToInt32(detailsResponse.Details["InvoiceResponseCode"]);
transaction.InvoiceNumber = detailsResponse.Details["InvoiceNumber"] ?? "";
transaction.InvoiceType = Convert.ToInt32(detailsResponse.Details["InvoiceType"] ?? "0");
step = 6;
if (transaction.StatusCodeDetails != 0)
{
throw new Exception($"[StatusCode Error] StatusCodeDetails {transaction.StatusCodeDetails} ({transaction.Code})");
}
step = 7;
transaction.CardOwnerId = detailsResponse.Details["CardOwnerID"] ?? "";
// fix format > MM (e.g: 7 to 07)
var CardValidityMonth = detailsResponse.Details["CardValidityMonth"] ?? "";
if (CardValidityMonth.Length == 1)
{
CardValidityMonth = $"0{CardValidityMonth}";
}
transaction.CardExpiry = $"{detailsResponse.Details["CardValidityYear"] ?? ""}{CardValidityMonth}";
transaction.CardSuffix = detailsResponse.Details["ExtShvaParams.CardNumber5"] ?? "";
transaction.NumOfPayments = Convert.ToInt32(detailsResponse.Details["NumOfPayments"] ?? "1");
step = 8;
// load ReturnValue field > extract order-id
var returnValue = detailsResponse.Details["ReturnValue"].Trim();
var orderId = Convert.ToInt32(returnValue);
step = 9;
// load related order
var order = await ordersBLL.Get(orderId);
step = 10;
// Collect custom details
transaction.Price = order.Total;
transaction.OrderId = order.Details.Id;
step = 11;
// update Order Status
order.Details.Status = Entities.eOrderStatus.APPROVED;
order.Details.IsPaid = true;
var orderUpdated = await ordersBLL.SaveDetails(order.Details) > 0;
if (!orderUpdated)
{
LoggerSingleton.Instance.Info("Cardcom", "Save Order Details Failed", new List <string> {
$"#{orderId}", "Status: APPROVED", $"Code: {transaction.Code}"
});
}
step = 12;
// send sms
if (orderUpdated)
{
SMSManager.OrderStatusChanged(order);
}
step = 13;
httpResult = "OK";
}
catch (Exception ex)
{
ex.Data.Add("step", step);
ex.Data.Add("Method", "ProcessCardcomTransaction");
LoggerSingleton.Instance.Error("Cardcom", ex);
httpResult = ex.Message;
}
try {
// add a transaction
var transactionId = await transactionsBLL.Create(transaction);
if (transactionId <= 0)
{
throw new Exception($"Error while trying to save an incoming transaction ({transaction.Code})");
}
}
catch (Exception ex)
{
ex.Data.Add("Action", "CreateTransaction");
ex.Data.Add("Method", "ProcessCardcomTransaction");
LoggerSingleton.Instance.Error("Cardcom", ex);
httpResult = ex.Message;
}
Response.StatusCode = httpResult == "OK" ? (int)HttpStatusCode.OK : (int)HttpStatusCode.InternalServerError;
return(httpResult);
}
public async Task <ActionResult> AskTransaction(int id)
{
// Find the requested service
Service service = await db.Services.Include(s => s.Supplier).Where(x => x.Id == id).FirstOrDefaultAsync();
// If this action is not already requested and not responded
if (!db.Transactions.Where(x => x.Service.Id == id && x.Sender_Id == user.Id && x.Status == 0).Any())
{
if (service != null)
{
// To be able to request a transaction the user must have enough credits to cover
// the cost of all pending requests plus this one.
decimal?pendingRequestsValue = db.Transactions.Where(t => t.Sender_Id == user.Id && (t.Status == Transaction.TransactionStatus.Accepted || t.Status == Transaction.TransactionStatus.New)).Sum(t => (decimal?)t.CreditValue);
if (pendingRequestsValue == null)
{
pendingRequestsValue = 0;
}
bool HasEnoughCredits = (user.CreditsOwned - pendingRequestsValue - service.CreditWorth > 0);
if (HasEnoughCredits)
{
var newTransaction = new Entities.Transaction
{
Status = 0,
Sender_Id = User.Identity.GetUserId(),
Service_Id = id,
CreditValue = service.CreditWorth
};
db.Transactions.Add(newTransaction);
db.SaveChanges();
// Send a message to Provider
Message newMessage = new Message()
{
SenderID = User.Identity.GetUserId(),
ReceiverID = service.Supplier.Id,
TransactionId = newTransaction.Id,
ParentMessageID = null,
SentDate = DateTimeOffset.Now,
ReceiverStatus = MessageStatus.Available,
SenderStatus = MessageStatus.Available,
Subject = "New Request",
Content = $"You have a new request for your service \"{service.Title}\"."
};
db.Messages.Add(newMessage);
db.SaveChanges();
}
else
{
return(RedirectToAction("Error", "Mistakes", new { mistake = $"You do not have enough credits to ask for this service! You own {user.CreditsOwned} credits, the sum of the pending requests you've asked for is {pendingRequestsValue} credits, so your available credits are {user.CreditsOwned - pendingRequestsValue}. This service is worth {service.CreditWorth} credits." }));
}
}
}
else
{
return(RedirectToAction("Error", "Mistakes", routeValues: new { mistake = "You have already asked for that service" }));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult <IEnumerable <ExpenseAccount> > > Get()
{
List <Entities.Account> accountEntities = await m_dbContext.Accounts.ToListAsync();
Dictionary <int, Entities.Account> accountEntitiesById = accountEntities.ToDictionary(a => a.AccountId, a => a);
List <Entities.AccountRelationship> accountRelationships = await m_dbContext.AccountRelationships
.ToListAsync();
List <Entities.AccountRelationship> prepaymentExpenseRelationships = accountRelationships
.Where(ar => ar.Type == AccountRelationshipType.PrepaymentToExpense)
.ToList();
Dictionary <int, int> expenseAccountIdByPrepaymentAccountId =
prepaymentExpenseRelationships.ToDictionary(p => p.SourceAccountId, p => p.DestinationAccountId);
List <Entities.AccountRelationship> physicalToLogicalRelationships = accountRelationships
.Where(ar => ar.Type == AccountRelationshipType.PhysicalToLogical)
.ToList();
Dictionary <int, int> physicalAccountIdByLogicalAccountId =
physicalToLogicalRelationships.ToDictionary(p => p.DestinationAccountId, p => p.SourceAccountId);
// cache all prepayment transactions that were credit card payoff transactions
List <Entities.TransactionRelationship> creditCardPaymentRelationships = await m_dbContext.TransactionRelationships
.Where(tr => tr.Type == TransactionRelationshipType.CreditCardPayment)
.ToListAsync();
Dictionary <int, int> expenseTransactionIdsByPrepaymentTransactionId =
creditCardPaymentRelationships.ToDictionary(p => p.DestinationTransactionId, p => p.SourceTransactionId);
var interestingAccountIds = new List <int>();
interestingAccountIds.AddRange(expenseAccountIdByPrepaymentAccountId.Keys);
interestingAccountIds.AddRange(expenseAccountIdByPrepaymentAccountId.Values);
List <Entities.Transaction> transactionEntities = await m_dbContext.Transactions
.Include(t => t.CreditAccount)
.Include(t => t.DebitAccount)
.Where(t => interestingAccountIds.Contains(t.CreditAccountId) || interestingAccountIds.Contains(t.DebitAccountId))
.ToListAsync();
var apiResponse = new List <ExpenseAccount>();
foreach (Entities.Account accountEntity in accountEntities.Where(a => expenseAccountIdByPrepaymentAccountId.ContainsKey(a.AccountId)))
{
int prepaymentAccountId = accountEntity.AccountId;
int expenseAccountId = expenseAccountIdByPrepaymentAccountId[prepaymentAccountId];
int physicalAccountId = physicalAccountIdByLogicalAccountId[prepaymentAccountId];
List <Entities.Transaction> prepaymentAccountTransactionEntities = transactionEntities
.Where(t => t.CreditAccountId == prepaymentAccountId || t.DebitAccountId == prepaymentAccountId)
.ToList();
// Process prepayment transactions
var expenseTransactions = new List <ExpenseTransaction>();
foreach (Entities.Transaction accountTransactionEntity in prepaymentAccountTransactionEntities)
{
int id = accountTransactionEntity.TransactionId;
DateTime at = accountTransactionEntity.At;
decimal amount = 0;
int otherAccountId = 0;
if (accountTransactionEntity.DebitAccountId == expenseAccountId &&
accountTransactionEntity.CreditAccountId == prepaymentAccountId)
{
// direct payment from prepayment to expense
otherAccountId = physicalAccountId;
amount = -accountTransactionEntity.Amount;
}
else if (accountTransactionEntity.CreditAccountId == expenseAccountId &&
accountTransactionEntity.DebitAccountId == prepaymentAccountId)
{
// direct payment from expense to prepayment (rare but must be handled)
otherAccountId = physicalAccountId;
amount = accountTransactionEntity.Amount;
}
else if (accountTransactionEntity.DebitAccountId == prepaymentAccountId)
{
// a prepayment account transaction
otherAccountId = accountTransactionEntity.CreditAccountId;
amount = accountTransactionEntity.Amount;
}
else if (accountTransactionEntity.CreditAccountId == prepaymentAccountId)
{
// a prepayment account transaction
otherAccountId = accountTransactionEntity.DebitAccountId;
amount = -accountTransactionEntity.Amount;
}
// lookup matching expense transaction & substitute details (as they are typically more accurate)
if (expenseTransactionIdsByPrepaymentTransactionId.ContainsKey(accountTransactionEntity.TransactionId))
{
Entities.Transaction expenseTransaction = transactionEntities
.Single(e => e.TransactionId == expenseTransactionIdsByPrepaymentTransactionId[accountTransactionEntity.TransactionId]);
if (expenseTransaction.DebitAccountId == expenseAccountId)
{
id = expenseTransaction.TransactionId;
at = expenseTransaction.At;
otherAccountId = expenseTransaction.CreditAccountId;
}
else if (expenseTransaction.CreditAccountId == expenseAccountId)
{
id = expenseTransaction.TransactionId;
at = expenseTransaction.At;
otherAccountId = expenseTransaction.DebitAccountId;
}
else
{
// we should never get here
}
}
expenseTransactions.Add(
new ExpenseTransaction
{
Id = id,
At = at,
Amount = amount,
Balance = -666,// to make it clear this is wrong
OtherAccountName = accountEntitiesById[otherAccountId].Name
}
);
}
// TODO: look for recent expense only transactions
if (expenseTransactions.Count == 0)
{
continue;
}
DateTime lastPrepaymentTransactionAt = expenseTransactions.Max(t => t.At);
List <Entities.Transaction> expenseAccountTransactionEntities = transactionEntities
.Where(t => t.At > lastPrepaymentTransactionAt && (t.CreditAccountId == expenseAccountId || t.DebitAccountId == expenseAccountId))
.ToList();
foreach (Entities.Transaction accountTransactionEntity in expenseAccountTransactionEntities)
{
int id = accountTransactionEntity.TransactionId;
DateTime at = accountTransactionEntity.At;
decimal amount = 0;
int otherAccountId = 0;
if (accountTransactionEntity.DebitAccountId == expenseAccountId)
{
// a prepament account transaction
otherAccountId = accountTransactionEntity.CreditAccountId;
amount = -accountTransactionEntity.Amount;
}
else if (accountTransactionEntity.CreditAccountId == expenseAccountId)
{
// a prepayment account transaction
otherAccountId = accountTransactionEntity.DebitAccountId;
amount = accountTransactionEntity.Amount;
}
expenseTransactions.Add(
new ExpenseTransaction
{
Id = id,
At = at,
Amount = amount,
Balance = -666,// to make it clear this is wrong
OtherAccountName = accountEntitiesById[otherAccountId].Name
}
);
}
decimal balance = 0;
foreach (ExpenseTransaction expenseTransaction in expenseTransactions.OrderBy(t => t.At).ThenBy(t => t.Id))
{
balance += expenseTransaction.Amount;
expenseTransaction.Balance = balance;
}
List <ExpenseTransaction> recentTransactions = expenseTransactions
.Where(et => et.At >= m_minTransactionAt)
.OrderByDescending(t => t.At).ThenByDescending(t => t.Id)
.ToList();
if (balance == 0 && recentTransactions.Count == 0)
{
continue;
}
apiResponse.Add(new ExpenseAccount
{
Id = accountEntity.AccountId,
Name = accountEntity.Name,
Balance = balance,
Transactions = recentTransactions
});
}
return(apiResponse);
}
public void Save(List <ImportProductModel> datas)
{
var mess = datas.Count(x => x.Error != null && x.Error.Length > 0);
if (mess > 0)
{
return;
}
var products = _db.Products.ToList();
var units = _db.Units.ToList();
List <Product> adds = new List <Product>();
List <Product> edits = new List <Product>();
List <ProductHistory> histories = new List <ProductHistory>();
List <TransactionDetail> tranDetails = new List <TransactionDetail>();
Product product;
var options = new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
};
using (var scope = new TransactionScope(TransactionScopeOption.Required, options))
{
// transaction
Entities.Transaction tran = new Entities.Transaction()
{
CreatedAt = DateTime.Now,
CreatedBy = "Administrator",
Type = Constants.PURCHASE,
SuplierId = 0,
IsPayment = FrmImportProduct._dialogModel.IsDebt ? Constants.NOT_PAY : Constants.PAID,
Amount = FrmImportProduct._dialogModel.Total,
Payment = FrmImportProduct._dialogModel.Payment,
PayBack = FrmImportProduct._dialogModel.Payback
};
_db.Transactions.Add(tran);
_db.SaveChanges();
List <Product> discounts;
TransactionDetail tranDetail;
foreach (var elm in datas)
{
discounts = elm.ToDiscount();
// product + history
product = products.FirstOrDefault(x => x.Barcode.Equals(elm.Barcode));
// not exist
if (product == null)
{
var add = elm.ToProduct();
add.CreatedAt = DateTime.Now;
add.CreatedBy = "Administrator";
adds.Add(add);
histories.Add(elm.ToProductHistory());
}
else
{
elm.DumpProduct(ref product);
_db.Entry(product).State = System.Data.Entity.EntityState.Modified;
histories.Add(elm.ToProductHistory(product));
}
// transaction detail
tranDetail = elm.ToTransactionDetail(tran.Id);
// discount
foreach (var discount in discounts)
{
product = products.First(x => x.Barcode.Equals(discount.Barcode));
histories.Add(new ProductHistory()
{
Barcode = discount.Barcode,
QuantityOld = product.Quantity,
QuantityNew = product.Quantity + discount.Quantity
});
if (discount.Barcode.Equals(elm.Barcode))
{
tranDetail.Quantity += discount.Quantity;
}
else
{
tranDetails.Add(new TransactionDetail()
{
Barcode = discount.Barcode,
TracsactionId = tran.Id,
Quantity = discount.Quantity,
IsDiscount = true,
Amount = product.PriceBuy.Value * discount.Quantity,
Unit = product.Unit,
CreatedAt = DateTime.Now,
CreatedBy = "Administrator"
});
}
product.Quantity += discount.Quantity;
product.UpdatedAt = DateTime.Now;
_db.Entry(product).State = System.Data.Entity.EntityState.Modified;
}
tranDetails.Add(tranDetail);
}
// insert
if (adds.Count > 0)
{
_db.Products.AddRange(adds);
}
_db.ProductHistories.AddRange(histories);
_db.TransactionDetails.AddRange(tranDetails);
_db.SaveChanges();
scope.Complete();
MessageUtil.UpdateSuccess();
}
}
public void TestReloadTransaction()
{
const string path = "TestData/TransactionReload.xml";
ILoggerFactory loggerFactory = new LoggerFactory();
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
var accountFactory = new AccountFactory();
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
var accountRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var transaction = new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
Amount = 10m,
DebitAccount = rentPrepaymentAccountEntity,
At = new DateTime(2018, 1, 1, 8, 30, 0)
};
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(accountRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
sqliteMemoryWrapper.DbContext.Transactions.Add(transaction);
sqliteMemoryWrapper.DbContext.SaveChanges();
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Save(path);
}
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Load(path);
List <Entities.Account> accounts = sqliteMemoryWrapper.DbContext.Accounts.ToList();
List <Entities.AccountRelationship> accountRelationships = sqliteMemoryWrapper.DbContext.AccountRelationships.ToList();
List <Entities.Currency> currencies = sqliteMemoryWrapper.DbContext.Currencies.ToList();
List <Entities.Transaction> transactions = sqliteMemoryWrapper.DbContext.Transactions.ToList();
Assert.AreEqual(2, accounts.Count);
Assert.AreEqual(1, accountRelationships.Count);
Assert.AreEqual(1, currencies.Count);
Assert.AreEqual(1, transactions.Count);
Assert.AreEqual(checkingAccountEntity.Name, transactions[0].CreditAccount.Name);
Assert.AreEqual(transaction.Amount, transactions[0].Amount);
Assert.AreEqual(rentPrepaymentAccountEntity.Name, transactions[0].DebitAccount.Name);
Assert.AreEqual(transaction.At, transactions[0].At);
}
}
public void TestGetAllTransactionsFilteredByAccountAndDateRange()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 35, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 9, 45, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 11, 15, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionService = new TransactionService(loggerFactory, sqliteMemoryWrapper.DbContext);
int[] accountIds = new int[1] {
rentPrepaymentAccountEntity.AccountId
};
List <Transaction> transactions = transactionService
.GetAll(
accountIds,
new DateTime(2018, 1, 1, 8, 35, 0),
new DateTime(2018, 1, 1, 10, 0, 0)
)
.ToList();
Assert.AreEqual(2, transactions.Count);
Assert.AreEqual(2, transactions[0].TransactionId);
Assert.AreEqual(checkingAccountEntity.AccountId, transactions[0].CreditAccount.AccountId);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, transactions[0].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[1].Amount, transactions[0].Amount);
Assert.AreEqual(transactionEntities[1].At, transactions[0].At);
Assert.AreEqual(checkingAccountEntity.AccountId, transactions[1].CreditAccount.AccountId);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, transactions[1].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[2].Amount, transactions[1].Amount);
Assert.AreEqual(transactionEntities[2].At, transactions[1].At);
}
}
public void TestGetPendingCreditCardTransactionsOneResult()
{
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account creditCardAccountEntity =
accountFactory.Create(AccountPrefab.CreditCard, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, creditCardAccountEntity);
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var rentPrepaymentToExpenseRelationship = new Entities.AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(rentPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionsToAdd = new Entities.Transaction[4]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 1)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 50m,
At = new DateTime(2018, 1, 1, 8, 30, 2)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 1, 8, 30, 3)
},
new Entities.Transaction
{
CreditAccount = rentPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 1, 8, 30, 4)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionsToAdd);
sqliteMemoryWrapper.DbContext.SaveChanges();
ILoggerFactory loggerFactory = new LoggerFactory();
TransactionService transactionService = new TransactionService(loggerFactory, sqliteMemoryWrapper.DbContext);
List <Payment> pendingPayments =
transactionService.GetPendingCreditCardPayments(creditCardAccountEntity.AccountId).ToList();
Assert.AreEqual(1, pendingPayments.Count);
Assert.AreEqual(creditCardAccountEntity.AccountId, pendingPayments[0].OriginalTransaction.CreditAccount.AccountId);
Assert.AreEqual(rentExpenseAccountEntity.AccountId, pendingPayments[0].OriginalTransaction.DebitAccount.AccountId);
Assert.AreEqual(transactionsToAdd[2].Amount, pendingPayments[0].OriginalTransaction.Amount);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, pendingPayments[0].PaymentTransaction.CreditAccount.AccountId);
Assert.AreEqual(creditCardAccountEntity.AccountId, pendingPayments[0].PaymentTransaction.DebitAccount.AccountId);
Assert.AreEqual(transactionsToAdd[2].Amount, pendingPayments[0].PaymentTransaction.Amount);
}
}
public void TestReconcileBalance()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity = accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity = accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var currencyService = new CurrencyService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var viewModel = new ReconcileBalanceViewModel(
loggerFactory,
accountService,
currencyService,
transactionService,
new Concrete.StubAccountLinkViewModelFactory(),
new Mock <IForeignAmountViewService>().Object,
checkingAccountEntity.AccountId);
viewModel.Balance = 140m;
viewModel.At = new DateTime(2018, 1, 2, 7, 0, 0);
viewModel.OKCommand.Execute(null);
Transaction newTransaction = viewModel.ToTransaction();
Assert.AreEqual(1, viewModel.Accounts.Count);
Assert.AreEqual(40m, newTransaction.Amount);
Assert.AreEqual(incomeAccountEntity.AccountId, newTransaction.CreditAccount.AccountId);
Assert.AreEqual(checkingAccountEntity.AccountId, newTransaction.DebitAccount.AccountId);
Assert.AreEqual(viewModel.At, newTransaction.At);
}
}
public void TestAccountTransactionListViewModelAccountWithLogicalsAndTransactions()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 31, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 8, 32, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
IAccountTransactionItemViewModelFactory accountTransactionViewModelFactory =
new Concrete.StubAccountTransactionItemViewModelFactory();
var viewModel = new AccountTransactionListViewModel(
loggerFactory,
accountService,
transactionService,
accountTransactionViewModelFactory,
new Mock <IDeleteConfirmationViewService>().Object,
new Mock <ITransactionCreateViewService>().Object,
new Mock <ITransactionEditViewService>().Object,
new Mock <IReconcileBalanceViewService>().Object,
checkingAccountEntity.AccountId);
Assert.AreEqual(true, viewModel.HasLogicalAcounts);
Assert.AreEqual(3, viewModel.Transactions.Count);
Assert.AreEqual(100m, viewModel.Transactions[0].Balance);
Assert.AreEqual(100m, viewModel.Transactions[1].Balance);
Assert.AreEqual(100m, viewModel.Transactions[2].Balance);
}
}
public void TestAccountTransactionListViewModelPostDeleteBalanceRefresh()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 31, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 8, 32, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
IAccountTransactionItemViewModelFactory accountTransactionViewModelFactory =
new Concrete.StubAccountTransactionItemViewModelFactory();
// Force transaction deletion to always confirm
var mockDeleteConfirmationViewService = new Mock <IDeleteConfirmationViewService>();
mockDeleteConfirmationViewService
.Setup(s => s.Show(It.IsAny <string>()))
.Returns(true);
var viewModel = new AccountTransactionListViewModel(
loggerFactory,
accountService,
transactionService,
accountTransactionViewModelFactory,
mockDeleteConfirmationViewService.Object,
new Mock <ITransactionCreateViewService>().Object,
new Mock <ITransactionEditViewService>().Object,
new Mock <IReconcileBalanceViewService>().Object,
checkingAccountEntity.AccountId
);
// Delete the first transaction
viewModel.SelectedTransaction = viewModel.Transactions.OrderBy(t => t.At).First();
viewModel.DeleteCommand.Execute(this);
var transactionViewModels = new List <IAccountTransactionItemViewModel>(viewModel.Transactions.OrderBy(t => t.At));
Assert.AreEqual(2, transactionViewModels.Count);
Assert.AreEqual(transactionEntities[1].CreditAccount.AccountId, transactionViewModels[0].CreditAccount.AccountId);
Assert.AreEqual(transactionEntities[1].DebitAccount.AccountId, transactionViewModels[0].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[1].Amount, transactionViewModels[0].Amount);
Assert.AreEqual(transactionEntities[1].At, transactionViewModels[0].At);
Assert.AreEqual(-60m, transactionViewModels[0].Balance);
Assert.AreEqual(transactionEntities[2].CreditAccount.AccountId, transactionViewModels[1].CreditAccount.AccountId);
Assert.AreEqual(transactionEntities[2].DebitAccount.AccountId, transactionViewModels[1].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[2].Amount, transactionViewModels[1].Amount);
Assert.AreEqual(transactionEntities[2].At, transactionViewModels[1].At);
Assert.AreEqual(-70m, transactionViewModels[1].Balance);
}
}
