コード例 #1
0
        public async Task <IActionResult> Put(int id, [FromBody] DailyExpense value)
        {
            if (value == null)
            {
                return(BadRequest());
            }

            var spentItem = await _context.Wallet.FindAsync(id);

            if (spentItem == null)
            {
                _logger.LogInformation($"Daily Expense for {id} does not exists!!");
                return(NotFound());
            }
            //Assign Values
            // Use AutoMapper if more properties
            spentItem.Amount      = value.Amount;
            spentItem.Description = value.Description;
            spentItem.SpentOn     = value.SpentOn;

            _context.Update(spentItem);
            await SaveAsync();

            return(NoContent());
        }
コード例 #2
0
        public ActionResult EditExpenses(DailyExpense expenses)
        {
            var status = "error";

            try
            {
                if (!Authenticated)
                {
                    status = "SESSION EXPIRED";
                }
                else
                {
                    DailyExpense objexp = db.DailyExpenses.Where(x => x.UID == expenses.UID).FirstOrDefault();

                    objexp.UpdatedOn = DateTime.Now;
                    objexp.UpdatedBy = ActiveUserId;
                    objexp.Date      = expenses.Date;
                    objexp.Amount    = expenses.Amount;
                    objexp.Comments  = expenses.Comments;
                    //db.Entry(size).State = System.Data.Entity.EntityState.Modified;
                    if (db.SaveChanges() > 0)
                    {
                        status = JsonConvert.SerializeObject(objexp);
                    }
                }
            }
            catch (Exception ex)
            {
                ApplicationExceptionLogging(ex.Message, ex.StackTrace, "DailyExpensesController", "EditExpenses");
            }
            return(Content(status));
        }
コード例 #3
0
        public IActionResult Put(int id, [FromBody] DailyExpense value)
        {
            if (value == null)
            {
                return(BadRequest());
            }

            var spentItem = _context.DailyExpenses.Find(id);

            if (spentItem == null)
            {
                //UnComment this for non Serilog Sink to Database
                //_logger.Information($"Daily Expense for {id} does not exists!!");
                _logger.LogInformation($"Daily Expense for {id} does not exists!!");
                return(NotFound());
            }
            //Assign Values
            // Use AutoMapper if more properties
            spentItem.Amount      = value.Amount;
            spentItem.Description = value.Description;
            spentItem.SpentOn     = value.SpentOn;

            _context.Update(spentItem);
            Save();
            return(NoContent());
        }
コード例 #4
0
 private void CheckMovieBudget(DailyExpense expense)
 {
     if (expense.SpentOn == ExpenseType.Movies && expense.Amount > 300)
     {
         ModelState.AddModelError("MovieLimit", $"Max movie expense limit is 300 and your amount is {expense.Amount}");
     }
 }
コード例 #5
0
        public ActionResult AddExpense(DailyExpense dailyexpense)
        {
            var status = "error";

            try
            {
                if (!Authenticated)
                {
                    status = "SESSION EXPIRED";
                }
                else
                {
                    dailyexpense.CreatedOn = DateTime.Now;
                    dailyexpense.CreatedBy = ActiveUserId;
                    dailyexpense.UID       = Guid.NewGuid();
                    dailyexpense.Status    = 1;


                    db.DailyExpenses.Add(dailyexpense);
                    if (db.SaveChanges() > 0)
                    {
                        status = JsonConvert.SerializeObject(dailyexpense);
                    }
                }
            }
            catch (Exception ex)
            {
                ApplicationExceptionLogging(ex.Message, ex.StackTrace, "CategoryController", "AddCategory");
            }

            return(Content(status));
        }
コード例 #6
0
        public ActionResult DeleteConfirmed(int id)
        {
            DailyExpense dailyExpense = db.dailyExpense.Find(id);

            db.dailyExpense.Remove(dailyExpense);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
コード例 #7
0
 private void CheckMovieBudget(DailyExpense expense)
 {
     if (expense.SpentOn == ExpenseType.Movies && expense.Amount > 300)
     {
         //UnComment this for non Serilog Sink to Database
         //_logger.Error("Errorneous input for Movie");
         _logger.LogError("Errorneous input for Movie");
         ModelState.AddModelError("MovieLimit", $"Max movie expense limit is 300 and your amount is {expense.Amount}");
     }
 }
コード例 #8
0
        public ActionResult Edit(DailyExpense objDailyExpenseInfo)
        {
            if (ModelState.IsValid)
            {
                DailyExpenseBLL objDailyExpenseBLL = new DailyExpenseBLL();

                objDailyExpenseBLL.UpdateDailyExpenseInfo(objDailyExpenseInfo);
            }
            return(RedirectToAction("Index", "DailyExpense"));
        }
コード例 #9
0
        public ActionResult Save()
        {
            ExpenseDetailBLL objExpenseDetailBLL = new ExpenseDetailBLL();
            var model = new DailyExpense
            {
                ExpenseDetailInfo = objExpenseDetailBLL.GetAllExpenseTypeInfo()
            };

            return(View(model));
        }
コード例 #10
0
 public ActionResult Edit([Bind(Include = "Id,Day,ItemCategoryId,Amount")] DailyExpense dailyExpense)
 {
     if (ModelState.IsValid)
     {
         db.Entry(dailyExpense).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.ItemCategoryId = new SelectList(db.itemCategory, "Id", "ItemName", dailyExpense.ItemCategoryId);
     return(View(dailyExpense));
 }
コード例 #11
0
        public ActionResult Save(DailyExpense objDailyExpense)
        {
            objDailyExpense.ExpenseDetailId = Convert.ToInt16(Request.Form["ExpenseDetailId"]);

            if (ModelState.IsValid)
            {
                DailyExpenseBLL objDailyExpenseBLL = new DailyExpenseBLL();

                objDailyExpenseBLL.SaveDailyExpenseInfo(objDailyExpense);
            }

            return(RedirectToAction("Index", "DailyExpense"));
        }
コード例 #12
0
        // GET: DailyExpenses/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            DailyExpense dailyExpense = db.dailyExpense.Find(id);

            if (dailyExpense == null)
            {
                return(HttpNotFound());
            }
            return(View(dailyExpense));
        }
コード例 #13
0
        // GET: DailyExpenses/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            DailyExpense dailyExpense = db.dailyExpense.Find(id);

            if (dailyExpense == null)
            {
                return(HttpNotFound());
            }
            ViewBag.ItemCategoryId = new SelectList(db.itemCategory, "Id", "ItemName", dailyExpense.ItemCategoryId);
            return(View(dailyExpense));
        }
コード例 #14
0
        public IActionResult Post([FromBody] DailyExpense value)
        {
            if (value == null)
            {
                throw new WebApiException("Request Object was NULL", HttpStatusCode.BadRequest);
            }
            CheckMovieBudget(value);

            if (!ModelState.IsValid)
            {
                throw new WebApiException($"Max movie expense limit is 300 and your amount is {value.Amount}", HttpStatusCode.BadRequest);
            }
            var newSpentItem = _context.DailyExpenses.Add(value);

            Save();
            return(Ok(newSpentItem.Entity.Id));
        }
コード例 #15
0
        public async Task <IActionResult> Post([FromBody] DailyExpense value)
        {
            if (value == null)
            {
                _logger.LogError("Request Object was NULL");
                return(BadRequest());
            }
            CheckMovieBudget(value);

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var newSpentItem = _context.Wallet.AddAsync(value);

            await SaveAsync();

            return(Ok(newSpentItem.Result.Entity.Id));
        }
コード例 #16
0
        public ActionResult Delete(Guid Id)
        {
            var status = "error";

            try
            {
                if (!Authenticated)
                {
                    status = "SESSION EXPIRED";
                }
                else
                {
                    DailyExpense obj = new DailyExpense();

                    DailyExpense objexp = db.DailyExpenses.Where(x => x.UID == Id).FirstOrDefault();

                    objexp.Status = 2;
                    if (db.SaveChanges() > 0)
                    {
                        var ListRelation = (from s in db.DailyExpenses
                                            where s.Status == 1

                                            select
                                            new
                        {
                            UID = s.UID,
                            Date = s.Date,
                            Amount = s.Amount,
                            Comments = s.Comments,
                        }).ToList();


                        status = JsonConvert.SerializeObject(ListRelation);
                    }
                }
            }
            catch (Exception ex)
            {
                ApplicationExceptionLogging(ex.Message, ex.StackTrace, "DailyExpenseController", "Edit");
            }
            return(Content(status));
        }
コード例 #17
0
        public IActionResult Post([FromBody] DailyExpense value)
        {
            if (value == null)
            {
                _logger.LogError("Request Object was NULL");
                //UnComment this for non Serilog Sink to Database
                //_logger.Error("Request Object was NULL");
                return(BadRequest());
            }
            CheckMovieBudget(value);

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var newSpentItem = _context.DailyExpenses.Add(value);

            Save();
            return(Ok(newSpentItem.Entity.Id));
        }
コード例 #18
0
        public DailyExpense GetDailyExpenseInfo(int id)
        {
            objDataAccess = DataAccess.NewDataAccess();
            objDbCommand  = objDataAccess.GetCommand(true, IsolationLevel.ReadCommitted);
            DbDataReader objDbDataReader = null;

            List <DailyExpense> objDailyExpenseList = new List <DailyExpense>();

            DailyExpense objDailyExpense = new DailyExpense();

            try
            {
                objDbCommand.AddInParameter("DailyExpenseId", id);
                objDbDataReader = objDataAccess.ExecuteReader(objDbCommand, "[dbo].[uspGetDailyExpenseInfo]", CommandType.StoredProcedure);

                if (objDbDataReader.HasRows)
                {
                    while (objDbDataReader.Read())
                    {
                        objDailyExpense = new DailyExpense();
                        this.BuildModelForDailyExpense(objDbDataReader, objDailyExpense);

                        objDailyExpenseList.Add(objDailyExpense);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error : " + ex.Message);
            }
            finally
            {
                if (objDbDataReader != null)
                {
                    objDbDataReader.Close();
                }
                objDataAccess.Dispose(objDbCommand);
            }

            return(objDailyExpense);
        }
コード例 #19
0
        public string UpdateDailyExpenseInfo(DailyExpense objDailyExpenseInfo)
        {
            int noRowCount = 0;

            objDataAccess = DataAccess.NewDataAccess();
            objDbCommand  = objDataAccess.GetCommand(true, IsolationLevel.Serializable);
            objDbCommand.AddInParameter("DailyExpenseId", objDailyExpenseInfo.DailyExpenseId);
            objDbCommand.AddInParameter("ExpenseDetailId", objDailyExpenseInfo.ExpenseDetailId);
            objDbCommand.AddInParameter("TotalAmount", objDailyExpenseInfo.TotalAmount);
            objDbCommand.AddInParameter("PaidAmount", objDailyExpenseInfo.PaidAmount);
            objDbCommand.AddInParameter("DueAmount", objDailyExpenseInfo.DueAmount);
            objDbCommand.AddInParameter("Date", objDailyExpenseInfo.Date);
            objDbCommand.AddInParameter("IsActive", objDailyExpenseInfo.IsActive);
            objDbCommand.AddInParameter("UpdatedBy", SessionUtility.STSessionContainer.UserID);

            try
            {
                noRowCount = objDataAccess.ExecuteNonQuery(objDbCommand, "[dbo].uspUpdateDailyExpense", CommandType.StoredProcedure);

                if (noRowCount > 0)
                {
                    objDbCommand.Transaction.Commit();
                    return("Save Successfully");
                }
                else
                {
                    objDbCommand.Transaction.Rollback();
                    return("Save Failed");
                }
            }
            catch (Exception ex)
            {
                objDbCommand.Transaction.Rollback();
                throw new Exception("Database Error Occured", ex);
            }
            finally
            {
                objDataAccess.Dispose(objDbCommand);
            }
        }
コード例 #20
0
        public List <DailyExpense> GetAllDailyExpenseInfo()
        {
            objDataAccess = DataAccess.NewDataAccess();
            objDbCommand  = objDataAccess.GetCommand(true, IsolationLevel.ReadCommitted);
            DbDataReader        objDbDataReader     = null;
            List <DailyExpense> objDailyExpenseList = new List <DailyExpense>();
            DailyExpense        objDailyExpense;

            try
            {
                //objDbCommand.AddInParameter("CreatedBy", SessionUtility.TBSessionContainer.UserID);
                objDbDataReader = objDataAccess.ExecuteReader(objDbCommand, "[dbo].uspGetDailyExpenseList",
                                                              CommandType.StoredProcedure);

                if (objDbDataReader.HasRows)
                {
                    while (objDbDataReader.Read())
                    {
                        objDailyExpense = new DailyExpense();
                        this.BuildModelForDailyExpense(objDbDataReader, objDailyExpense);
                        objDailyExpenseList.Add(objDailyExpense);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error : " + ex.Message);
            }
            finally
            {
                if (objDbDataReader != null)
                {
                    objDbDataReader.Close();
                }
                objDataAccess.Dispose(objDbCommand);
            }

            return(objDailyExpenseList);
        }
コード例 #21
0
        public IActionResult Put(int id, [FromBody] DailyExpense value)
        {
            if (value == null)
            {
                throw new WebApiException("Request Object was NULL", HttpStatusCode.BadRequest);
            }

            var spentItem = _context.DailyExpenses.Find(id);

            if (spentItem == null)
            {
                throw new WebApiException($"Daily Expense for {id} does not exists!!", HttpStatusCode.NotFound);
            }
            //Assign Values
            // Use AutoMapper if more properties
            spentItem.Amount      = value.Amount;
            spentItem.Description = value.Description;
            spentItem.SpentOn     = value.SpentOn;

            _context.Update(spentItem);
            Save();
            return(NoContent());
        }
コード例 #22
0
        public async Task <dynamic> AddComponentAsync(AddDailyExpense[] addComponents, int instituteId)
        {
            var oldEntries = await iMSDbContext.DailyExpenses.Where(x => x.MessManageId == addComponents[0].MessManageId && x.ExpenseTypeId == addComponents[0].ExpenseTypeId && x.InstituteId == instituteId).ToListAsync();

            iMSDbContext.RemoveRange(oldEntries);
            await iMSDbContext.SaveChangesAsync();

            var results = new List <dynamic>();

            foreach (AddDailyExpense addComponent in addComponents)
            {
                if (!string.IsNullOrEmpty(addComponent.BillNo) && !string.IsNullOrEmpty(addComponent.Particulars) && addComponent.Amount != 0)
                {
                    var dailyExpense = new DailyExpense()
                    {
                        InstituteId   = instituteId,
                        MessManageId  = addComponent.MessManageId,
                        ExpenseTypeId = addComponent.ExpenseTypeId,
                        Amount        = addComponent.Amount,
                        Description   = addComponent.Description,
                        BillNo        = addComponent.BillNo,
                        ProofUrl      = addComponent.ProofUrl,
                        Particulars   = addComponent.Particulars,
                        Date          = addComponent.Date
                    };
                    iMSDbContext.DailyExpenses.Add(dailyExpense);
                    await iMSDbContext.SaveChangesAsync();

                    results.Add(dailyExpense);
                }
                else
                {
                    results.Add(addComponent);
                }
            }
            return(new { HasError = false, Result = results, Message = "Daily Expenses added successfully" });
        }
コード例 #23
0
        public ActionResult DailyExpenseView(DailyExpenseViewModel model, DateTime Day)
        {
            var k     = Day.Month;
            var month = DateTimeFormatInfo.CurrentInfo.GetMonthName(k);

            model.budgetdetail = db.monthlyBudget.Where(b => b.BudgetMonth == month).ToList();
            // model.dailyexpensedetail = db.dailyExpense.Where(b => b.Day.Month == Day.Month).ToList();
            //model.budgetdetail = db.monthlyBudget;
            // model.budgetdetail = db.monthlyBudget.Where(s => s.BudgetMonth == BudgetMonth).ToList() ;
            //model.dailyexpensedetail.Reverse();
            ItemCategory newItem = new ItemCategory();

            newItem = db.itemCategory.FirstOrDefault(x => x.Id == model.ItemCategoryId);
            var           matchcCategory = newItem.CategoryId;
            MonthlyBudget newBudget      = new MonthlyBudget();

            newBudget = db.monthlyBudget.FirstOrDefault(y => y.CategoryId == matchcCategory && y.BudgetMonth == month);
            var s = DateTime.ParseExact(newBudget.BudgetMonth, "MMMM", System.Globalization.CultureInfo.InvariantCulture).Month;

            if (model.Day.Month == s)
            {
                newBudget.ActualAmount += model.Amount;
                newBudget.Difference    = newBudget.BudgetAmount - newBudget.ActualAmount;
            }
            //MonthlyBudget budget1 = db.monthlyBudget.FirstOrDefault(s => s.BudgetMonth.Month == BudgetMonth.Month);
            //model.dailyexpensedetail = db.dailyExpense;
            ////model.dailyexpensedetail.Reverse();
            //model.budgetdetail = db.monthlyBudget;
            //ItemCategory newItem = new ItemCategory();
            //newItem = db.itemCategory.FirstOrDefault(x => x.Id == model.ItemCategoryId);
            //var matchcCategory = newItem.CategoryId;
            //MonthlyBudget newBudget = new MonthlyBudget();
            //newBudget = db.monthlyBudget.FirstOrDefault(y => y.CategoryId == matchcCategory);
            //if (model.Day.Month == newBudget.BudgetMonth.Month)
            //{
            //    newBudget.ActualAmount += model.Amount;
            //    newBudget.Difference = newBudget.BudgetAmount - newBudget.ActualAmount;
            //}
            Category newCategory      = new Category();
            var      categoryNameList = db.category.Select(a => a).ToList();

            foreach (var item in categoryNameList)
            {
                var categoryName = db.category.FirstOrDefault(z => z.Id == matchcCategory);
                model.CategoryName = categoryName.CategoryName;
            }
            model.BudgetAmount = newBudget.BudgetAmount;
            model.ActualAmount = newBudget.ActualAmount;
            // model.Difference = newBudget.Difference;
            model.BudgetMonth = newBudget.BudgetMonth;


            var budgetList = db.monthlyBudget.Select(b => b).ToList();

            foreach (var item in budgetList)
            {
                item.Difference  = item.BudgetAmount - item.ActualAmount;
                model.Difference = item.Difference;
            }
            var budgettal1 = db.monthlyBudget.Where(a => a.BudgetMonth == month).Select(l => l.BudgetAmount).ToList();

            // var budgetall = db.monthlyBudget.Select(a => a.BudgetAmount).ToList();
            for (var i = 0; i < budgettal1.Count; i++)
            {
                model.TotalBudget += budgettal1[i];
            }

            var newExpense = new DailyExpense
            {
                Day            = model.Day,
                ItemCategoryId = model.ItemCategoryId,
                Amount         = model.Amount
            };

            db.dailyExpense.Add(newExpense);
            db.SaveChanges();

            var budgetall1 = db.monthlyBudget.Where(a => a.BudgetMonth == month).Select(a => a.ActualAmount).ToList();

            for (var i = 0; i < budgetall1.Count; i++)
            {
                model.TotalActual += budgetall1[i];
            }

            model.TotalDifference = model.TotalBudget - model.TotalActual;

            model.dailyexpensedetail = db.dailyExpense.Where(b => b.Day.Month == Day.Month).ToList();

            ModelState.Clear();
            ViewBag.ItemCategoryId = new SelectList(db.itemCategory, "Id", "ItemName", model.ItemCategoryId);
            return(View(model));
        }
コード例 #24
0
        public IHttpActionResult AddAdditionAmount(AdditionalExpenseRequest additionalExpenseRequest)
        {
            if (ModelState.IsValid)
            {
                int currentWeek  = HelperFunctions.HelperFunctions.CurrentWeekNumber;
                int currentMonth = DateTime.UtcNow.Month;
                int currentYear  = DateTime.UtcNow.Year;
                int userDataid   = additionalExpenseRequest.UserDataID;
                int toCategoryID = db.Categories.Where(e => e.CategoryName.Equals(additionalExpenseRequest.ToCategory)).FirstOrDefault().CategoryID;
                if (additionalExpenseRequest.IsFromCategory)
                {
                    int fromCategoryID = db.Categories.Where(e => e.CategoryName.Equals(additionalExpenseRequest.FromCategory)).FirstOrDefault().CategoryID;

                    #region subtract_amount_from selected category

                    // Create a new entry for DailyExpense
                    DailyExpense dailyExpense = new DailyExpense();
                    dailyExpense.UserDataID   = userDataid;
                    dailyExpense.CategoryID   = fromCategoryID;
                    dailyExpense.Amount       = additionalExpenseRequest.AmountToAdd;
                    dailyExpense.CurrentWeek  = currentWeek;
                    dailyExpense.CurrentMonth = currentMonth;
                    dailyExpense.CurrentYear  = currentYear;
                    dailyExpense.DateCreated  = DateTime.UtcNow;
                    dailyExpense.DateModified  = DateTime.UtcNow;

                    // Update WeeklySaving - Subtract the daily expense amount from the total amount for that category

                    WeeklySaving weeklySavingfromCategory = db.WeeklySavings.Where(e =>
                                                                                   e.UserDataID == userDataid &&
                                                                                   e.CategoryID == fromCategoryID &&
                                                                                   e.CurrentMonth == currentMonth &&
                                                                                   e.CurrentYear == currentYear &&
                                                                                   e.CurrentWeek == currentWeek).FirstOrDefault();

                    if (weeklySavingfromCategory != null)
                    {
                        weeklySavingfromCategory.Amount -= additionalExpenseRequest.AmountToAdd;
                        if (this.WeeklyExpenseForUserExists(userDataid, toCategoryID))
                        {
                            WeeklyExpenseDetail weeklyExpenseDetail = db.WeeklyExpenseDetails.Where(e =>
                                                                                                    e.UserDataID == userDataid &&
                                                                                                    e.CategoryID == fromCategoryID).FirstOrDefault();

                            if (weeklyExpenseDetail != null)
                            {
                                // Update WeeklyExpenseDetails with new reset values
                                weeklyExpenseDetail.Amount         -= additionalExpenseRequest.AmountToAdd;
                                weeklyExpenseDetail.DateModified     = DateTime.UtcNow;
                                db.Entry(weeklyExpenseDetail).State = EntityState.Modified;
                            }
                            else
                            {
                                return(BadRequest());
                            }
                        }
                    }
                    else
                    {
                        return(BadRequest());
                    }

                    #endregion
                }

                #region add amount to requested category

                if (this.WeeklyExpenseForUserExists(userDataid, toCategoryID))
                {
                    WeeklyExpenseDetail weeklyExpenseDetail = db.WeeklyExpenseDetails.Where(e =>
                                                                                            e.UserDataID == userDataid &&
                                                                                            e.CategoryID == toCategoryID).FirstOrDefault();

                    if (weeklyExpenseDetail != null)
                    {
                        // Update WeeklyExpenseDetails with new reset values
                        weeklyExpenseDetail.Amount         += additionalExpenseRequest.AmountToAdd;
                        weeklyExpenseDetail.DateModified     = DateTime.UtcNow;
                        db.Entry(weeklyExpenseDetail).State = EntityState.Modified;

                        // Check WeeklySavngs exits
                        WeeklySaving weeklySavingsToUpdate = db.WeeklySavings.Where(e =>
                                                                                    e.UserDataID == userDataid &&
                                                                                    e.CategoryID == toCategoryID).FirstOrDefault();
                        if (weeklySavingsToUpdate != null)
                        {
                            weeklySavingsToUpdate.Amount         += additionalExpenseRequest.AmountToAdd;
                            weeklyExpenseDetail.DateModified       = DateTime.UtcNow;
                            db.Entry(weeklySavingsToUpdate).State = EntityState.Modified;
                            try
                            {
                                db.SaveChanges();
                                return(Ok(true));
                            }
                            catch (DbUpdateConcurrencyException)
                            {
                                throw;
                            }
                        }
                        else
                        {
                            return(BadRequest());
                        }
                    }
                    else
                    {
                        return(BadRequest());
                    }
                }
                else
                {
                    return(BadRequest());
                }

                #endregion
            }
            else
            {
                return(BadRequest());
            }
        }
コード例 #25
0
        private void BuildModelForDailyExpense(DbDataReader objDataReader, DailyExpense objDailyExpense)
        {
            DataTable objDataTable = objDataReader.GetSchemaTable();

            foreach (DataRow dr in objDataTable.Rows)
            {
                String column = dr.ItemArray[0].ToString();
                switch (column)
                {
                case "DailyExpenseId":
                    if (!Convert.IsDBNull(objDataReader["DailyExpenseId"]))
                    {
                        objDailyExpense.DailyExpenseId = Convert.ToInt32(objDataReader["DailyExpenseId"]);
                    }
                    break;

                case "ExpenseDetailId":
                    if (!Convert.IsDBNull(objDataReader["ExpenseDetailId"]))
                    {
                        objDailyExpense.ExpenseDetailId = Convert.ToInt16(objDataReader["ExpenseDetailId"].ToString());
                    }
                    break;

                case "ExpenseType":
                    if (!Convert.IsDBNull(objDataReader["ExpenseType"]))
                    {
                        objDailyExpense.ExpenseType = objDataReader["ExpenseType"].ToString();
                    }
                    break;

                case "TotalAmount":
                    if (!Convert.IsDBNull(objDataReader["TotalAmount"]))
                    {
                        objDailyExpense.TotalAmount = Convert.ToDouble(objDataReader["TotalAmount"].ToString());
                    }
                    break;

                case "PaidAmount":
                    if (!Convert.IsDBNull(objDataReader["PaidAmount"]))
                    {
                        objDailyExpense.PaidAmount = Convert.ToDouble(objDataReader["PaidAmount"].ToString());
                    }
                    break;

                case "DueAmount":
                    if (!Convert.IsDBNull(objDataReader["DueAmount"]))
                    {
                        objDailyExpense.DueAmount = Convert.ToDouble(objDataReader["DueAmount"].ToString());
                    }
                    break;

                case "Date":
                    if (!Convert.IsDBNull(objDataReader["Date"]))
                    {
                        objDailyExpense.Date = Convert.ToDateTime(objDataReader["Date"].ToString());
                    }
                    break;

                case "IsActive":
                    if (!Convert.IsDBNull(objDataReader["IsActive"]))
                    {
                        objDailyExpense.IsActive = Convert.ToBoolean(objDataReader["IsActive"].ToString());
                    }
                    break;

                case "UserStatus":
                    if (!Convert.IsDBNull(objDataReader["UserStatus"]))
                    {
                        objDailyExpense.UserStatus = objDataReader["UserStatus"].ToString();
                    }
                    break;

                case "CreatedBy":
                    if (!Convert.IsDBNull(objDataReader["CreatedBy"]))
                    {
                        objDailyExpense.CreatedBy = Convert.ToInt16(objDataReader["CreatedBy"]);
                    }
                    break;

                case "CreatedDate":
                    if (!Convert.IsDBNull(objDataReader["CreatedDate"]))
                    {
                        objDailyExpense.CreatedDate = Convert.ToDateTime(objDataReader["CreatedDate"].ToString());
                    }
                    break;

                case "UpdatedBy":
                    if (!Convert.IsDBNull(objDataReader["UpdatedBy"]))
                    {
                        objDailyExpense.UpdatedBy = Convert.ToInt16(objDataReader["UpdatedBy"].ToString());
                    }
                    break;

                case "UpdatedDate":
                    if (!Convert.IsDBNull(objDataReader["UpdatedDate"]))
                    {
                        objDailyExpense.UpdatedDate = Convert.ToDateTime(objDataReader["UpdatedDate"].ToString());
                    }
                    break;

                case "SortedBy":
                    if (!Convert.IsDBNull(objDataReader["SortedBy"]))
                    {
                        objDailyExpense.SortedBy = Convert.ToByte(objDataReader["SortedBy"].ToString());
                    }
                    break;

                case "Remarks":
                    if (!Convert.IsDBNull(objDataReader["Remarks"]))
                    {
                        objDailyExpense.Remarks = objDataReader["Remarks"].ToString();
                    }
                    break;

                default:
                    break;
                }
            }
        }
コード例 #26
0
 public bool AddDailyExpense(DailyExpense de)
 {
     return(db.AddDailyExpense(de));
 }
コード例 #27
0
        public IHttpActionResult AddUserDailyExpense(AddExpense addExpenseModel)
        {
            DailyExpense dailyExpense = new DailyExpense();

            // Fetch category id from category name
            int categoryID = db.Categories.Where(e => e.CategoryName.Equals(addExpenseModel.Category)).FirstOrDefault().CategoryID;

            int week  = HelperFunctions.HelperFunctions.CurrentWeekNumber;
            int month = DateTime.UtcNow.Month;
            int year  = DateTime.UtcNow.Year;

            // Create a new entry for DailyExpense
            dailyExpense.UserDataID   = addExpenseModel.UserDataID;
            dailyExpense.CategoryID   = categoryID;
            dailyExpense.Amount       = addExpenseModel.Amount;
            dailyExpense.CurrentWeek  = week;
            dailyExpense.CurrentMonth = month;
            dailyExpense.CurrentYear  = year;
            dailyExpense.DateCreated  = DateTime.UtcNow;
            dailyExpense.DateModified  = DateTime.UtcNow;

            // Update WeeklySaving - Subtract the daily expense amount from the total amount for that category

            WeeklySaving weeklySaving = db.WeeklySavings.Where(e =>
                                                               e.UserDataID == addExpenseModel.UserDataID &&
                                                               e.CategoryID == categoryID &&
                                                               e.CurrentMonth == month &&
                                                               e.CurrentYear == year &&
                                                               e.CurrentWeek == week).FirstOrDefault();

            if (weeklySaving != null && weeklySaving.Amount != 0.00m && weeklySaving.Amount >= addExpenseModel.Amount)
            {
                weeklySaving.Amount -= addExpenseModel.Amount;
            }
            else
            {
                return(BadRequest());
            }

            if (ModelState.IsValid)
            {
                DailyExpenseReturnModel dailyExpenseReturnModel = new DailyExpenseReturnModel();

                // Saves data in DB
                db.Entry(weeklySaving).State = EntityState.Modified;
                _ = db.DailyExpenses.Add(dailyExpense);
                db.SaveChanges();
                dailyExpenseReturnModel.isDatabaseUpdated = true;


                // Verifies if weekly limit is reached

                WeeklyExpenseDetail weeklyExpenseDetail = db.WeeklyExpenseDetails.Where(e =>
                                                                                        e.UserDataID == addExpenseModel.UserDataID &&
                                                                                        e.CategoryID == categoryID).FirstOrDefault();
                if (this.VerifyThresholdNotReached(weeklyExpenseDetail.Amount, weeklySaving.Amount))
                {
                    dailyExpenseReturnModel.hasThresholdReached = false;
                }
                else
                {
                    dailyExpenseReturnModel.hasThresholdReached = true;
                }

                return(Ok(dailyExpenseReturnModel));
            }
            else
            {
                return(BadRequest());
            }
        }