public IActionResult Create([FromBody] ExpenseInputModel expenseInputModels)
{
try
{
var expenseEntity = new ExpenseEntity();
expenseEntity.Account = expenseInputModels.Account;
expenseEntity.Amount = expenseInputModels.Amount;
expenseEntity.Category = expenseInputModels.Category;
expenseEntity.ColorCode = expenseInputModels.ColorCode;
expenseEntity.Date = expenseInputModels.Date;
expenseEntity.Impulse = expenseInputModels.Impulse;
expenseEntity.Memo = expenseInputModels.Memo;
expenseEntity.Payee = expenseInputModels.Payee;
expenseEntity.Repeat = expenseInputModels.Repeat;
using (ISession session = _inHibernateSession.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(expenseEntity);
transaction.Commit();
}
}
return(new JsonResult(expenseEntity));
}
catch (Exception e)
{
return(new JsonResult(e));
}
}
public async Task <ExpenseEntity> Add(string userId, ExpenseEntity expense)
{
var user = await FetchUser(userId);
user.Expenses.Add(expense);
await _collection.ReplaceOneAsync(eu => eu.Id == user.Id, user).ConfigureAwait(false);
return(expense);
}
public ExpenseModel Convert(ExpenseEntity expense)
{
return(new ExpenseModel()
{
Guid = expense.Guid,
Description = expense.Description,
CreateTime = expense.CreateTime,
Amount = expense.Amount
});
}
public async Task <ExpenseEntity> GetExpenseAsync(int?id)
{
ExpenseEntity expenseEntity = await _dataContext.Expenses
.Include(e => e.ExpenseType)
.Include(e => e.Trip)
.Include(e => e.User)
.FirstOrDefaultAsync(e => e.Id == id);
return(expenseEntity);
}
private void GetShouldReturn(ExpenseEntity entity, string whenId = "")
{
_expenseRepository = new MockExpenseRepositoryBuilder()
.GetAsyncIs(id => id == whenId, entity)
.Build();
_unitOfWork = new MockUnitOfWorkBuilder()
.AddExpenseRepository(_expenseRepository.Object)
.Build();
_handler = new GetExpenseQueryHandler(_unitOfWork.Object, _mapper);
}
private void AddShouldReturn(ExpenseEntity entity)
{
_expenseRepository = new MockExpenseRepositoryBuilder()
.AddAsync(entity)
.Build();
_unitOfWork = new MockUnitOfWorkBuilder()
.AddExpenseRepository(_expenseRepository.Object)
.Build();
_handler = new CreateExpenseCommandHandler(_unitOfWork.Object, _mapper);
}
public CreateExpenseEntryCommandTests()
{
_seededExpenseEntity = TestExpenseSeeder.SeedExpense();
_expenseRepository = new MockExpenseRepositoryBuilder()
.GetAsyncIs(id => id == _seededExpenseEntity.Id, _seededExpenseEntity)
.Build();
_unitOfWork = new MockUnitOfWorkBuilder()
.AddExpenseRepository(_expenseRepository.Object)
.Build();
_handler = new CreateExpenseEntryHandler(_unitOfWork.Object, _mapper);
}
public ExpenseResponse ToExpenseResponse(ExpenseEntity expenseEntity)
{
return(new ExpenseResponse
{
Id = expenseEntity.Id,
Details = expenseEntity.Details,
Date = expenseEntity.Date,
PicturePath = expenseEntity.PicturePath,
Value = expenseEntity.Value,
Type = ToExpenseTypeResponse(expenseEntity.ExpenseType)
});
}
public async Task Add(Expense expense)
{
var entity = new ExpenseEntity
{
Amount = expense.Amount,
CategoryId = expense.Category,
};
_context.Expenses.Add(entity);
await _context.SaveChangesAsync();
expense.Id = entity.Id;
}
public ActionResult Edit([Bind(Include = "ID,ExpenseTypeID,ExpenseEntityName,ExpenseEntityDescription")] ExpenseEntity expenseEntity)
{
string userId = User.Identity.GetUserId();
if (ModelState.IsValid)
{
expenseEntity.UserId = userId;
db.Entry(expenseEntity).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
//--- if the model is not valid, show the same edit form
ViewBag.ExpenseTypeID = new SelectList(db.ExpenseTypes.Where(x => x.UserId == userId), "ID", "Title", expenseEntity.ExpenseTypeID);
return(View(expenseEntity));
}
public static ExpenseEntity ToTableEntity(this Expense model)
{
var expense = new ExpenseEntity
{
PartitionKey = model.UserName.EncodePartitionAndRowKey(),
RowKey = model.Id == null ? null : KeyGenerator.ExpenseEntityRowKey(model.Id),
Approved = model.Approved,
CostCenter = model.CostCenter,
Date = model.Date,
ReimbursementMethod = Enum.GetName(typeof(ReimbursementMethod), model.ReimbursementMethod),
Title = model.Title,
ApproverName = model.ApproverName
};
return(expense);
}
public void deleteRecord(ExpenseEntity expenseEntity)
{
var delete = (from s in db.Expenses
where s.ExpenseId == expenseEntity.ExpenseId
select s).FirstOrDefault();
ReceiptEntity receiptEntity = new ReceiptEntity();
receiptEntity.ReceiptId = Convert.ToInt32(delete.ReceiptId);
var deleteReceipt = (from s in db.Receipts
where s.ReceiptId == receiptEntity.ReceiptId
select s).FirstOrDefault();
db.Receipts.DeleteOnSubmit(deleteReceipt);
db.Expenses.DeleteOnSubmit(delete);
db.SubmitChanges();
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
ExpenseEntity model = await _dataContext.Expenses
.Include(t => t.ExpenseType)
.Include(t => t.Trip)
.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(NotFound());
}
return(View(model));
}
public ActionResult Edit(int?id)
{
string userId = User.Identity.GetUserId();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ExpenseEntity expenseEntity = db.ExpenseEntities.Find(id);
if (expenseEntity == null)
{
return(HttpNotFound());
}
//--- prepare the "select list" of expense types for the "Type" combobox and select the current type
ViewBag.ExpenseTypeID = new SelectList(db.ExpenseTypes.Where(x => x.UserId == userId), "ID", "Title", expenseEntity.ExpenseTypeID);
return(View(expenseEntity));
}
public async Task <IActionResult> DeleteExpense([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ExpenseEntity expenseEntity = await _tripHelper.GetExpenseAsync(id);
if (expenseEntity == null)
{
return(BadRequest("Expense doesn't exist"));
}
_dataContext.Expenses.Remove(expenseEntity);
await _dataContext.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
ExpenseEntity expense = await _dataContext.Expenses.FirstOrDefaultAsync(e => e.Id == id);
if (expense == null)
{
return(NotFound());
}
_dataContext.Expenses.Remove(expense);
await _dataContext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public void editRecord(ExpenseEntity expenseEntity)
{
ReceiptEntity receiptE = new ReceiptEntity();
var update = (from s in db.Expenses
where s.ExpenseId == expenseEntity.ExpenseId
select s).FirstOrDefault();
var query = (from s in db.Receipts
where s.ReceiptId == update.ReceiptId
select s).FirstOrDefault();
receiptE.ReceiptId = query.ReceiptId;
receiptE.Amount = Convert.ToInt64(query.Amount);
receiptE.ReceiptDate = query.ReceiptDate;
receiptE.ReceiptPath = query.ReceiptPath;
receiptE.Comment = query.Comment;
receiptE.CurrencyTypeId = query.CurrencyTypeId;
receiptE.ExpenseTypeId = query.ExpenseTypeId;
expenseEntity.receiptE = receiptE;
}
public async Task <IActionResult> Create(ExpenseViewModel model)
{
if (ModelState.IsValid)
{
string path = string.Empty;
if (model.PictureFile != null)
{
path = await _imageHelper.UploadImageAsync(model.PictureFile, "Expenses");
}
model.Date = DateTime.UtcNow;
ExpenseEntity expense = await _converterHelper.ToAddExpenseEntity(model, path);
_dataContext.Add(expense);
await _dataContext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
model.ExpensesType = _combosHelper.GetComboExpenses();
return(View(model));
}
public async Task <IActionResult> DeleteExpense(int?id)
{
if (id == null)
{
return(NotFound());
}
ExpenseEntity expense = await _dataContext.Expenses
.Include(e => e.Trip)
.FirstOrDefaultAsync(e => e.Id == id);
if (expense == null)
{
return(NotFound());
}
_dataContext.Expenses.Remove(expense);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(TripExpensesDetail)}/{expense.Trip.Id}"));
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ExpenseEntity expenseEntity = db.ExpenseEntities.Find(id);
if (expenseEntity == null)
{
return(HttpNotFound());
}
string expenseEntityName = expenseEntity.ExpenseEntityName;
try
{
db.ExpenseEntities.Remove(expenseEntity);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
string errorMessage = String.Empty;
try
{
string userId = User.Identity.GetUserId();
ViewBag.ExpenseTypeID = new SelectList(db.ExpenseTypes.Where(x => x.UserId == userId), "ID", "Title", expenseEntity.ExpenseTypeID);
}
catch (Exception ex2)
{
ViewBag.Title = $"Delete Expense Entity: (#{id}) : {expenseEntityName}";
ViewData["message"] = ex2.GetBaseException().Message;
ViewData["trace"] = ex.StackTrace;
return(View("ErrorDescr"));
}
ExpenseLog.Utils.ExceptionHandler exceptionHandler = new ExpenseLog.Utils.ExceptionHandler();
this.ModelState.AddModelError("ExpenseEntityDescription", exceptionHandler.GetExceptionMessage(ex));
return(View("Edit", expenseEntity));
}
}
public async Task Edit(string userId, string expenseId, ExpenseEntity expense)
{
if (expense.Id != expenseId)
{
return;
}
var user = await FetchUser(userId);
var oldEntity = user.Expenses.FirstOrDefault(e => e.Id == expenseId);
if (oldEntity == null)
{
return;
}
// TODO: preserve creation date (find a smarter way to do it)
var entity = new ExpenseEntity(expense.Id, expense.Amount, expense.What, expense.Where, expense.When, oldEntity.CreationDate);
user.Expenses.Remove(oldEntity);
user.Expenses.Add(entity);
await _collection.ReplaceOneAsync(eu => eu.Id == user.Id, user);
}
public async Task Should_Add_New_Expense()
{
// Arrange
var expected = new ExpenseEntity(
Guid.NewGuid().ToString(),
123U,
"something",
"somewhere",
DateTime.UtcNow,
DateTime.UtcNow);
// Act
var add = await _repo.Add(_userId, expected);
// Assert
Assert.NotNull(add);
var expenses = await _repo.GetAll(_userId);
var actual = expenses.SingleOrDefault(e => e.Id == expected.Id);
Assert.NotNull(actual);
}
public async Task <IActionResult> EditExpense(ExpenseViewModel model)
{
if (ModelState.IsValid)
{
string path = string.Empty;
if (model.PictureFile != null)
{
path = await _imageHelper.UploadImageAsync(model.PictureFile, "Expenses");
model.PicturePath = path;
}
ExpenseEntity expense = await _converterHelper.ToEditExpenseEntity(model, model.PicturePath);
_dataContext.Update(expense);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(TripExpensesDetail)}/{model.TripId}"));
}
model.ExpensesType = _combosHelper.GetComboExpenses();
return(View(model));
}
public void Added_Expense_Should_Save()
{
var expenseInput = new ExpenseInputModel()
{
Id = 10,
Payee = "Amazon",
Amount = 18.00M,
Category = "Stuff I Forget to Budget For",
Account = "Middleburg",
Date = DateTime.Today,
Repeat = false,
Impulse = true,
Memo = "Dry Erase Paper Sheets",
ColorCode = "Blue"
};
var expenseEntity = new ExpenseEntity()
{
Id = 10,
Payee = "Amazon",
Amount = 18.00M,
Category = "Stuff I Forget to Budget For",
Account = "Middleburg",
Date = DateTime.Today,
Repeat = false,
Impulse = true,
Memo = "Dry Erase Paper Sheets",
ColorCode = "Blue"
};
_session.Setup(x => x.Save(It.IsAny <ExpenseEntity>()))
.Returns(() => expenseEntity);
_sut.Create(expenseInput);
_session.Verify(x => x.Save(It.IsAny <ExpenseEntity>()), Times.Once);
}
public void updateRecord(ExpenseEntity expenseEntity)
{
if (!receipt.HasFile)
{
receiptEntity.ReceiptPath = receiptImage.AlternateText;
}
else
{
receiptEntity.ReceiptPath = receipt.FileName;
}
expenseEntity.ExpenseId = Convert.ToInt32(hdf1.Value);
expenseEntity.UserId = Convert.ToInt32(Session["Id"]);
receiptEntity.ReceiptId = Convert.ToInt32(hdf.Value);
receiptEntity.Amount = Convert.ToInt64(txtAmount.Text);
receiptEntity.ReceiptDate = txtDate.Text;
// receiptEntity.ReceiptPath=receipt.FileName;
receiptEntity.CurrencyTypeId = Convert.ToInt32((dlCurrency.SelectedValue).ToString());
receiptEntity.ExpenseTypeId = Convert.ToInt32((dlExpenseType.SelectedValue).ToString());
receiptEntity.Comment = txtComment.Text;
expenseEntity.receiptE = receiptEntity;
receiptBusiness.updateRecord(expenseEntity);
}
public GetExpenseQueryHandlerTests() : base()
{
_seededEntity = TestExpenseSeeder.SeedExpense();
}
public void WriteValues(ExpenseEntity expense, ExpenseModel model)
{
model.Amount = expense.Amount;
model.Description = expense.Description;
model.CreateTime = expense.CreateTime;
}
public MockExpenseRepositoryBuilder AddAsync(ExpenseEntity returns)
{
_repository.Setup(r => r.AddAsync(It.IsAny <ExpenseEntity>()))
.ReturnsAsync(returns);
return(this);
}
public bool AddExpense([FromBody] ExpenseEntity e)
{
return(db.AddExpense(e));
}
public CreateExpenseCommandHandlerTests() : base()
{
_seededEntity = TestExpenseSeeder.SeedExpense();
}
