internal List <MonthlyIncome> GetMonthlyIncomes()
{
List <MonthlyIncome> itemsChart = new List <MonthlyIncome>();
var groupedIncomings = (from i in Incomings
where i.Category != null && i.Category.Name.Equals("Performance")
group i by new { month = i.Date.Month, year = i.Date.Year } into d
select new
{
dt = string.Format("{0}/{1}", d.Key.month, d.Key.year),
count = d.Count()
}).OrderByDescending(g => g.dt);
foreach (var item in groupedIncomings)
{
var ic = itemsChart.Where(i => i.Date.Equals(DateTime.Parse("01/" + item.dt))).FirstOrDefault();
if (ic == null)
{
ic = new MonthlyIncome(item.dt);
itemsChart.Add(ic);
}
ic.SetIncoming(Incomings.Where(i => i.Date.Month.Equals(ic.Date.Month) &&
i.Date.Year.Equals(ic.Date.Year) &&
i.Category != null &&
i.Category.Name.Equals("Performance")).Sum(i => i.Value));
}
return(itemsChart.OrderByDescending(i => i.Date).ToList());
}
public async Task ExpenditurePostTest_InvalidModelState()
{
string id = Guid.NewGuid().ToString();
this._controller.RouteData.Values.Add("id", id);
this._controller.ModelState.AddModelError("testing", "testing");
this._portalSettings.Features.EnablePartialSave = true;
ExpendituresVm vm = new ExpendituresVm();
IncomeAndExpenditure iAndE = new IncomeAndExpenditure();
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm();
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings();
MonthlyOutgoingsVm monthlyOutgoingsVm = new MonthlyOutgoingsVm();
this._sessionState.Setup(x => x.CheckSessionStatus(id));
this._sessionState.Setup(x => x.GetIncomeAndExpenditure(Guid.Parse(id))).Returns(iAndE);
this._mapper.Setup(x => x.Map(vm, iAndE)).Returns(iAndE);
this._sessionState.Setup(x => x.SaveIncomeAndExpenditure(iAndE, Guid.Parse(id)));
this._calculatorService.Setup(x => x.CalculateMonthlyIncome(iAndE)).Returns(monthlyIncome);
this._calculatorService.Setup(x => x.CalculateMonthlyOutgoings(iAndE)).Returns(monthlyOutgoings);
this._mapper.Setup(x => x.Map <MonthlyIncome, MonthlyIncomeVm>(monthlyIncome))
.Returns(monthlyIncomeVm);
this._mapper.Setup(x => x.Map <MonthlyOutgoings, MonthlyOutgoingsVm>(monthlyOutgoings))
.Returns(monthlyOutgoingsVm);
ViewResult result = (ViewResult)await this._controller.ExpenditurePost(vm, "testing");
Assert.AreEqual("Expenditure", result.ViewName);
Assert.AreEqual(vm, result.Model);
Assert.AreEqual(vm.IncomeVmSummary, monthlyIncomeVm);
Assert.AreEqual(vm.OutgoingsVmSummary, monthlyOutgoingsVm);
Assert.IsTrue(vm.EnabledPartialSave);
}
public async Task <MonthlyIncome> GetMonthlyIncomeAsync(MonthlyIncome monthlyIncome)
{
using (ParkingLotManagementContext context = new ParkingLotManagementContext())
{
return(await context.MonthlyIncome.FindAsync(monthlyIncome.ID));
}
}
public index()
{
InitializeComponent();
userid = Form1.userid;
connectionString = Form1.connectionString;
string sql = "SELECT FNAME,LNAME FROM DETAIL WHERE USERID=" + userid + "";
OracleConnection con = new OracleConnection(connectionString);
con.Open();
OracleDataAdapter adt = new OracleDataAdapter(sql, con);
DataTable dt = new DataTable();
adt.Fill(dt);
string fname = dt.Rows[0][0].ToString(), lname = dt.Rows[0][1].ToString();
label2.Text = fname + " " + lname;
con.Close();
string month = DateTime.Today.ToString("MMMM-yyyy");
label6.Text = month;
income_expense_calc();
label7.Text = "Rs " + MonthlyIncome.ToString();
label8.Text = "Rs " + MonthlyExpense.ToString();
label9.Text = "Rs " + SpendingLimit.ToString();
if (SpendingLimit < 0)
{
MessageBox.Show("You are in Debt.\nKindly manage funds properly", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private BudgetSummary CreateBudgetSummary(MonthlyIncome monthlyIncome, MonthlyOutgoings monthlyExpenses, decimal disosableIncome, IncomeAndExpenditure iAndE, bool anonUser)
{
var budgetSummary = new BudgetSummary();
budgetSummary.IncomeTotal = monthlyIncome.Total;
budgetSummary.Salary = monthlyIncome.Salary;
budgetSummary.Benefits = monthlyIncome.Benefits;
budgetSummary.Pension = monthlyIncome.Pension;
budgetSummary.Other = monthlyIncome.Other;
budgetSummary.TotalExpenditure = monthlyExpenses.Total;
budgetSummary.HouseholdBills = monthlyExpenses.HouseholdBills;
budgetSummary.Expenditure = monthlyExpenses.Expenditures;
budgetSummary.DisposableIncome = disosableIncome;
budgetSummary.Frequency = "monthly";
budgetSummary.AnonUser = anonUser;
if (iAndE != null && (iAndE.RentalArrears > 0 ||
iAndE.CCJsArrears > 0 ||
iAndE.ChildMaintenanceArrears > 0 ||
iAndE.CouncilTaxArrears > 0 ||
iAndE.CourtFinesArrears > 0 ||
iAndE.ElectricityArrears > 0 ||
iAndE.GasArrears > 0 ||
iAndE.MortgageArrears > 0 ||
iAndE.OtherUtilitiesArrears > 0 ||
iAndE.RentArrears > 0 ||
iAndE.SecuredloansArrears > 0 ||
iAndE.TvLicenceArrears > 0 ||
iAndE.WaterArrears > 0))
{
budgetSummary.PriorityBillsInArrears = true;
}
return(budgetSummary);
}
public void CalculateMonthlyIncomeTest()
{
IncomeAndExpenditure iAndE = new IncomeAndExpenditure()
{
Salary = 2500,
SalaryFrequency = "monthly",
BenefitsTotal = 250,
BenefitsTotalFrequency = "monthly",
Pension = 100,
PensionFrequency = "fortnightly",
OtherIncome = 1000,
OtherincomeFrequency = "annually"
};
MonthlyIncome expected = new MonthlyIncome()
{
Salary = 2500,
Benefits = 250,
Other = 83.33M,
Pension = 217,
Total = 3050.33M
};
MonthlyIncome result = this._calculatorService.CalculateMonthlyIncome(iAndE);
Assert.IsTrue(Utilities.DeepCompare(expected, result));
}
static void Main(string[] args)
{
// Object Structure
var person = new Person();
person.Assets.Add(new BankAccount {
Amount = 1000, MonthlyInterestRate = 0.01
});
person.Assets.Add(new BankAccount {
Amount = 2000, MonthlyInterestRate = 0.02
});
person.Assets.Add(new RealEstate {
EstimatedValue = 79000, MonthlyRent = 500
});
person.Assets.Add(new Loan {
Owed = 40000, MonthlyPayment = 40
});
// Visitor
var netWorthVisitor = new NetWorthVisitor();
person.Accept(netWorthVisitor);
var monthlyincome = new MonthlyIncome();
person.Accept(monthlyincome);
Console.WriteLine("Net Worth: {0}", netWorthVisitor.Total);
Console.WriteLine("Monthly Income: {0}", monthlyincome.Amount);
Console.ReadKey();
}
public async Task BillsAndOutgoingsPostTest()
{
string id = Guid.NewGuid().ToString();
this._controller.RouteData.Values.Add("id", id);
this._portalSettings.Features.EnablePartialSave = true;
IncomeAndExpenditure iAndE = new IncomeAndExpenditure();
BillsAndOutgoingsVm vm = new BillsAndOutgoingsVm();
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm();
this._sessionState.Setup(x => x.CheckSessionStatus(id));
this._sessionState.Setup(x => x.GetIncomeAndExpenditure(Guid.Parse(id)))
.Returns(iAndE);
this._mapper.Setup(x => x.Map(vm, iAndE)).Returns(iAndE);
this._sessionState.Setup(x => x.SaveIncomeAndExpenditure(iAndE, Guid.Parse(id)));
this._calculatorService.Setup(x => x.CalculateMonthlyIncome(iAndE)).Returns(monthlyIncome);
string lowellReference = "123456789";
this._sessionState.Setup(x => x.GetLowellReferenceFromSurrogate(Guid.Parse(id)))
.Returns(lowellReference);
RedirectToActionResult result = (RedirectToActionResult)await this._controller
.BillsAndOutgoingsPost(vm, "testing");
Assert.AreEqual("Expenditure", result.ActionName);
Assert.AreEqual(id, result.RouteValues["id"]);
Assert.IsTrue(vm.EnabledPartialSave);
}
public void ConvertTest_SourceNull()
{
IncomeAndExpenditure source = null;
ExpendituresVm destination = Utilities.CreateDefaultTestExpendituresVm();
ExpendituresVm expected = Utilities.DeepCopy(destination);
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm()
{
Benefits = 100,
Other = 200,
Pension = 300,
Salary = 400,
Total = 1000
};
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings();
MonthlyOutgoingsVm monthlyOutgoingsVm = new MonthlyOutgoingsVm()
{
Expenditures = 1000,
HouseholdBills = 2000,
Total = 3000
};
_calculatorService.Setup(x => x.CalculateMonthlyIncome(It.IsAny <IncomeAndExpenditure>()))
.Returns(monthlyIncome);
_mapper.Setup(x => x.Map <MonthlyIncomeVm>(monthlyIncome)).Returns(monthlyIncomeVm);
_calculatorService.Setup(x => x.CalculateMonthlyOutgoings(It.IsAny <IncomeAndExpenditure>()))
.Returns(monthlyOutgoings);
_mapper.Setup(x => x.Map <MonthlyOutgoingsVm>(monthlyOutgoings)).Returns(monthlyOutgoingsVm);
expected.CareAndHealthCosts.Amount = 0;
expected.CareAndHealthCosts.Frequency = null;
expected.CommunicationsAndLeisure.Amount = 0;
expected.CommunicationsAndLeisure.Frequency = null;
expected.FoodAndHouseKeeping.Amount = 0;
expected.FoodAndHouseKeeping.Frequency = null;
expected.IncomeVmSummary = monthlyIncomeVm;
expected.Other.Amount = 0;
expected.Other.Frequency = null;
expected.OutgoingsVmSummary = monthlyOutgoingsVm;
expected.PensionsAndInsurance.Amount = 0;
expected.PensionsAndInsurance.Frequency = null;
expected.PersonalCosts.Amount = 0;
expected.PersonalCosts.Frequency = null;
expected.Professional.Amount = 0;
expected.Professional.Frequency = null;
expected.Savings.Amount = 0;
expected.Savings.Frequency = null;
expected.SchoolCosts.Amount = 0;
expected.SchoolCosts.Frequency = null;
expected.TravelAndTransport.Amount = 0;
expected.TravelAndTransport.Frequency = null;
ExpendituresVm result = _converter.Convert(source, destination, null);
//Check result is as expected
Assert.IsTrue(Utilities.DeepCompare(expected, result));
}
public UserControlItemMonthlyIncome(MonthlyIncome item, double maximum)
{
InitializeComponent();
DataContext = item;
GridIncoming.Height = (item.Incomings * 130) / maximum;
}
public async Task AddMonthlyIncomeAsync(MonthlyIncome monthlyIncome)
{
using (ParkingLotManagementContext context = new ParkingLotManagementContext())
{
context.MonthlyIncome.Add(monthlyIncome);
await context.SaveChangesAsync();
}
}
public async Task UpdateMonthlyIncomeAsync(MonthlyIncome monthlyIncome)
{
using (ParkingLotManagementContext context = new ParkingLotManagementContext())
{
context.Entry(monthlyIncome).State = EntityState.Modified;
await context.SaveChangesAsync();
}
}
public async Task DeleteMonthlyIncomeAsync(MonthlyIncome monthlyIncome)
{
using (ParkingLotManagementContext context = new ParkingLotManagementContext())
{
MonthlyIncome income = await context.MonthlyIncome.FindAsync(monthlyIncome.ID);
context.MonthlyIncome.Remove(income);
await context.SaveChangesAsync();
}
}
public ActionResult DeleteConfirmed(int id)
{
//MonthlyIncome monthlyIncome = db.MonthlyIncomes.Find(id);
MonthlyIncome monthlyIncome = db.MonthlyIncomes.SingleOrDefault(c => c.IncomeID == id);
//db.MonthlyIncomes.Remove(monthlyIncome);
//db.SaveChanges();
db.Delete(monthlyIncome);
return(RedirectToAction("Index"));
}
private void CheckOut()
{
#region Update Customer Total Using Time And Total Using Money
if (cus != null)
{
var _lot = _parkingLotsList.Find(param => param.ID == "HCMUTEPL");
cus.TotalUsingMoney += TotalPrice;
cus.TotalUsingTime += Math.Round((double)_timeDiff?.TotalHours, 2);
if (cus.TotalUsingTime >= _lot.VIPRequiredTime)
{
cus.isVIP = "Yes";
}
Task.WaitAll(Task.Run(async() => await _customersRepository.UpdateCustomerAsync(cus)));
}
#endregion
#region Update Monthly Income
MonthlyIncome monthlyIncome = _monthlyIncomesList.Find(param => param.ID == parking.CheckOutDateTime?.Month);
monthlyIncome.Income += TotalPrice;
Task.WaitAll(Task.Run(async() => await _monthlyIncomesRepository.UpdateMonthlyIncomeAsync(monthlyIncome)));
#endregion
#region Update Slot Availability
var slot = _slotsList.Find(param => param.ID == parking.SlotID);
slot.Availability = "Yes";
Task.WaitAll(Task.Run(async() => await _slotsRepository.UpdateSlotAsync(slot)));
#endregion
#region Delete From Parking
Task.WaitAll(Task.Run(async() => await _parkingsRepository.DeleteParkingAsync(parking)));
#endregion
MessageBox.Show("Customer has been checked out!", "Successful", MessageBoxButton.OK, MessageBoxImage.Asterisk);
using (System.IO.StreamWriter file = new System.IO.StreamWriter("EventLog.txt", true))
{
string temp = CustomerID == String.Empty ? "null" : CustomerID;
file.WriteLine("----------");
file.WriteLine($"[CheckOut] - Date:{DateTime.Now.ToShortDateString()}; Time:{DateTime.Now.ToLongTimeString()}; License Plate:{CheckOutLicensePlate}; Slot:{slot.Name}; UserID:{temp}");
}
ClearTheView();
}
public ActionResult Edit([Bind(Include = "IncomeID,Origin,Amount,Date")] MonthlyIncome monthlyIncome)
{
if (ModelState.IsValid)
{
//db.Entry(monthlyIncome).State = EntityState.Modified;
//db.SaveChanges();
db.Save(monthlyIncome);
return(RedirectToAction("Index"));
}
return(View(monthlyIncome));
}
public ActionResult Create([Bind(Include = "IncomeID,Origin,Amount,Date")] MonthlyIncome monthlyIncome)
{
if (ModelState.IsValid)
{
//db.MonthlyIncomes.Add(monthlyIncome);
//db.SaveChanges();
db.Save(monthlyIncome);
return(RedirectToAction("Index"));
}
return(View(monthlyIncome));
}
public async Task <IActionResult> ExpenditurePost(ExpendituresVm viewModel, string submit)
{
if (submit == "saveforlater")
{
viewModel.PartialSavedEvent = true;
}
var id = RouteData.Values["id"];
if (id == null)
{
return(RedirectToAction("Index", "MyAccounts"));
}
Guid guid = Guid.Parse(id.ToString());
ApplicationSessionState.CheckSessionStatus(id.ToString());
viewModel.EnabledPartialSave = _portalSettings.Features.EnablePartialSave && LoggedInUser.IsLoggedInUser;
var incomeExpenditure = ApplicationSessionState.GetIncomeAndExpenditure(guid);
incomeExpenditure = _mapper.Map(viewModel, incomeExpenditure);
ApplicationSessionState.SaveIncomeAndExpenditure(incomeExpenditure, guid);
if (!ModelState.IsValid)
{
MonthlyIncome monthlyIncome = _calculatorService.CalculateMonthlyIncome(incomeExpenditure);
MonthlyOutgoings monthlyOutgoings = _calculatorService.CalculateMonthlyOutgoings(incomeExpenditure);
viewModel.IncomeVmSummary = _mapper.Map <MonthlyIncome, MonthlyIncomeVm>(monthlyIncome);
viewModel.OutgoingsVmSummary = _mapper.Map <MonthlyOutgoings, MonthlyOutgoingsVm>(monthlyOutgoings);
return(View("Expenditure", viewModel));
}
string lowellReference = ApplicationSessionState.GetLowellReferenceFromSurrogate(guid);
await _webActivityService.LogBudgetCalculatorCompleted(lowellReference, LoggedInUserId);
if (submit == "saveforlater" && LoggedInUser.IsLoggedInUser && _portalSettings.Features.EnablePartialSave)
{
bool isPartialSaved = await PartialSave(incomeExpenditure, lowellReference);
viewModel.PartialSavedIAndE = isPartialSaved;
viewModel.HasErrorPartialSavedIAndE = !isPartialSaved;
return(View("Expenditure", viewModel));
}
return(RedirectToAction("BudgetSummary", new { id }));
}
// GET: MonthlyIncomes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//MonthlyIncome monthlyIncome = db.MonthlyIncomes.Find(id);
MonthlyIncome monthlyIncome = db.MonthlyIncomes.SingleOrDefault(c => c.IncomeID == id);
if (monthlyIncome == null)
{
return(HttpNotFound());
}
return(View(monthlyIncome));
}
public void GetBudgetSummaryTest()
{
IncomeAndExpenditure iAndE = new IncomeAndExpenditure();
Guid lowellReferenceSurrogateKey = Guid.NewGuid();
string loggedInUserId = Guid.NewGuid().ToString();
MonthlyIncome monthlyIncome = new MonthlyIncome()
{
Benefits = 100,
Other = 200,
Pension = 300,
Salary = 2400,
Total = 3500
};
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings()
{
Expenditures = 1000,
HouseholdBills = 2000,
Total = 3000
};
decimal disposableIncome = 500;
this._calculatorService.Setup(x => x.CalculateMonthlyIncome(iAndE)).Returns(monthlyIncome);
this._calculatorService.Setup(x => x.CalculateMonthlyOutgoings(iAndE)).Returns(monthlyOutgoings);
this._calculatorService.Setup(x => x.CalculateDisposableIncome(3500, 3000)).Returns(disposableIncome);
BudgetSummary expected = new BudgetSummary()
{
IncomeTotal = 3500,
Salary = 2400,
Benefits = 100,
Pension = 300,
Other = 200,
TotalExpenditure = 3000,
HouseholdBills = 2000,
Expenditure = 1000,
DisposableIncome = 500,
Frequency = "monthly",
AnonUser = false,
PriorityBillsInArrears = false
};
BudgetSummary result = this._budgetCalculatorService.GetBudgetSummary(iAndE, lowellReferenceSurrogateKey, loggedInUserId);
Assert.IsTrue(Utilities.DeepCompare(expected, result));
}
public void CalculateMonthlyIncomeTest_IAndENull()
{
IncomeAndExpenditure iAndE = null;
MonthlyIncome expected = new MonthlyIncome()
{
Salary = 0.00M,
Benefits = 0.00M,
Other = 0.00M,
Pension = 0.00M,
Total = 0.00M
};
MonthlyIncome result = this._calculatorService.CalculateMonthlyIncome(iAndE);
Assert.IsTrue(Utilities.DeepCompare(expected, result));
}
public async Task <IActionResult> AddMonthlyIncome(MonthlyIncomeInputModel model)
{
var userId = this.GetUserId <string>();
var language = this.GetCurrentLanguage();
var componentTypeId = (int)ComponentTypes.PaymentComponent;
if (!this.ModelState.IsValid)
{
model.ComponentsSelectListItems = await this.componentsService.AllByUserIdAndTypeIdActiveLocalized <ComponentsSelectListItem>(userId, componentTypeId, language);
return(this.View(model));
}
try
{
var entityToAdd = new MonthlyIncome
{
Amount = model.Amount,
UserId = userId,
IncomePeriod = model.IncomePeriod,
ComponentId = model.ComponentId
};
await this.monthlyIncomeService.AddAsync(entityToAdd);
var result = await this.componentsService.AddAmount(userId, model.ComponentId, model.Amount);
if (result)
{
this.AddAlertMessageToTempData(AlertType.Success, Resources.Success, Resources.MonthlyIncomeAddSuccess);
}
else
{
this.AddAlertMessageToTempData(AlertType.Error, Resources.Error, Resources.MonthlyIncomeAddError);
}
}
catch (Exception)
{
this.AddAlertMessageToTempData(AlertType.Error, Resources.Error, Resources.MonthlyIncomeAddError);
}
return(this.RedirectToAction("Index"));
}
internal List <MonthlyIncome> GetMonthlyIncomes()
{
var accounts = GetAccountList().Where(a => a.Enabled.Equals(true));
List <MonthlyIncome> itemsChart = new List <MonthlyIncome>();
List <Incoming> selectedIncomings = new List <Incoming>();
foreach (var item in Incomings)
{
var itemAccount = item.Account.Name;
var accountEnabled = accounts.Where(a => a.Name.Equals(itemAccount)).FirstOrDefault();
if (accountEnabled != null)
{
selectedIncomings.Add(item);
}
}
var groupedIncomings = (from i in selectedIncomings
where i.Category != null && i.Category.Name.Equals("Rendimento")
group i by new { month = i.Date.Month, year = i.Date.Year } into d
select new
{
dt = string.Format("{0}/{1}", d.Key.month, d.Key.year),
count = d.Count()
}).OrderByDescending(g => g.dt);
foreach (var item in groupedIncomings)
{
var ic = itemsChart.Where(i => i.Date.Equals(DateTime.Parse("01/" + item.dt))).FirstOrDefault();
if (ic == null)
{
ic = new MonthlyIncome(item.dt);
itemsChart.Add(ic);
}
ic.SetIncoming(selectedIncomings.Where(i => i.Date.Month.Equals(ic.Date.Month) &&
i.Date.Year.Equals(ic.Date.Year) &&
i.Category != null &&
i.Category.Name.Equals("Rendimento")).Sum(i => i.Value));
}
return(itemsChart.OrderByDescending(i => i.Date).ToList());
}
public async Task BillsAndOutgoingsPostTest_SaveForLater()
{
string id = Guid.NewGuid().ToString();
this._controller.RouteData.Values.Add("id", id);
this._portalSettings.Features.EnablePartialSave = true;
IncomeAndExpenditure iAndE = new IncomeAndExpenditure();
BillsAndOutgoingsVm vm = new BillsAndOutgoingsVm();
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm();
this._sessionState.Setup(x => x.CheckSessionStatus(id));
this._sessionState.Setup(x => x.GetIncomeAndExpenditure(Guid.Parse(id)))
.Returns(iAndE);
this._mapper.Setup(x => x.Map(vm, iAndE)).Returns(iAndE);
this._sessionState.Setup(x => x.SaveIncomeAndExpenditure(iAndE, Guid.Parse(id)));
this._calculatorService.Setup(x => x.CalculateMonthlyIncome(iAndE)).Returns(monthlyIncome);
string lowellReference = "123456789";
this._sessionState.Setup(x => x.GetLowellReferenceFromSurrogate(Guid.Parse(id)))
.Returns(lowellReference);
this._budgetCalculatorService.Setup(x => x.PartiallySaveIncomeAndExpenditure(
iAndE, lowellReference, Guid.Parse(this._caseflowUserId))).Returns(Task.FromResult(true));
ViewResult result = (ViewResult)await this._controller
.BillsAndOutgoingsPost(vm, "saveforlater");
Assert.AreEqual("BillsAndOutgoings", result.ViewName);
Assert.AreEqual(vm, result.Model);
Assert.IsTrue(vm.EnabledPartialSave);
Assert.IsTrue(vm.PartialSavedEvent);
Assert.IsTrue(vm.PartialSavedIAndE);
Assert.IsFalse(vm.HasErrorPartialSavedIAndE);
}
public void ConvertTest_SourceNull()
{
IncomeAndExpenditure source = null;
BillsAndOutgoingsVm destination = Utilities.CreateDefaultTestBillsAndOutgoingsVm();
BillsAndOutgoingsVm expected = Utilities.DeepCopy(destination);
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm()
{
Benefits = 100,
Other = 200,
Salary = 300,
Pension = 400,
Total = 1000
};
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings();
MonthlyOutgoingsVm monthlyOutgoingsVm = new MonthlyOutgoingsVm()
{
Expenditures = 1000,
HouseholdBills = 2000,
Total = 3000
};
_calculatorService.Setup(x => x.CalculateMonthlyIncome(It.IsAny <IncomeAndExpenditure>()))
.Returns(monthlyIncome);
_mapper.Setup(x => x.Map <MonthlyIncomeVm>(monthlyIncome)).Returns(monthlyIncomeVm);
_calculatorService.Setup(x => x.CalculateMonthlyOutgoings(It.IsAny <IncomeAndExpenditure>()))
.Returns(monthlyOutgoings);
_mapper.Setup(x => x.Map <MonthlyOutgoingsVm>(monthlyOutgoings)).Returns(monthlyOutgoingsVm);
expected.ApplianceOrFurnitureRental.Amount = 0;
expected.ApplianceOrFurnitureRental.ArrearsAmount = 0;
expected.ApplianceOrFurnitureRental.Frequency = null;
expected.ApplianceOrFurnitureRental.InArrears = false;
expected.Ccjs.Amount = 0;
expected.Ccjs.ArrearsAmount = 0;
expected.Ccjs.Frequency = null;
expected.Ccjs.InArrears = false;
expected.ChildMaintenance.Amount = 0;
expected.ChildMaintenance.ArrearsAmount = 0;
expected.ChildMaintenance.Frequency = null;
expected.ChildMaintenance.InArrears = false;
expected.CouncilTax.Amount = 0;
expected.CouncilTax.ArrearsAmount = 0;
expected.CouncilTax.Frequency = null;
expected.CouncilTax.InArrears = false;
expected.CourtFines.Amount = 0;
expected.CourtFines.ArrearsAmount = 0;
expected.CourtFines.Frequency = null;
expected.CourtFines.InArrears = false;
expected.Electric.Amount = 0;
expected.Electric.ArrearsAmount = 0;
expected.Electric.Frequency = null;
expected.Electric.InArrears = false;
expected.Gas.Amount = 0;
expected.Gas.ArrearsAmount = 0;
expected.Gas.Frequency = null;
expected.Gas.InArrears = false;
expected.IncomeSummary = monthlyIncomeVm;
expected.OutgoingSummary = monthlyOutgoingsVm;
expected.Mortgage.Amount = 0;
expected.Mortgage.ArrearsAmount = 0;
expected.Mortgage.Frequency = null;
expected.Mortgage.InArrears = false;
expected.OtherFuel.Amount = 0;
expected.OtherFuel.ArrearsAmount = 0;
expected.OtherFuel.Frequency = null;
expected.OtherFuel.InArrears = false;
expected.Rent.Amount = 0;
expected.Rent.ArrearsAmount = 0;
expected.Rent.Frequency = null;
expected.Rent.InArrears = false;
expected.SecuredLoan.Amount = 0;
expected.SecuredLoan.ArrearsAmount = 0;
expected.SecuredLoan.Frequency = null;
expected.SecuredLoan.InArrears = false;
expected.TvLicense.Amount = 0;
expected.TvLicense.ArrearsAmount = 0;
expected.TvLicense.Frequency = null;
expected.TvLicense.InArrears = false;
expected.Water.Amount = 0;
expected.Water.ArrearsAmount = 0;
expected.Water.Frequency = null;
expected.Water.InArrears = false;
BillsAndOutgoingsVm result = _converter.Convert(source, destination, null);
//Check result is as expected
Assert.IsTrue(Utilities.DeepCompare(expected, result));
}
public async Task <WrapperMonthIncomeVM> MonthlyIncome(MonthlyReport vm)
{
vm.To = vm.To.ToLocalTime();
vm.From = vm.From.ToLocalTime();
WrapperMonthIncomeVM returnData = new WrapperMonthIncomeVM();
Task <List <Income> > IncomeT = _repositoryWrapper
.Income
.FindAll()
.Where(x => x.FactoryId == vm.FactoryId)
//.Where(x => x.Month == vm.Month)
.Where(x => x.CreatedDateTime >= vm.From)
.Where(x => x.CreatedDateTime <= vm.To)
.Include(x => x.Staff)
.Include(x => x.Supplier)
.Include(x => x.Customer)
.ToListAsync();
await IncomeT;
//Task<List<Income>> IncomeT_1 = _repositoryWrapper
// .Income
// .FindAll()
// .Where(x => x.FactoryId == vm.FactoryId)
// .Where(x => x.Month == vm.Month)
// .Include(x => x.Customer)
// .ToListAsync();
//await IncomeT_1;
//Task<List<Income>> IncomeT_2 = _repositoryWrapper
// .Income
// .FindAll()
// .Where(x => x.FactoryId == vm.FactoryId)
// .Where(x => x.Month == vm.Month)
// .Include(x => x.Supplier)
// .ToListAsync();
//await IncomeT_2;
// await Task.WhenAll(IncomeT, IncomeT_1, IncomeT_2);
List <Income> lst = IncomeT.Result.ToList();
// lst = _utilService.ConcatList<Income>(IncomeT.Result.ToList(), _utilService.ConcatList<Income>(IncomeT_1.Result.ToList(), IncomeT_2.Result.ToList()));
List <MonthlyIncome> monthlyIncome = new List <MonthlyIncome>();
monthlyIncome = _utilService.Mapper.Map <List <Income>, List <MonthlyIncome> >(lst);
returnData.TotalRecords = monthlyIncome
.ToList()
.Count();
MonthlyIncome lastRow = new MonthlyIncome();
returnData.ListOfData = monthlyIncome;
lastRow.Amount = returnData.ListOfData.Sum(x => (x.Amount));
returnData.ListOfData = monthlyIncome
.OrderByDescending(x => x.CreatedDateTime)
.Skip((vm.PageNumber - 1) * (vm.PageSize))
.Take(vm.PageSize)
.ToList();
returnData.Total_TillNow = lastRow.Amount;
returnData.Total_Monthly = returnData.ListOfData.Sum(x => (x.Amount));
returnData.ListOfData.Add(lastRow);
return(returnData);
}
public void ConvertTest()
{
IncomeAndExpenditure source = new IncomeAndExpenditure()
{
AdultsInHousehold = 1,
Children16to18 = 2,
ChildrenUnder16 = 3,
Created = DateTime.Now.Date,
CouncilTax = 100,
CouncilTaxArrears = 110,
CouncilTaxFrequency = "monthly",
ChildMaintenance = 120,
ChildMaintenanceArrears = 130,
ChildMaintenanceFrequency = "fortnightly",
HomeContents = 140,
HomeContentsArrears = 150,
HomeContentsFrequency = "weekly",
HasArrears = true,
EmploymentStatus = "employed full time",
Healthcare = 160,
HealthcareFrequency = "monthly",
Housekeeping = 170,
HousekeepingFrequency = "fortnightly",
HousingStatus = "homeowner",
Leisure = 180,
LeisureFrequency = "weekly",
LowellReference = "123456789",
Mortgage = 190,
MortgageArrears = 200,
MortgageFrequency = "monthly",
OtherUtilities = 210,
OtherUtilitiesArrears = 220,
OtherUtilitiesFrequency = "fortnightly",
OtherIncome = 230,
OtherincomeFrequency = "weekly",
PersonalCosts = 240,
PersonalCostsFrequency = "fortnightly",
Pension = 250,
PensionFrequency = "weekly",
PensionInsurance = 260,
PensionInsuranceFrequency = "monthly",
Rental = 270,
RentalArrears = 280,
RentalFrequency = "fortnightly",
Rent = 290,
RentArrears = 300,
RentFrequency = "weekly",
Salary = 310,
SalaryFrequency = "monthly",
SavingsContributions = 320,
SavingsContributionsFrequency = "fortnightly",
SchoolCosts = 330,
SchoolCostsFrequency = "weekly",
ProfessionalCosts = 340,
ProfessionalCostsFrequency = "monthly",
SecuredLoans = 350,
SecuredloansArrears = 360,
SecuredLoansFrequency = "fortnightly",
Travel = 370,
TravelFrequency = "weekly",
TvLicence = 380,
TvLicenceArrears = 390,
TvLicenceFrequency = "monthly",
User = "******",
OtherDebts = new List <SaveOtherDebts>()
{
},
Electricity = 400,
ElectricityArrears = 410,
ElectricityFrequency = "fortnightly",
Gas = 420,
GasArrears = 430,
GasFrequency = "weekly",
Water = 440,
WaterArrears = 450,
WaterFrequency = "monthly",
BenefitsTotal = 460,
BenefitsTotalFrequency = "fortnightly",
EarningsTotal = 470,
EarningsTotalFrequency = "weekly",
ExpenditureTotal = 480,
IncomeTotal = 490,
DisposableIncome = 500,
UtilitiesTotal = 510,
UtilitiesTotalArrears = 520,
UtilitiesTotalFrequency = "monthly",
CCJs = 530,
CCJsArrears = 540,
CCJsFrequency = "fortnightly",
CourtFines = 550,
CourtFinesArrears = 560,
CourtFinesFrequency = "weekly",
OtherExpenditure = 570,
OtherExpenditureFrequency = "monthly"
};
//Create a copy of source for later
IncomeAndExpenditure sourceCopy = Utilities.DeepCopy(source);
IncomeAndExpenditureApiModel destination = new IncomeAndExpenditureApiModel();
IncomeAndExpenditureApiModel expected = Utilities.DeepCopy(destination);
this._calculatorService.Setup(x => x.InArrears(source)).Returns(true);
expected.LowellReference = "123456789";
expected.User = "******";
expected.Created = DateTime.UtcNow;
expected.HasArrears = true;
expected.AdultsInHousehold = 1;
expected.ChildrenUnder16 = 3;
expected.Children16to18 = 2;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.Salary = 310;
expected.SalaryFrequency = "M";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.Pension = 250;
expected.PensionFrequency = "W";
expected.EarningsTotal = 0.00M;
expected.EarningsTotalFrequency = "";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.BenefitsTotal = 460;
expected.BenefitsTotalFrequency = "F";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.OtherIncome = 230;
expected.OtherincomeFrequency = "W";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.Mortgage = 190;
expected.MortgageFrequency = "M";
expected.MortgageArrears = 200;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.Rent = 290;;
expected.RentFrequency = "W";
expected.RentArrears = 300;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.SecuredLoans = 350;
expected.SecuredLoansFrequency = "F";
expected.SecuredloansArrears = 360;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.CouncilTax = 100;
expected.CouncilTaxFrequency = "M";
expected.CouncilTaxArrears = 110;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.Rental = 270;
expected.RentalFrequency = "F";
expected.RentalArrears = 280;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.TvLicence = 380;
expected.TvLicenceFrequency = "M";
expected.TvLicenceArrears = 390;
expected.HomeContents = 0.00M;
expected.HomeContentsFrequency = "";
expected.HomeContentsArrears = 150.00M;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.Gas = 420;
expected.GasFrequency = "W";
expected.GasArrears = 430;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.OtherUtilities = 210;
expected.OtherUtilitiesFrequency = "F";
expected.OtherUtilitiesArrears = 220;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.Electricity = 400;
expected.ElectricityFrequency = "F";
expected.ElectricityArrears = 410;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.Water = 440;
expected.WaterFrequency = "M";
expected.WaterArrears = 450;
expected.UtilitiesTotal = 0.00M;
expected.UtilitiesTotalFrequency = "";
expected.UtilitiesTotalArrears = 520.00M;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.ChildMaintenance = 120;
expected.ChildMaintenanceFrequency = "F";
expected.ChildMaintenanceArrears = 130;
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.Housekeeping = 170;
expected.HousekeepingFrequency = "F";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.PersonalCosts = 240;
expected.PersonalCostsFrequency = "F";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.Leisure = 180;
expected.LeisureFrequency = "W";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.Travel = 370;
expected.TravelFrequency = "W";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.Healthcare = 160;
expected.HealthcareFrequency = "M";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.PensionInsurance = 260;
expected.PensionInsuranceFrequency = "M";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("weekly")).Returns("W");
expected.SchoolCosts = 330;
expected.SchoolCostsFrequency = "W";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("monthly")).Returns("M");
expected.ProfessionalCosts = 340;
expected.ProfessionalCostsFrequency = "M";
this._mapperHelper.Setup(x => x.ConvertFrequencyToInitial("fortnightly")).Returns("F");
expected.SavingsContributions = 320;
expected.SavingsContributionsFrequency = "F";
List <SaveOtherDebtsApiModel> otherDebts = new List <SaveOtherDebtsApiModel>()
{
new SaveOtherDebtsApiModel()
{
Amount = 570, Arrears = 580, Frequency = "M", CountyCourtJudgement = true
}
};
_mapperHelper.Setup(x => x.CreateOtherDebts(source)).Returns(otherDebts);
expected.OtherDebts = otherDebts;
MonthlyIncome monthlyIncome = new MonthlyIncome()
{
Total = 590
};
this._calculatorService.Setup(x => x.CalculateMonthlyIncome(source)).Returns(monthlyIncome);
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings()
{
Total = 600
};
this._calculatorService.Setup(x => x.CalculateMonthlyOutgoings(source)).Returns(monthlyOutgoings);
this._mapperHelper.Setup(x => x.ConvertToHousingStatusCaseflow("homeowner")).Returns("Owner");
this._mapperHelper.Setup(x => x.ConvertToEmploymentStatusCaseflow("employed full time")).Returns("Full-Time");
expected.IncomeTotal = 590;
expected.ExpenditureTotal = 600;
expected.DisposableIncome = -10;
expected.HousingStatus = "Owner";
expected.EmploymentStatus = "Full-Time";
IncomeAndExpenditureApiModel result = _converter.Convert(source, destination, null);
//Check that source hasn't been modified
Assert.IsTrue(Utilities.DeepCompare(source, sourceCopy));
//Check that result is as expected
Assert.IsTrue(Utilities.DeepCompare(expected, result, 1000));
}
public void ConvertTest_DestinationNull()
{
IncomeAndExpenditure source = new IncomeAndExpenditure()
{
Mortgage = 100,
MortgageArrears = 10,
MortgageFrequency = "monthly",
Rental = 150,
RentalArrears = 0,
RentalFrequency = "weekly",
Electricity = 200,
ElectricityArrears = 20,
ElectricityFrequency = "fortnightly",
CCJs = 250,
CCJsArrears = 0,
CCJsFrequency = "monthly",
ChildMaintenance = 300,
ChildMaintenanceArrears = 30,
ChildMaintenanceFrequency = "weekly",
CouncilTax = 350,
CouncilTaxArrears = 0,
CouncilTaxFrequency = "fortnightly",
CourtFines = 400,
CourtFinesArrears = 40,
CourtFinesFrequency = "monthly",
Gas = 450,
GasArrears = 0,
GasFrequency = "weekly",
OtherUtilities = 500,
OtherUtilitiesArrears = 50,
OtherUtilitiesFrequency = "fortnightly",
Rent = 550,
RentArrears = 0,
RentFrequency = "monthly",
SecuredLoans = 600,
SecuredloansArrears = 60,
SecuredLoansFrequency = "weekly",
TvLicence = 650,
TvLicenceArrears = 0,
TvLicenceFrequency = "fortnightly",
Water = 700,
WaterArrears = 70,
WaterFrequency = "monthly",
AdultsInHousehold = 1,
ChildrenUnder16 = 2,
Children16to18 = 3,
HasArrears = true,
UtilitiesTotal = 750,
UtilitiesTotalArrears = 0,
UtilitiesTotalFrequency = "weekly",
User = "******",
Created = DateTime.Now.Date,
Healthcare = 800,
HealthcareFrequency = "fortnightly",
HomeContents = 850,
HomeContentsArrears = 0,
HomeContentsFrequency = "monthly",
EmploymentStatus = "student",
Housekeeping = 900,
HousekeepingFrequency = "monthly",
HousingStatus = "homeowner",
DisposableIncome = 999.99M,
BenefitsTotal = 888.88M,
BenefitsTotalFrequency = "monthly",
Leisure = 50,
LeisureFrequency = "weekly",
OtherDebts = new List <SaveOtherDebts>(),
OtherExpenditure = 60,
OtherExpenditureFrequency = "fortnightly",
OtherIncome = 500,
OtherincomeFrequency = "monthly",
LowellReference = "123456789",
EarningsTotal = 10000,
EarningsTotalFrequency = "monthly",
PersonalCosts = 225,
PersonalCostsFrequency = "monthly",
Pension = 400,
PensionFrequency = "monthly",
Salary = 9999,
SalaryFrequency = "monthly",
SavingsContributions = 55,
SavingsContributionsFrequency = "weekly",
SchoolCosts = 5,
SchoolCostsFrequency = "weekly",
Travel = 45,
TravelFrequency = "fortnightly",
ProfessionalCosts = 123,
ProfessionalCostsFrequency = "monthly",
IncomeTotal = 1234.56M,
PensionInsurance = 75,
PensionInsuranceFrequency = "monthly",
ExpenditureTotal = 1000
};
//Create a copy of source for later
IncomeAndExpenditure sourceCopy = Utilities.DeepCopy(source);
MonthlyIncome monthlyIncome = new MonthlyIncome();
MonthlyIncomeVm monthlyIncomeVm = new MonthlyIncomeVm()
{
Benefits = 100,
Other = 200,
Pension = 300,
Salary = 400,
Total = 1000
};
MonthlyOutgoings monthlyOutgoings = new MonthlyOutgoings();
MonthlyOutgoingsVm monthlyOutgoingsVm = new MonthlyOutgoingsVm()
{
Expenditures = 123,
HouseholdBills = 456,
Total = 789
};
BillsAndOutgoingsVm destination = null;
BillsAndOutgoingsVm expected = new BillsAndOutgoingsVm();
expected.Mortgage = new OutgoingSourceVm()
{
Amount = 100, ArrearsAmount = 10, Frequency = "monthly", InArrears = true
};
expected.ApplianceOrFurnitureRental = new OutgoingSourceVm()
{
Amount = 150, ArrearsAmount = 0, Frequency = "weekly", InArrears = false
};
expected.Electric = new OutgoingSourceVm()
{
Amount = 200, ArrearsAmount = 20, Frequency = "fortnightly", InArrears = true
};
expected.Ccjs = new OutgoingSourceVm()
{
Amount = 250, ArrearsAmount = 0, Frequency = "monthly", InArrears = false
};
expected.ChildMaintenance = new OutgoingSourceVm()
{
Amount = 300, ArrearsAmount = 30, Frequency = "weekly", InArrears = true
};
expected.CouncilTax = new OutgoingSourceVm()
{
Amount = 350, ArrearsAmount = 0, Frequency = "fortnightly", InArrears = false
};
expected.CourtFines = new OutgoingSourceVm()
{
Amount = 400, ArrearsAmount = 40, Frequency = "monthly", InArrears = true
};
expected.Gas = new OutgoingSourceVm()
{
Amount = 450, ArrearsAmount = 0, Frequency = "weekly", InArrears = false
};
expected.OtherFuel = new OutgoingSourceVm()
{
Amount = 500, ArrearsAmount = 50, Frequency = "fortnightly", InArrears = true
};
expected.Rent = new OutgoingSourceVm()
{
Amount = 550, ArrearsAmount = 0, Frequency = "monthly", InArrears = false
};
expected.SecuredLoan = new OutgoingSourceVm()
{
Amount = 600, ArrearsAmount = 60, Frequency = "weekly", InArrears = true
};
expected.TvLicense = new OutgoingSourceVm()
{
Amount = 650, ArrearsAmount = 0, Frequency = "fortnightly", InArrears = false
};
expected.Water = new OutgoingSourceVm()
{
Amount = 700, ArrearsAmount = 70, Frequency = "monthly", InArrears = true
};
expected.IncomeSummary = monthlyIncomeVm;
expected.OutgoingSummary = monthlyOutgoingsVm;
_calculatorService.Setup(x => x.CalculateMonthlyIncome(source)).Returns(monthlyIncome);
_calculatorService.Setup(x => x.CalculateMonthlyOutgoings(source)).Returns(monthlyOutgoings);
_mapper.Setup(x => x.Map <MonthlyIncomeVm>(monthlyIncome)).Returns(monthlyIncomeVm);
_mapper.Setup(x => x.Map <MonthlyOutgoingsVm>(monthlyOutgoings)).Returns(monthlyOutgoingsVm);
BillsAndOutgoingsVm result = _converter.Convert(source, destination, null);
//Check that the result is as expected
Assert.IsTrue(Utilities.DeepCompare(expected, result));
//Check that source hasn't been modified
Assert.IsTrue(Utilities.DeepCompare(source, sourceCopy));
}
