/// <summary>
/// Calculation and addition of the Automated Bank Charges field
/// </summary>
/// <param name="budgetId">The Id of the budget in question</param>
/// <returns>New Budget Transaction with a completed Automated Bank Charges Calculation</returns>
private BudgetTransaction AddAutomated(string budgetId)
{
double fees = 0;
foreach (Account acc in Collections.Accounts.Where(x => x.AccountType.Transactional))
{
fees = fees + acc.MonthlyFee;
double debt = acc.AccountLimit - acc.Available;
if (debt > 0)
{
fees = fees + debt * (acc.CreditRate / 12 / 100);
}
}
fees = Math.Round(fees, 2);
CFClassification classification = new CFClassification("Expense");
CFType typeT = new CFType("Bank Charges");
return(new BudgetTransaction
{
BudgetId = budgetId,
Automated = true,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = classification.Id,
CFClassification = classification,
CFType = typeT,
CFTypeId = typeT.Id,
Name = "Automated Bank Charges",
Amount = fees,
});
}
/// <summary>
/// Constuctor that returns a single CFClassification by Id or name
/// </summary>
/// <param name="id">The Id or name of the CFClassification</param>
public CFClassification(string id)
{
using (FinPlannerContext _context = new FinPlannerContext())
{
try {
CFClassification temp = _context.CFClassifications.Find(id);
Id = temp.Id;
Name = temp.Name;
Sign = temp.Sign;
if (temp == null)
{
temp = _context.CFClassifications.Where(x => x.Name == id).FirstOrDefault();
Id = temp.Id;
Name = temp.Name;
Sign = temp.Sign;
}
}
catch
{
try
{
CFClassification temp = _context.CFClassifications.Where(x => x.Name == id).FirstOrDefault();
Id = temp.Id;
Name = temp.Name;
Sign = temp.Sign;
}
catch
{
Id = "";
Name = "";
Sign = 0;
}
}
}
}
public List <ReportedTransaction> CleanNonTransactional(List <ReportedTransaction> reportedTransactions)
{
List <Account> accounts = reportedTransactions.Select(x => x.Account).Distinct().ToList();
List <ReportedTransaction> copy = new List <ReportedTransaction>(reportedTransactions.ToArray());
CFType type = new CFType();
List <CFType> types = new List <CFType>();
types.Add(new CFType("Loans"));
types.Add(new CFType("Car Loan"));
//4 phases
//Convert interst on transactional account to bank charges
CFType tempType = reportedTransactions.Select(x => x.CFType).Where(x => x.Name == "Bank Charges").FirstOrDefault();
foreach (ReportedTransaction item in copy.Where(x => x.Account.AccountType.Transactional == true && x.CFType.Name == "Interest"))
{
item.CFType = tempType;
}
//change bank charges and interest to the same CF Classification
CFClassification tempClassification = reportedTransactions.Select(x => x.CFClassification).Where(x => x.Sign == -1).FirstOrDefault();
foreach (ReportedTransaction item in copy.Where(x => x.Account.AccountType.Transactional == true && x.CFType.Name == "Bank Charges" && x.CFClassification.Sign == 1))
{
item.CFClassification = tempClassification;
item.Amount = item.Amount * -1;
}
// convert transfer to non tranasactional items to payments
foreach (ReportedTransaction item in copy.Where(x => x.Account.AccountType.Transactional && x.CFType.Id == "999"))
{
if (reportedTransactions.Where(x => x.Account.AccountType.Transactional == false && x.CFType.Id == "999" && x.Amount == item.Amount).Any())
{
ReportedTransaction transaction = reportedTransactions.Where(x => x.Account.AccountType.Transactional == false && x.CFType.Id == "999" && x.Amount == item.Amount).FirstOrDefault();
switch (transaction.Account.AccountType.Name)
{
case "Personal Loan":
item.CFType = types.Where(x => x.Name == "Loans").FirstOrDefault();
break;
case "Car Loan":
item.CFType = types.Where(x => x.Name == "Car Loan").FirstOrDefault();
break;
}
}
}
// strip out the non tranasactional accounts
foreach (Account item in accounts.Where(x => x.AccountType.Transactional == false))
{
foreach (ReportedTransaction t in reportedTransactions.Where(x => x.AccountId == item.Id))
{
copy.Remove(t);
}
}
foreach (ReportedTransaction item in copy)
{
item.Account = null;
}
return(copy);
}
public TransactionComparison(double spent, double budgeted, BudgetTransaction transaction)
{
CFClassification = new CFClassification(transaction.CFClassificationId);
CFType = new CFType(transaction.CFTypeId);
Budgeted = budgeted;
Spent = spent;
Remaining = budgeted - spent;
CFClassificationId = transaction.CFClassificationId;
CFTypeId = transaction.CFTypeId;
}
private ReportedTransaction(AutomatedCashFlow auto, Account account)
{
CFType = new CFType(auto.CFTypeId);
CFClassification = new CFClassification(auto.CFClassificationId);
Amount = auto.Amount;
DateCaptured = auto.DateCaptured;
SourceOfExpense = auto.SourceOfExpense;
Account = account;
Account.ManualCashFlows = null;
Account.AutomatedCashFlows = null;
DateBooked = auto.DateBooked;
Validated = auto.Validated;
}
private ReportedTransaction(ManualCashFlow manual, Account account)
{
CFType = new CFType(manual.CFTypeId);
CFClassification = new CFClassification(manual.CFClassificationId);
Amount = manual.Amount;
DateCaptured = manual.DateCaptured;
SourceOfExpense = manual.SourceOfExpense;
Account = account;
Account.ManualCashFlows = null;
Account.AutomatedCashFlows = null;
DateBooked = manual.DateBooked;
Validated = true;
}
public void BankCharges(Collections collection)
{
try
{
Budget budget = collection.Budgets.Where(x => x.Simulation == false).OrderByDescending(x => x.EndDate).First();
double fees = 0;
foreach (Account acc in collection.Accounts.Where(x => x.AccountType.Transactional == true))
{
fees = fees + acc.MonthlyFee;
double debt = acc.AccountLimit - acc.Available;
if (debt > 0)
{
fees = fees + debt * (acc.CreditRate / 12 / 100);
}
}
fees = Math.Round(fees, 2);
budget.GetBudgetTransacions();
using (FinPlannerContext _context = new FinPlannerContext())
{
if (budget.BudgetTransactions.Where(x => x.CFType.Name == "Bank Charges" && x.Automated == true).Any())
{
BudgetTransaction transaction = budget.BudgetTransactions.Where(x => x.CFType.Name == "Bank Charges" && x.Automated == true).FirstOrDefault();
transaction.Amount = fees;
_context.Entry(transaction).State = EntityState.Modified;
}
else
{
CFClassification classification = new CFClassification("Expense");
CFType type = new CFType("Bank Charges");
BudgetTransaction transaction = new BudgetTransaction()
{
BudgetId = budget.BudgetId,
Automated = true,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = classification.Id,
CFTypeId = type.Id,
Name = "Automated Bank Charges",
Amount = fees,
};
_context.Add(transaction);
}
_context.SaveChanges();
}
}
catch (Exception e)
{
ExceptionCatcher catcher = new ExceptionCatcher();
catcher.Catch(e.Message);
}
}
public ManualCashFlow(CFType cfId, CFClassification cfClass, double amount, DateTime dateBooked, string source, string userID, bool exp, string el)
{
CFType = cfId;
CFClassification = cfClass;
Amount = amount;
DateBooked = dateBooked;
DateCaptured = DateTime.Now;
SourceOfExpense = source;
Expected = exp;
Id = Guid.NewGuid().ToString();
UserId = userID;
isDeleted = false;
ExpenseLocation = el;
}
public void GetBudgetTransacions()
{
using (FinPlannerContext _context = new FinPlannerContext())
{
BudgetTransactions = _context.BudgetTransactions.Where(x => x.BudgetId == this.BudgetId).ToList();
}
CFClassification classification = new CFClassification();
List <CFClassification> classifications = classification.GetList();
CFType type = new CFType();
List <CFType> types = type.GetCFList(this.CollectionId);
foreach (BudgetTransaction item in BudgetTransactions)
{
item.CFClassification = classifications.Where(x => x.Id == item.CFClassificationId).FirstOrDefault();
item.CFType = types.Where(x => x.Id == item.CFTypeId).FirstOrDefault();
}
}
public void AddAccountChange(ManualCashFlow flow)
{
AccountChange change = new AccountChange();
change.AccountChangeId = Guid.NewGuid().ToString();
using (FinPlannerContext _context = new FinPlannerContext())
{
Account account = _context.Account.Find(flow.AccountId);
CFClassification classification = _context.CFClassifications.Find(flow.CFClassificationId);
change.UpdatedBalance = Math.Round(account.Available + (flow.Amount * classification.Sign), 2);
account.Available = change.UpdatedBalance;
change.DateAdded = DateTime.Now;
change.ManualCashFlowId = flow.Id;
_context.Entry(account).State = EntityState.Modified;
_context.AccountChange.Add(change);
_context.SaveChanges();
}
}
public List <Account> GetAccountsWithCF(string collectionsId, int count)
{
CFClassification classification = new CFClassification();
List <CFClassification> classifications = classification.GetList();
List <Account> accounts = GetAccountsEmpty(collectionsId);
Institution institution = new Institution();
List <Institution> institutions = institution.GetInstitutions();
AccountType type = new AccountType();
List <AccountType> types = type.GetAccountTypes();
ManualCashFlow manual = new ManualCashFlow();
AutomatedCashFlow automated = new AutomatedCashFlow();
Collections collection = new Collections();
foreach (Account item in accounts)
{
item.Institution = institutions
.Where(x => x.Id == item.InstitutionId)
.FirstOrDefault();
item.AccountType = types
.Where(x => x.AccountTypeId == item.AccountTypeId)
.FirstOrDefault();
item.AccountType.Accounts = null;
item.ManualCashFlows = manual.GetManualCashFlows(item.Id, count);
item.AutomatedCashFlows = automated.GetAutomatedCashFlows(item.Id, count);
foreach (ManualCashFlow flow in item.ManualCashFlows)
{
flow.CFClassification = classifications.Where(x => x.Id == flow.CFClassificationId).FirstOrDefault();;
flow.CFClassification.ManualCashFlows = null;
}
foreach (AutomatedCashFlow flow in item.AutomatedCashFlows)
{
flow.CFClassification = classifications.Where(x => x.Id == flow.CFClassificationId).FirstOrDefault();;
flow.CFClassification.ManualCashFlows = null;
}
item.Collections = collection.GetCollections(collectionsId);
//foreach(ManualCashFlow flow in item.ManualCashFlows)
//{
// flow.Account.ManualCashFlows = null;
//}
}
return(accounts);
}
public UnseenModel(string userId)
{
AspNetUsers users = new AspNetUsers();
string id = users.getUserId(userId);
using (FinPlannerContext _context = new FinPlannerContext())
{
List <string> collections = _context
.UserCollectionMapping
.Where(x => x.Id == id)
.Select(x => x.CollectionsId)
.ToList();
List <string> accountsStr = _context
.Account
.Where(Acc => collections.Contains(Acc.CollectionsId))
.Select(x => x.Id)
.ToList();
Account account = new Account();
Accounts = new List <Account>();
foreach (string item in collections)
{
Accounts
.AddRange(account.GetAccounts(item));
}
AutomatedCashFlow automatedCash = new AutomatedCashFlow();
ManualCashFlow manualCash = new ManualCashFlow();
CFType type = new CFType();
CFClassification classification = new CFClassification();
AutomatedCashFlows = automatedCash
.GetAutomatedCashFlowsUnseen(accountsStr);
ManualCashFlows = manualCash
.GetManualCahFlowsUnseen(accountsStr);
CFTypes = type
.GetCFList(collections)
.GroupBy(x => x.Id)
.Select(x => x.First())
.ToList();
CFClassifications = classification
.GetList();
}
}
public List <ReportedTransaction> GetTransactions(List <string> accountIds, int count, List <string> collectionsIds)
{
//get transaction
List <ManualCashFlow> manualCashFlows = new List <ManualCashFlow>();
List <AutomatedCashFlow> automatedCashFlows = new List <AutomatedCashFlow>();
using (FinPlannerContext _context = new FinPlannerContext())
{
manualCashFlows = _context
.ManualCashFlows
.Where(cf => accountIds.Contains(cf.AccountId))
.Where(x => x.AutomatedCashFlow == null)
.OrderByDescending(x => x.DateBooked)
.Take(count)
.ToList();
automatedCashFlows = _context
.AutomatedCashFlows
.Where(cf => accountIds.Contains(cf.AccountId))
.OrderByDescending(x => x.DateBooked)
.Take(count)
.ToList();
}
//get type and classification lists
CFType type = new CFType();
CFClassification classification = new CFClassification();
List <CFType> types = type.GetCFList(collectionsIds);
List <CFClassification> classifications = classification.GetList();
//reconfigure cash flows
List <ReportedTransaction> transactions = new List <ReportedTransaction>();
foreach (AutomatedCashFlow item in automatedCashFlows)
{
transactions.Add(new ReportedTransaction(item, types, classifications));
}
foreach (ManualCashFlow item in manualCashFlows)
{
transactions.Add(new ReportedTransaction(item, types, classifications));
}
return(transactions);
} /// <summary>
/// <summary>
/// Return a specific instance of the object
/// </summary>
/// <param name="Id">Id of the instance</param>
public SimulationAssumptions(string Id)
{
using (FinPlannerContext _context = new FinPlannerContext())
{
SimulationAssumptions a = _context.SimulationAssumptions.Find(Id);
SimulationAssumptionsId = a.SimulationAssumptionsId;
NumberOfMonths = a.NumberOfMonths;
Bonus = a.Bonus;
BonusMonth = a.BonusMonth;
BonusAmount = a.BonusAmount;
Increase = a.Increase;
IncreaseMonth = a.IncreaseMonth;
IncreasePercentage = a.IncreasePercentage;
Recurring = a.Recurring;
ChangeDate = a.ChangeDate;
CFClassification = new CFClassification(a.CFClassificationId);
CFClassificationId = a.CFClassificationId;
CFType = new CFType(a.CFTypeId);
CFTypeId = a.CFTypeId;
Type = a.Type;
SimualtionName = a.SimualtionName;
}
}
public ReturnModel AddTransfer(TransferObject obj)
{
CFClassification classification = new CFClassification();
List <CFClassification> classifications = classification.GetList();
ManualCashFlow to = new ManualCashFlow()
{
Id = Guid.NewGuid().ToString(),
CFClassificationId = classifications.Where(x => x.Sign == 1).Select(x => x.Id).FirstOrDefault(),
CFTypeId = "999",
Amount = obj.Amount,
SourceOfExpense = "Transfer",
Description = "Transfer",
DateBooked = obj.DateBooked,
DateCaptured = DateTime.Now,
AccountId = obj.TransferTo,
};
ManualCashFlow from = new ManualCashFlow()
{
Id = Guid.NewGuid().ToString(),
CFClassificationId = classifications.Where(x => x.Sign == -1).Select(x => x.Id).FirstOrDefault(),
CFTypeId = "999",
SourceOfExpense = "Transfer",
Description = "Transfer",
Amount = obj.Amount,
DateBooked = obj.DateBooked,
DateCaptured = DateTime.Now,
AccountId = obj.TransferFrom,
};
to.Save();
from.Save();
return(new ReturnModel()
{
result = true
});
}
private void Build()
{
this.Collections = new Collections(this.CollectionsId);
// Get base information
Budget budget = Collections.Budgets.Where(x => x.Simulation == false).OrderByDescending(x => x.StartDate).FirstOrDefault();
this.Collections.Budgets = null;
Account account = new Account();
this.Collections.Accounts = account.GetAccounts(this.CollectionsId);
foreach (Account acc in Collections.Accounts)
{
acc.ReportedTransactions = null;
acc.AutomatedCashFlows = null;
acc.ManualCashFlows = null;
acc.Institution = null;
}
//this.SimulationAssumptions = new SimulationAssumptions(SimulationAssumptionsId);
this.Budgets = new List <Budget>();
CFClassification cf = new CFClassification();
List <CFClassification> cfList = cf.GetList();
CFType type = new CFType();
List <CFType> typeList = type.GetCFList(CollectionsId);
switch (this.Collections.DurationType)
{
case "Month":
// Get Date of starting
DateTime date = DateTime.Now;
date = new DateTime(date.Year, date.Month, this.Collections.ResetDay);
if (date > DateTime.Now)
{
date.AddMonths(1);
}
// Set Simulation Object
Simulation simulation = new Simulation();
// Loop for the number of Months
for (int i = 0; i < SimulationAssumptions.NumberOfMonths; i++)
{
Budget sim = new Budget(CollectionsId, date.AddMonths(i), date.AddMonths(i + 1), true);
sim.AccountStates = new List <AccountState>();
// If first month, then pull BudgetTransactions from actual BudgetTransactions ELSE pull from previous month
if (i == 0)
{
sim.BudgetTransactions = budget.BudgetTransactions.Where(x => x.Automated == false).ToList();
foreach (BudgetTransaction item in sim.BudgetTransactions)
{
item.CFClassification = cfList.Where(x => x.Id == item.CFClassificationId).FirstOrDefault();
item.CFType = typeList.Where(x => x.Id == item.CFTypeId).FirstOrDefault();
}
foreach (Account item in Collections.Accounts)
{
sim.AccountStates.Add(new AccountState(item, sim.BudgetId));
}
}
else
{
sim.BudgetTransactions = this.Budgets[i - 1].BudgetTransactions.Where(x => x.Automated == false).ToList();
foreach (BudgetTransaction item in sim.BudgetTransactions)
{
item.CFClassification = cfList.Where(x => x.Id == item.CFClassificationId).FirstOrDefault();
}
foreach (Account item in this.Collections.Accounts)
{
sim.AccountStates.Add(new AccountState(item, sim.BudgetId, this
.Budgets[i - 1]
.AccountStates
.Where(x => x.AccountId == item.Id)
.FirstOrDefault()));
}
}
//=======================================================================================================================================================
// Bonus Handling
//=======================================================================================================================================================
// Add Bonus multiple if the correct month
if (SimulationAssumptions.Bonus && SimulationAssumptions.BonusMonth == date.AddMonths(i).Month)
{
foreach (BudgetTransaction transaction in sim.BudgetTransactions.Where(x => x.CFType.Name == "Salary"))
{
transaction.Amount = transaction.Amount * SimulationAssumptions.BonusAmount;
}
}
// Strip Bonus Amount out if following Month
if (SimulationAssumptions.Bonus && SimulationAssumptions.BonusMonth == date.AddMonths(i + 1).Month)
{
foreach (BudgetTransaction transaction in sim.BudgetTransactions.Where(x => x.CFType.Name == "Salary"))
{
transaction.Amount = this.Budgets[i - 1].BudgetTransactions.Where(x => x.Name == transaction.Name).Select(x => x.Amount).FirstOrDefault();
}
}
//=======================================================================================================================================================
// Increase Handling
//=======================================================================================================================================================
// Add Increase if correct month (only add apportionment of previous month if not bonus month)
if (SimulationAssumptions.Increase && SimulationAssumptions.IncreaseMonth == date.AddMonths(i).Month)
{
// if Bonus month == Increase month then use previous month
if (SimulationAssumptions.IncreaseMonth == SimulationAssumptions.BonusMonth)
{
foreach (BudgetTransaction transaction in sim.BudgetTransactions.Where(x => x.CFType.Name == "Salary"))
{
transaction.Amount = this
.Budgets[i - 1]
.BudgetTransactions.Where(x => x.Name == transaction.Name)
.Select(x => x.Amount)
.FirstOrDefault()
* (1 + SimulationAssumptions.IncreasePercentage);
}
}
else
{
foreach (BudgetTransaction transaction in sim.BudgetTransactions.Where(x => x.CFType.Name == "Salary"))
{
transaction.Amount = transaction.Amount * (1 + SimulationAssumptions.IncreasePercentage);
}
}
}
//=======================================================================================================================================================
// Inflation Handling
//=======================================================================================================================================================
if (date.AddMonths(i).Month == 1)
{
foreach (BudgetTransaction item in sim.BudgetTransactions.Where(x => x.CFType.Infaltion))
{
item.Amount = item.Amount * 1.06;
}
}
//=======================================================================================================================================================
// Cashflow Handling
//=======================================================================================================================================================
if (i > 0)
{
//double fees = 0;
//foreach(Account acc in Collections.Accounts.Where(x=>x.AccountType.Transactional))
//{
// fees = fees + acc.MonthlyFee;
// double debt = acc.AccountLimit - acc.Available;
// if (debt > 0)
// {
// fees = fees + debt * (acc.CreditRate / 12 / 100);
// }
//}
//fees = Math.Round(fees, 2);
//CFClassification classification = new CFClassification("Expense");
//CFType typeT = new CFType("Bank Charges");
//sim.BudgetTransactions.Add(new BudgetTransaction
//{
// BudgetId = sim.BudgetId,
// Automated = true,
// BudgetTransactionId = Guid.NewGuid().ToString(),
// CFClassificationId = classification.Id,
// CFClassification = classification,
// CFType = typeT,
// CFTypeId = typeT.Id,
// Name = "Automated Bank Charges",
// Amount = fees,
//});
sim.BudgetTransactions.Add(AddAutomated(sim.BudgetId));
sim.AccountStates
.Where(x => x.Amount < 0 && x.Account.AccountType.Transactional)
.OrderByDescending(x => x.Account.CreditRate)
.FirstOrDefault()
.Update(sim.BudgetTransactions.Sum(x => x.Amount * x.CFClassification.Sign));
}
this.Budgets.Add(sim);
}
break;
}
}
private void Payment()
{
CFClassification cf = new CFClassification();
List <CFClassification> cfList = cf.GetList();
CFType type = new CFType();
List <CFType> typeList = type.GetCFList(CollectionsId);
if (SimulationAssumptions.Recurring)
{
for (int i = 0; i < SimulationAssumptions.NumberOfMonths; i++)
{
Budgets[i].BudgetTransactions.Add(new BudgetTransaction
{
Amount = SimulationAssumptions.Amount,
Automated = true,
BudgetId = Budgets[i].BudgetId,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = cfList.Where(x => x.Sign == 1).FirstOrDefault().Id,
CFClassification = cfList.Where(x => x.Sign == 1).FirstOrDefault(),
CFTypeId = "999",
CFType = typeList.Where(x => x.Id == "999").FirstOrDefault(),
Name = "Recurring Payment",
});
Budgets[i].BudgetTransactions.Add(new BudgetTransaction
{
Amount = SimulationAssumptions.Amount,
Automated = true,
BudgetId = Budgets[i].BudgetId,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = cfList.Where(x => x.Sign == 1).FirstOrDefault().Id,
CFClassification = cfList.Where(x => x.Sign == -1).FirstOrDefault(),
CFTypeId = "999",
CFType = typeList.Where(x => x.Id == "999").FirstOrDefault(),
Name = "Recurring Payment",
});
Budgets[i].AccountStates
.Where(x => x.Amount < 0 && x.Account.AccountType.Transactional)
.OrderByDescending(x => x.Account.CreditRate)
.FirstOrDefault()
.Update(-SimulationAssumptions.Amount);
Budgets[i].AccountStates
.Where(x => x.AccountId == SimulationAssumptions.AccountId)
.FirstOrDefault()
.Update(SimulationAssumptions.Amount);
}
}
else
{
for (int i = 0; i < SimulationAssumptions.NumberOfMonths; i++)
{
if (SimulationAssumptions.ChangeDate == Budgets[i].StartDate)
{
Budgets[i].BudgetTransactions.Add(new BudgetTransaction
{
Amount = SimulationAssumptions.Amount,
Automated = true,
BudgetId = Budgets[i].BudgetId,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = cfList.Where(x => x.Sign == 1).FirstOrDefault().Id,
CFClassification = cfList.Where(x => x.Sign == 1).FirstOrDefault(),
CFTypeId = "999",
CFType = typeList.Where(x => x.Id == "999").FirstOrDefault(),
Name = "Recurring Payment",
});
Budgets[i].BudgetTransactions.Add(new BudgetTransaction
{
Amount = SimulationAssumptions.Amount,
Automated = true,
BudgetId = Budgets[i].BudgetId,
BudgetTransactionId = Guid.NewGuid().ToString(),
CFClassificationId = cfList.Where(x => x.Sign == 1).FirstOrDefault().Id,
CFClassification = cfList.Where(x => x.Sign == -1).FirstOrDefault(),
CFTypeId = "999",
CFType = typeList.Where(x => x.Id == "999").FirstOrDefault(),
Name = "Recurring Payment",
});
Budgets[i].AccountStates
.Where(x => x.Amount < 0 && x.Account.AccountType.Transactional)
.OrderByDescending(x => x.Account.CreditRate)
.FirstOrDefault()
.Update(-SimulationAssumptions.Amount);
Budgets[i].AccountStates
.Where(x => x.AccountId == SimulationAssumptions.AccountId)
.FirstOrDefault()
.Update(SimulationAssumptions.Amount);
}
}
}
}
public async Task <bool> UpdateTransactions()
{
//Invoke Classes
CFClassification classification = new CFClassification();
YodleeTransactionModel transactionModel = new YodleeTransactionModel();
Collections collection = new Collections();
YodleeTransactionType transactionType = new YodleeTransactionType();
ManualCashFlow manualCash = new ManualCashFlow();
AutomatedCashFlow automatedCashFlow = new AutomatedCashFlow();
//Get Static Lists
List <Collections> collections = collection.GetCollections("", "");
List <CFClassification> classifications = classification.GetList();
foreach (Collections item in collections.Where(x => x.Accounts.Any()))
{
AutomateReturnList returnList = new AutomateReturnList();
returnList.automateReturns = new List <AutomateReturn>();
if (item.Accounts.Where(x => x.AccountIdentifier != null).Any())
{
YodleeModel yodlee = new YodleeModel();
string token = await yodlee.getToken(item.CollectionsId, "");
List <YodleeTransactionLevel> transactions = await transactionModel.GetYodleeTransactions(item.CollectionsId, token);
if (transactions != null)
{
DateTime smallest = transactions.Select(x => x.transactionDate).Min();
if (smallest > DateTime.MinValue)
{
smallest = smallest.AddDays(-3);
}
List <CFType> yodleeTypes = await transactionType.YodleeTransform(token, item.CollectionsId);
foreach (Account account in item.Accounts.Where(x => x.YodleeId != 0))
{
Account tempAccount = account;
List <ManualCashFlow> manualFlows = manualCash.GetManualCashFlows(account.Id);
foreach (ManualCashFlow m in manualFlows)
{
m.CFClassification = classifications.Where(x => x.Id == m.CFClassificationId).FirstOrDefault();
}
account.AutomatedCashFlows = automatedCashFlow.GetAutomatedCashFlows(account.Id, smallest, DateTime.Now.AddDays(1));
foreach (YodleeTransactionLevel transaction in transactions.Where(x => x.accountId == account.YodleeId))
{
if (!account.AutomatedCashFlows.Where(x => x.YodleeId == transaction.id).Any())
{
ManualCashFlow manualCashFlow = manualFlows
.Where(x => x.AutomatedCashFlowId == null)
.Where(x => x.Amount == transaction.amount.amount && x.CFClassification.Name.ToLower() == transaction.categoryType.ToLower() && x.DateBooked > transaction.transactionDate.AddDays(-2) && x.DateBooked < transaction.transactionDate.AddDays(5))
.FirstOrDefault();
try
{
returnList.automateReturns.Add(AddTransaction(transaction, account.Id, yodleeTypes, manualCashFlow, classifications, tempAccount));
}
catch (Exception e)
{
ExceptionCatcher catcher = new ExceptionCatcher();
catcher.Catch(e.Message + ";" + JsonConvert.SerializeObject(transaction) + ";" + JsonConvert.SerializeObject(manualCashFlow) + "");
}
if (manualCashFlow != null)
{
manualFlows.Remove(manualCashFlow);
}
}
}
//item.Accounts.Where(x=>x.Id == account.Id).FirstOrDefault() = tempAccount;
}
try
{
List <AccountChange> accChangeList = new List <AccountChange>();
List <AutomatedCashFlow> cashFlows = new List <AutomatedCashFlow>();
List <ManualCashFlow> manualCashFlows = new List <ManualCashFlow>();
//ac
foreach (AutomateReturn returnItem in returnList.automateReturns)
{
if (returnItem.AccountChange.AccountChangeId != "")
{
returnItem.AccountChange.Account = null;
returnItem.AccountChange.AutomatedCashFlow = null;
accChangeList.Add(returnItem.AccountChange);
}
returnItem.AutomatedCashFlow.Account = null;
returnItem.AutomatedCashFlow.CFClassification = null;
cashFlows.Add(returnItem.AutomatedCashFlow);
if (returnItem.ManualCashFlow.Id != "")
{
manualCashFlows.Add(returnItem.ManualCashFlow);
}
}
using (FinPlannerContext _context = new FinPlannerContext())
{
_context.AccountChange.AddRange(accChangeList);
_context.AutomatedCashFlows.AddRange(cashFlows);
foreach (ManualCashFlow manual in manualCashFlows)
{
_context.Entry(manual).State = EntityState.Modified;
}
_context.SaveChanges();
}
}
catch (Exception e)
{
ExceptionCatcher catcher = new ExceptionCatcher();
catcher.Catch(e.Message);
}
}
}
}
return(true);
}
