Esempio n. 1
0
        public ActionResult Details(long id)
        {
            ExpenseItem   expenseItem   = _expenseItemBll.FindExpenseItem(id);
            ExpenseItemVM expenseItemVM = Mapper.Map <ExpenseItemVM>(expenseItem);

            return(PartialView("_Details", expenseItemVM));
        }
Esempio n. 2
0
        public bool IsExpenseItemSaved(ExpenseItemVM itemVm)
        {
            ExpenseItem item = new ExpenseItem()
            {
                Name        = itemVm.Name,
                Code        = itemVm.Code,
                Description = itemVm.Description,
                Date        = itemVm.Date,
                CategoryId  = itemVm.CategoryId
            };

            dbContext.ExpenseItems.Add(item);
            var isAdded = dbContext.SaveChanges();

            if (isAdded > 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }

            return(false);
        }
        public void ExpenseItemCreate()
        {
            var item = new ExpenseItemVM()
            {
                Amount = 23, GroupId = 1, UserId = 1
            };
            var result = (RedirectToRouteResult)_SystemUnderTest.CreateExpense(item);

            Assert.AreEqual(true, _SystemUnderTest.ModelState.IsValid);
            _expenseItemServiceMock.Verify(m => m.Create(It.IsAny <ExpenseItem>()), Times.Once);
        }
Esempio n. 4
0
        public ActionResult AddExpense(int GroupId)
        {
            var viewModel = new ExpenseItemVM
            {
                GroupId   = GroupId,
                GroupName = _groupService.GetById(GroupId).Name,
                UserList  = GetAllUsers()
            };

            return(View(viewModel));
        }
        public ActionResult Edit(ExpenseItemVM itemVm)
        {
            if (ModelState.IsValid)
            {
                if (expenseItemDa.IsExpenseItemUpdated(itemVm))
                {
                    return(RedirectToAction("Index"));
                }
            }

            return(View(itemVm));
        }
Esempio n. 6
0
        public ActionResult Edit(ExpenseItemVM expenseItemVm)
        {
            ExpenseItem expenseitem = Mapper.Map <ExpenseItem>(expenseItemVm);

            if (ModelState.IsValid)
            {
                if (_expenseItemBll.IsExpenseItemUpdated(expenseitem))
                {
                    return(RedirectToAction("Index"));
                }
            }

            return(View(expenseItemVm));
        }
        public ActionResult Create(ExpenseItemVM itemVm)
        {
            itemVm.Date = DateTime.Now;

            if (ModelState.IsValid)
            {
                if (expenseItemDa.IsExpenseItemSaved(itemVm))
                {
                    return(RedirectToAction("Index"));
                }
            }

            ModelVm.SelectList = expenseItemDa.GetExpenseItemSelectList();
            return(View(ModelVm));
        }
        public void InvalidExpenseCreate()
        {
            var item = new ExpenseItemVM()
            {
                Amount = 23, GroupId = 1
            };

            _SystemUnderTest.ModelState.AddModelError("Error", "No user selected");

            var result = (ViewResult)_SystemUnderTest.CreateExpense(item);

            Assert.AreEqual(false, _SystemUnderTest.ModelState.IsValid);
            _expenseItemServiceMock.Verify(m => m.Create(It.IsAny <ExpenseItem>()), Times.Never);
            Assert.AreEqual("AddExpense", result.ViewName);
        }
Esempio n. 9
0
        public ActionResult Create(ExpenseItemVM expenseItemVM)
        {
            expenseItemVM.Date = DateTime.Now;

            ExpenseItem expenseItem = Mapper.Map <ExpenseItem>(expenseItemVM);

            if (ModelState.IsValid)
            {
                if (_expenseItemBll.IsExpenseItemSaved(expenseItem))
                {
                    return(RedirectToAction("Index"));
                }
            }

            ModelVm.SelectList = _expenseItemBll.GetExpenseItemSelectList();
            return(View(ModelVm));
        }
        public ActionResult Edit(long?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            ModelVm = expenseItemDa.FindExpenseItem(id);

            if (ModelVm == null)
            {
                return(HttpNotFound());
            }

            ModelVm.SelectList = expenseItemDa.GetExpenseItemSelectList();
            return(View(ModelVm));
        }
Esempio n. 11
0
        public ActionResult Edit(long?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            expenseItemEn = _expenseItemBll.FindExpenseItem(id);
            ExpenseItemVM expenseItemVm = Mapper.Map <ExpenseItemVM>(expenseItemEn);

            if (expenseItemVm == null)
            {
                return(HttpNotFound());
            }

            expenseItemVm.SelectList = _expenseItemBll.GetExpenseItemSelectList();
            return(View(expenseItemVm));
        }
Esempio n. 12
0
        public ActionResult CreateExpense(ExpenseItemVM data)
        {
            if (!ModelState.IsValid)
            {
                return(View("AddExpense", data));
            }

            var expenseItem = new ExpenseItem
            {
                Amount         = data.Amount,
                UserId         = data.UserId,
                ExpenseGroupId = data.GroupId
            };

            _expenseItemService.Create(expenseItem);

            return(RedirectToAction("Details", new { GroupId = data.GroupId }));
        }
        public bool IsExpenseItemUpdated(ExpenseItemVM itemVm)
        {
            ExpenseItem item = new ExpenseItem()
            {
                Id          = itemVm.Id,
                Name        = itemVm.Name,
                PreCode     = itemVm.PreCode,
                Code        = itemVm.Code,
                Description = itemVm.Description,
                Date        = itemVm.Date,
                CategoryId  = itemVm.CategoryId
            };

            dbContext.Entry(item).State = EntityState.Modified;
            var isUpdated = dbContext.SaveChanges() > 0;

            return(isUpdated);
        }
        public ExpenseItemVM FindExpenseItem(long?id)
        {
            var           item         = dbContext.ExpenseItems.Find(id);
            var           itemCategory = dbContext.ExpenseCategories.Find(item.CategoryId);
            ExpenseItemVM itemVm       = null;

            if (item != null)
            {
                itemVm = new ExpenseItemVM()
                {
                    Name        = item.Name,
                    PreCode     = item.PreCode,
                    Code        = item.Code,
                    Description = item.Description,
                    Date        = item.Date,
                    CategoryId  = item.CategoryId,
                    Category    = itemCategory
                };
            }

            return(itemVm);
        }
        public ActionResult Details(long id)
        {
            ExpenseItemVM itemVm = expenseItemDa.FindExpenseItem(id);

            return(PartialView("_Details", itemVm));
        }