public BaseResult CreateMonthlyBudget(MonthlyBudget monthlyBudget)
{
BaseResult result = null;
if (monthlyBudget != null)
{
monthlyBudget.EntityState = EntityState.Added;
monthlyBudget.CreationDate = DateTime.Now;
monthlyBudget.LastModifited = monthlyBudget.CreationDate;
// set related entities to added
if (monthlyBudget.Expenses != null && monthlyBudget.Expenses.Count > 0)
{
monthlyBudget.Expenses.Select(b => { b.Id = 0; b.EntityState = EntityState.Added; return(b); }).ToList();
}
try
{
monthlyBudgetBL.Add(monthlyBudget);
result = new OperationResult(ResultStatus.Success, Reflection.GetCurrentMethodName())
{
Value = monthlyBudget.Id
};
}
catch (Exception Ex)
{
_log.Error(string.Format("Cannot save new monthly plan.\r\n{0}", Ex.Message), Ex);
result = new OperationResult(ResultStatus.Exception, Reflection.GetCurrentMethodName())
{
Message = "Cannot save new monthly plan.",
Value = Ex.Message
};
}
}
return(result);
}
public ActionResult EditMonthlyBudget(MonthlyBudgetDto model, HttpPostedFileBase file)
{
try
{
//Check the model state
if (!ModelState.IsValid)
{
return(View(model));
}
//Get the entity
MonthlyBudget dto = _monthlyBudgetRepository.Get(model.Id);
if (dto == null)
{
return(Content("תקציב לא קיים"));
}
else
{
dto = Mapper.Map <MonthlyBudget>(model);
//Update dto entity
_monthlyBudgetRepository.Update(dto);
InitState();
return(View(model));
}
}
catch (Exception ex)
{
logger.Error($"EditMonthlyBudget() {DateTime.Now}");
logger.Error(ex.Message);
logger.Error("==============================");
return(null);
}
}
public MonthlyBudget GetMonthlyBudget(int monthlyBudgetId)
{
MonthlyBudget monthlyBudget = null;
if (monthlyBudgetId != 0)
{
try
{
monthlyBudget = monthlyBudgetBL.GetById(monthlyBudgetId,
m => m.Expenses,
m => m.Cheques,
m => m.CreditCards,
m => m.LoansPayments,
m => m.Salaries,
m => m.AdditionalIncome
);
}
catch (Exception Ex)
{
_log.Error(string.Format("{0} : Get monthly plan failed. {1}", Reflection.GetCurrentMethodName(), Ex.Message), Ex);
throw;
}
}
return(monthlyBudget);
}
private async Task<MonthlyBudget> GenerateReport(MonthlyBudget report)
{
report.CreatedDate = DateTime.Now;
var transactions = await _transactionRepo.GetForMonth(report.Year, report.Month);
foreach (var transaction in transactions)
{
if (transaction.Category.Contains("TRANSFER")) {
// ignore this document
} else if (transaction.Category.StartsWith("R")) {
AddInCollection(transaction, report.Income);
} else if (transaction.Category.StartsWith("A") || transaction.Category.StartsWith("B") || transaction.Category.StartsWith("C")) {
AddInCollection(transaction, report.Expenses);
} else if (transaction.Category.StartsWith("D")) {
AddInCollection(transaction, report.Debts);
} else {
AddInCollection(transaction, report.Outages);
}
}
report.IncomeTotal = SumCollection(report.Income);
report.ExpensesTotal = SumCollection(report.Expenses);
report.Total = report.IncomeTotal - report.ExpensesTotal;
report.DebtsTotal = SumCollection(report.Debts);
report.CleanTotal = report.Total - report.DebtsTotal;
report.OutagesTotal = SumCollection(report.Outages);
return report;
}
/// <summary>
/// gets the onthly budget
/// </summary>
/// <returns></returns>
public MonthlyBudget GetMonthlyBudget()
{
ShoeTrackerSqlStatment statment = new ShoeTrackerSqlStatment(StoredProcedureConstants.GetMonthlyBudgetQuery);
MonthlyBudget monthlyBudget = shoeTrackerDatabase.ExecuteStoredProc(statment, MapMonthlyBudget).FirstOrDefault();
return(monthlyBudget);
}
public ActionResult DeleteConfirmed(int id)
{
MonthlyBudget monthlyBudget = db.monthlyBudget.Find(id);
db.monthlyBudget.Remove(monthlyBudget);
db.SaveChanges();
return(RedirectToAction("MonthlyBudgetView"));
}
public ActionResult Edit([Bind(Include = "Id,CategoryId,BudgetMonth,BudgetAmount,ActualAmount,Difference")] MonthlyBudget monthlyBudget)
{
if (ModelState.IsValid)
{
db.Entry(monthlyBudget).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("MonthlyBudgetView"));
}
ViewBag.CategoryId = new SelectList(db.category, "Id", "CategoryName", monthlyBudget.CategoryId);
return(View(monthlyBudget));
}
public BaseResult CreateFromTemplate(int MonthlyPlanTemplateId)
{
BaseResult result = null;
MonthlyPlanTemplate template = null;
try
{
template = GetTemplate(MonthlyPlanTemplateId);
if (template != null)
{
// template loaded, try deserialize into object from JSON format
MonthlyBudget _tempBudget = Newtonsoft.Json.JsonConvert.DeserializeObject <MonthlyBudget>(template.Template);
// Add new monthly, then iterate and add all related entites
_tempBudget.Id = 0;
bool action = DefaultAddEntity(_tempBudget);
if (action)
{
result = new OperationResult(ResultStatus.Success, "CreateFromTemplate")
{
Value = _tempBudget.Id
};
}
else
{
result = new OperationResult(ResultStatus.Failure, "CreateFromTemplate")
{
Message = "Unable to create monthly budget from template"
};
}
}
else
{
result = new OperationResult(ResultStatus.Failure, "CreateFromTemplate")
{
Message = "Template not found",
Value = HttpStatusCode.NotFound
};
}
}
catch (Exception Ex)
{
_log.Error(string.Format("Unable to create monthly budget from template.\r\n{0}", Ex), Ex);
result = new OperationResult(ResultStatus.Exception, "CreateFromTemplate")
{
Message = "Could not load template from database.",
Value = HttpStatusCode.InternalServerError
};
}
return(result);
}
public ActionResult Create([Bind(Include = "Id,CategoryId,BudgetMonth,BudgetAmount,ActualAmount,Difference")] MonthlyBudget monthlyBudget)
{
if (ModelState.IsValid)
{
db.monthlyBudget.Add(monthlyBudget);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(db.category, "Id", "CategoryName", monthlyBudget.CategoryId);
return(View(monthlyBudget));
}
public bool Delete(int id)
{
bool isDeleted = false;
MonthlyBudget entity = context.MonthlyBudgets.FirstOrDefault(p => p.Id == id);
if (entity != null)
{
context.MonthlyBudgets.Remove(entity);
context.SaveChanges();
isDeleted = true;
}
return(isDeleted);
}
public BaseResult DeleteMonthlyBudget(MonthlyBudget monthlyBudget)
{
List <BaseResult> results = new List <BaseResult>();
List <BaseResult> partialResults = new List <BaseResult>();
bool partialResultsContainsError = false;
BaseResult result = null;
if (monthlyBudget != null)
{
try
{
int id = monthlyBudget.Id;
monthlyBudget.EntityState = EntityState.Deleted;
// Remove all budget item by category of this budget plan (e.g, Expenses, Cheques, Salaries, etc... )
results = RemoveMonthlyPlanBudgetItems(monthlyBudget);
// Check if there result contains errors
partialResultsContainsError = results.Where(br => br.Status != ResultStatus.Success).Any();
// If there were no errors, try delete the monthly plan object
if (partialResultsContainsError == false)
{
monthlyBudgetBL.Remove(monthlyBudget);
// remove the relation to the old entities
monthlyBudget.Expenses = null;
result = new OperationResult(ResultStatus.Success, Reflection.GetCurrentMethodName())
{
Value = id
};
}
else
{
result = new OperationResult(ResultStatus.Failure, Reflection.GetCurrentMethodName())
{
Value = results
};
}
}
catch (Exception Ex)
{
_log.Error(string.Format("Cannot fully delete monthly plan.\r\n{0}", Ex.Message), Ex);
result =
new OperationResult(ResultStatus.Exception, Reflection.GetCurrentMethodName())
{
Message = "Cannot delete monthly plan.",
Value = Ex.Message
};
}
}
return(result);
}
public bool DefaultAddEntity(IEntity Entity)
{
bool actionResult = true;
if (Entity != null)
{
Entity.EntityState = EntityState.Added;
try
{
if (Entity is AnnualBudget)
{
AnnualBudget ab = Entity as AnnualBudget;
// set related entities to added
if (ab.MonthlyBudgets != null && ab.MonthlyBudgets.Count > 0)
{
ab.MonthlyBudgets.Select(b => { b.Id = 0; b.EntityState = EntityState.Added; return(b); }).ToList();
}
annualBudgetBL.Add(Entity as AnnualBudget);
}
else if (Entity is MonthlyBudget)
{
MonthlyBudget mb = Entity as MonthlyBudget;
// set related entities to added
if (mb.Expenses != null && mb.Expenses.Count > 0)
{
mb.Expenses.Select(b => { b.Id = 0; b.EntityState = EntityState.Added; return(b); }).ToList();
}
monthlyBudgetBL.Add(Entity as MonthlyBudget);
}
else if (Entity is Expense)
{
expenseBL.Add(Entity as Expense);
}
else if (Entity is MonthlyPlanTemplate)
{
monthlyTemplateBL.Add(Entity as MonthlyPlanTemplate);
}
else
{
actionResult = false;
}
}
catch (Exception Ex)
{
string errMessage = "Save new entity failed.";
_log.Error(string.Format("{0} : {1} {2}", this.GetType().Name, errMessage + Environment.NewLine, Ex.Message), Ex);
}
}
return(actionResult);
}
// GET: MonthlyBudgets/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MonthlyBudget monthlyBudget = db.monthlyBudget.Find(id);
if (monthlyBudget == null)
{
return(HttpNotFound());
}
return(View(monthlyBudget));
}
public bool Update(MonthlyBudget item)
{
bool isUpdated = false;
MonthlyBudget entity = context.MonthlyBudgets.FirstOrDefault(p => p.Id == item.Id);
if (entity != null)
{
entity.Budget = item.Budget;
entity.Date = item.Date;
entity.ShortDesc = item.ShortDesc;
context.SaveChanges();
isUpdated = true;
}
return(isUpdated);
}
// GET: MonthlyBudgets/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MonthlyBudget monthlyBudget = db.monthlyBudget.Find(id);
if (monthlyBudget == null)
{
return(HttpNotFound());
}
ViewBag.CategoryId = new SelectList(db.category, "Id", "CategoryName", monthlyBudget.CategoryId);
return(View(monthlyBudget));
}
private MonthlyBudget PrepareBudgetEntity(Category category, BudgetPeriod period)
{
var monthlyBudget = _repository.GetForCategory(category, period);
if (monthlyBudget == null)
{
// TODO czy entity z EF mogą mieć niedomyślne konstruktory?
monthlyBudget = new MonthlyBudget
{
Year = period.Year,
Month = period.Month,
Category = category
};
_repository.Insert(monthlyBudget);
}
return(monthlyBudget);
}
public static MonthlyBudget MapToModel(this MonthlyPlanViewModel monthlyPlanVM)
{
MonthlyBudget budget = null;
if (monthlyPlanVM != null)
{
budget = new MonthlyBudget()
{
BaseBudget = monthlyPlanVM.BudgetForAllocation,
Comments = monthlyPlanVM.Comments,
MonthName = monthlyPlanVM.MonthName,
Id = monthlyPlanVM.MonthlyBudgetId,
AnnualBudgetId = monthlyPlanVM.AnnualBudgetId,
LastModifited = monthlyPlanVM.LastModified,
CreationDate = monthlyPlanVM.CreationDate
};
}
return(budget);
}
public BaseResult UpdateMonthlyPlan(MonthlyBudget monthlyBudget)
{
BaseResult result = null;
if (monthlyBudget != null)
{
try
{
dynamic businessLayer = businessLayers[typeof(MonthlyBudget)];
if (businessLayer != null)
{
monthlyBudget.LastModifited = DateTime.Now;
monthlyBudget.EntityState = EntityState.Modified;
// save the budget item entity
businessLayer.Update(monthlyBudget);
// update the monthly plan relevant fields
result = new OperationResult(ResultStatus.Success)
{
Value = monthlyBudget.Id
};
}
}
catch (Exception Ex)
{
_log.Error(string.Format("{0} : Cannot update monthly budget plan.\r\n{1}", this.GetType().Name, Ex.Message), Ex);
result = new OperationResult(ResultStatus.Exception, Reflection.GetCurrentMethodName())
{
Message = "Cannot update monthly budget plan item.",
Value = Ex.Message
};
}
}
else
{
result = new OperationResult(ResultStatus.Failure, Reflection.GetCurrentMethodName())
{
Message = "Monthly budget plan cannot be null",
Value = null
};
}
return(result);
}
public ActionResult MonthlyBudgetView(MonthlyBudgetViewModel model, string BudgetMonth)
{
model.CategoryList = db.category;
var newMonthlyBuget = new MonthlyBudget
{
CategoryId = model.CategoryId,
BudgetMonth = model.BudgetMonth,
BudgetAmount = model.BudgetAmount,
ActualAmount = 0,
Difference = 0
};
db.monthlyBudget.Add(newMonthlyBuget);
db.SaveChanges();
model.BudgetList = db.monthlyBudget.Where(x => x.BudgetMonth == BudgetMonth).ToList();
ViewBag.CategoryId = new SelectList(db.category, "Id", "CategoryName", model.CategoryId);
return(View(model));
}
public static MonthlyPlanViewModel MapToViewModel(this MonthlyBudget monthyBudget)
{
if (monthyBudget != null)
{
return(new MonthlyPlanViewModel
{
AnnualBudgetId = monthyBudget.AnnualBudgetId,
BudgetForAllocation = monthyBudget.BaseBudget,
MonthlyBudgetId = monthyBudget.Id,
MonthName = monthyBudget.MonthName,
Comments = monthyBudget.Comments,
CreationDate = monthyBudget.CreationDate,
LastModified = monthyBudget.LastModifited,
CalculatedFields = CalculatedFieldsHelper.CreateCalculatedFieldsObject(monthyBudget)
});
}
else
{
return(null);
}
}
public ActionResult AddMonthlyBudget([Bind(Exclude = "Id")] MonthlyBudgetDto model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
MonthlyBudget dto = Mapper.Map <MonthlyBudget>(model);
_monthlyBudgetRepository.Add(dto);
InitState();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
logger.Error($"AddMonthlyBudget() {DateTime.Now}");
logger.Error(ex.Message);
logger.Error("==============================");
return(null);
}
}
public ActionResult EditMonthlyBudget(int id)
{
try
{
MonthlyBudgetDto model;
MonthlyBudget dto = _monthlyBudgetRepository.Get(id);
if (dto == null)
{
return(Content("לא קיים תקציב."));
}
model = Mapper.Map <MonthlyBudgetDto>(dto);
return(View(model));
}
catch (Exception ex)
{
logger.Error($"EditMonthlyBudget() {DateTime.Now}");
logger.Error(ex.Message);
logger.Error("==============================");
return(null);
}
}
public async Task<MonthlyBudget> CreateMonthlyBudget(int year, int month)
{
var report = await _repo.GetMonthlyBudget(year, month);
if (report == null) {
report = new MonthlyBudget();
report.Year = year;
report.Month = month;
report = await GenerateReport(report);
return await _repo.Create(report) ?? null;
} else {
report.Clean();
report = await GenerateReport(report);
await _repo.Update(report.Id.ToString(), report);
return report;
}
}
public BaseResult SaveMonthlyPlanAsTemplate(int?MonthlyPlanId, string TemplateName)
{
BaseResult Result = new OperationResult();
MonthlyBudget budget = null;
budget = GetMonthlyBudget(MonthlyPlanId.Value);
if (budget != null)
{
string templateJson = string.Empty;
try
{
var serializer = new JavaScriptSerializer();
templateJson = serializer.Serialize(budget);
}
catch (Exception Ex)
{
Result = new OperationResult(ResultStatus.Exception, Reflection.GetCurrentMethodName())
{
Message = "Unable to build JSON template from monthly plan",
Value = Ex
};
}
if (string.IsNullOrEmpty(templateJson) == false)
{
// info log
_log.InfoFormat("Generated Template: {0}", templateJson);
// save
MonthlyPlanTemplate template = new MonthlyPlanTemplate()
{
EntityState = EntityState.Added,
Id = 0,
TemplateName = TemplateName,
Template = templateJson
};
bool result = false;
try
{
result = DefaultAddEntity(template);
if (result)
{
Result = new OperationResult(ResultStatus.Success, Reflection.GetCurrentMethodName());
}
else
{
Result = new OperationResult(ResultStatus.Failure, Reflection.GetCurrentMethodName());
}
}
catch (Exception Ex)
{
Result = new OperationResult(ResultStatus.Exception, Reflection.GetCurrentMethodName())
{
Message = "Unable to save monthly plan template",
Value = Ex
};
}
}
}
else
{
Result = new OperationResult(ResultStatus.Failure, Reflection.GetCurrentMethodName())
{
Message = string.Format("Unable to create template based on monthly pland id {0}, the template was not found in the database.", MonthlyPlanId),
Value = HttpStatusCode.NoContent
};
}
return(Result);
}
public void Add(MonthlyBudget item)
{
context.MonthlyBudgets.Add(item);
context.SaveChanges();
}
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));
}
private List <BaseResult> RemoveMonthlyPlanBudgetItems(MonthlyBudget monthlyBudget)
{
List <BaseResult> results = new List <BaseResult>();
List <BaseResult> partialResults = new List <BaseResult>();
bool partialResultsContainsError = false;
// Delete monthly budget and all it's related child entities
if (monthlyBudget.AdditionalIncome != null && monthlyBudget.AdditionalIncome.Count > 0)
{
var additionalIncomeList = monthlyBudget.AdditionalIncome.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(additionalIncomeList);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.AdditionalIncome = null;
}
}
if (monthlyBudget.Salaries != null && monthlyBudget.Salaries.Count > 0)
{
var salariesList = monthlyBudget.Salaries.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(salariesList);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.Salaries = null;
}
}
if (monthlyBudget.Expenses != null && monthlyBudget.Expenses.Count > 0)
{
var budgetItems = monthlyBudget.Expenses.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(budgetItems);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.Expenses = null;
}
}
if (monthlyBudget.Cheques != null && monthlyBudget.Cheques.Count > 0)
{
var budgetItems = monthlyBudget.Cheques.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(budgetItems);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.Cheques = null;
}
}
if (monthlyBudget.CreditCards != null && monthlyBudget.CreditCards.Count > 0)
{
var budgetItems = monthlyBudget.CreditCards.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(budgetItems);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.CreditCards = null;
}
}
if (monthlyBudget.LoansPayments != null && monthlyBudget.LoansPayments.Count > 0)
{
var budgetItems = monthlyBudget.LoansPayments.ToList <BudgetItemBase>();
partialResults = removeBudgetItems(budgetItems);
if (partialResults != null && partialResults.Count > 0)
{
partialResultsContainsError = partialResults.Where(pr => pr.Status != ResultStatus.Success).Any();
}
if (partialResultsContainsError)
{
results.AddRange(partialResults);
}
else
{
monthlyBudget.LoansPayments = null;
}
}
return(results);
}
