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(); }