public IActionResult Store(CreateViewModel costInfoViewModel)
{
var costType = _expenseFacade.GetItemType(costInfoViewModel.TypeId);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (!ModelState.IsValid || costType == null || costType.AccountId != account.Id)
{
var model = new CreateViewModel()
{
CostTypes = GetAllCostTypes(),
};
return(View("Create", model));
}
var costInfo = Mapper.Map <CostInfo>(costInfoViewModel);
costInfo.AccountId = account.Id;
costInfo.Periodicity = Periodicity.None;
_expenseFacade.CreateItem(costInfo);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.ExpenseCreated }));
}
public IActionResult Update(EditViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectWithError(ExpenseManagerResource.UnknownError));
}
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var category = _expenseFacade.GetItemType(model.Id);
if (category == null || category.AccountId != account.Id)
{
return(RedirectWithError(ExpenseManagerResource.UnknownError));
}
var existingCategories = _expenseFacade.ListItemTypes(model.Name, account.Id, null);
if (existingCategories.Count > 0 && existingCategories.First().Id != category.Id)
{
return(RedirectToAction("Index", "Error", new { errorMessage = ExpenseManagerResource.CategoryExists }));
}
category.Name = model.Name;
_expenseFacade.UpdateItemType(category);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.CategoryEdited }));
}
public ActionResult DeleteConfirmed(int id)
{
CurrentAccountProvider currentAccountProvider = db.CurrentAcountProvider.Find(id);
db.CurrentAcountProvider.Remove(currentAccountProvider);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private List <Models.CostType.CategoryViewModel> GetAllCostTypes()
{
var accountId = CurrentAccountProvider.GetCurrentAccount(HttpContext.User).Id;
var costTypes = _expenseFacade.ListItemTypes(accountId);
var costTypeViewModels = Mapper.Map <List <Models.CostType.CategoryViewModel> >(costTypes);
return(costTypeViewModels);
}
/// <summary>
/// Index page
/// </summary>
/// <returns></returns>
public IActionResult Index()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var model = new IndexViewModel()
{
AchievedBadges = GetAchievedBadges(account),
NotAchievedBadges = GetNotAchievedBadges(account)
};
return(View(model));
}
public ActionResult Edit([Bind(Include = "IdCurrentAccountProvider,IdProvider,TotalDebt,CreatedDate")] CurrentAccountProvider currentAccountProvider)
{
if (ModelState.IsValid)
{
db.Entry(currentAccountProvider).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdProvider = new SelectList(db.Provider, "Id", "Name", currentAccountProvider.IdProvider);
return(View(currentAccountProvider));
}
/// <summary>
/// Displays all cost types for current account
/// </summary>
/// <returns></returns>
public IActionResult Index()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var model = new IndexViewModel()
{
Categories = Mapper.Map <List <CategoryViewModel> >(_expenseFacade.ListItemTypes(account.Id)),
CurrentUser = GetCurrentUser()
};
return(View(model));
}
public IActionResult Index()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var currentUserModel = Mapper.Map <Models.User.IndexViewModel>(CurrentAccountProvider.GetCurrentUser(HttpContext.User));
var model = new PermanentExpensesIndexViewModel()
{
Expenses = GetAllPermanentExpenses(account),
CurrentUser = currentUserModel
};
return(View(model));
}
/// <summary>
/// Displays all plans
/// </summary>
/// <returns></returns>
public IActionResult Index()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var model = new IndexViewModel()
{
AllPlans = GetAllPlans(account),
ClosablePlans = GetClosablePlans(account),
CurrentUser = Mapper.Map <Models.User.IndexViewModel>(CurrentAccountProvider.GetCurrentUser(HttpContext.User))
};
return(View(model));
}
public IActionResult Index()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var currentUserModel = Mapper.Map <IndexViewModel>(CurrentAccountProvider.GetCurrentUser(HttpContext.User));
var model = new AddAccessViewModel()
{
UsersWithAccess = GetAllUsersWithAccess(account),
CurrentUser = currentUserModel
};
return(View(model));
}
// GET: CurrentAccountProviders/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CurrentAccountProvider currentAccountProvider = db.CurrentAcountProvider.Find(id);
if (currentAccountProvider == null)
{
return(HttpNotFound());
}
return(View(currentAccountProvider));
}
public IActionResult Delete([FromForm] Guid id)
{
var plan = _balanceFacade.GetPlan(id);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (plan == null || plan.AccountId != account.Id)
{
return(RedirectWithError(ExpenseManagerResource.PlanNotDeleted));
}
_balanceFacade.DeletePlan(id);
return(RedirectToAction("Index", new { sucessMessage = ExpenseManagerResource.PlanDeleted }));
}
public IActionResult StoreAccount()
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (account != null)
{
return(RedirectWithError(ExpenseManagerResource.YouHaveAccount));
}
var user = CurrentAccountProvider.GetCurrentUser(HttpContext.User);
_accountFacade.CreateAccount(user.Id);
return(RedirectToAction("Index", "Expense", new { sucessMessage = ExpenseManagerResource.AccountCreated }));
}
// GET: CurrentAccountProviders/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CurrentAccountProvider currentAccountProvider = db.CurrentAcountProvider.Find(id);
if (currentAccountProvider == null)
{
return(HttpNotFound());
}
ViewBag.IdProvider = new SelectList(db.Provider, "Id", "Name", currentAccountProvider.IdProvider);
return(View(currentAccountProvider));
}
public IActionResult Delete(
[FromForm] Guid id,
[FromForm] string returnRedirect)
{
var costInfo = _expenseFacade.GetItem(id);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (costInfo == null || costInfo.AccountId != account.Id)
{
return(RedirectWithError(ExpenseManagerResource.ExpenseNotDeleted));
}
_expenseFacade.DeleteItem(id);
return(Redirect(returnRedirect));
}
public IActionResult Edit(Guid id)
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var category = _expenseFacade.GetItemType(id);
if (category == null || category.AccountId != account.Id)
{
return(RedirectWithError(ExpenseManagerResource.UnknownError));
}
var model = new EditViewModel()
{
Id = category.Id,
Name = category.Name
};
return(View(model));
}
/// <summary>
/// Displays expenses for loged-in user
/// </summary>
/// <returns></returns>
public IActionResult Index(IndexFilterViewModel filterModel)
{
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
PageInfo pageInfo = new PageInfo
{
PageNumber = filterModel.PageNumber ?? 1,
PageSize = NumberOfExpensesPerPage,
OrderByPropertyName = nameof(CostInfo.Created),
OrderByDesc = true
};
filterModel.Expenses = GetFilteredExpenses(account.Id, Periodicity.None, filterModel.DateFrom, filterModel.DateTo, filterModel.MoneyFrom, filterModel.MoneyTo, filterModel.CostTypeId, null, pageInfo);
filterModel.PageCount = (int)Math.Ceiling(_expenseFacade.GetCostInfosCount(account.Id, Periodicity.None, filterModel.DateFrom, filterModel.DateTo, filterModel.MoneyFrom, filterModel.MoneyTo, filterModel.CostTypeId, null) / (double)NumberOfExpensesPerPage);
filterModel.CostTypes = GetAllCostTypes();
filterModel.CurrentUser = Mapper.Map <Models.User.IndexViewModel>(CurrentAccountProvider.GetCurrentUser(HttpContext.User));
return(View(filterModel));
}
public IActionResult Store(CreatePermanentExpenseViewModel costInfoViewModel)
{
var costType = _expenseFacade.GetItemType(costInfoViewModel.TypeId);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (!ModelState.IsValid || costType == null || costType.AccountId != account.Id)
{
return(RedirectToAction("Create", new { errorMessage = ExpenseManagerResource.InvalidInputData }));
}
var costInfo = Mapper.Map <CostInfo>(costInfoViewModel);
costInfo.AccountId = account.Id;
_expenseFacade.CreateItem(costInfo);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.ExpenseCreated }));
}
public ActionResult Create(CreateProviderViewModel provider)
{
if (ModelState.IsValid)
{
var P = new CSales.Database.Models.Provider
{
Contact = provider.Contact,
IsActive = provider.IsActive,
Name = provider.Name,
IsForeignProvider = provider.IsForeignProvider,
};
this.db.Database.ExecuteSqlCommand(@"INSERT INTO PROVIDER(NAME, ISACTIVE, CONTACT, ISFOREIGNPROVIDER, BUSINESSNAME, CREATEDDATE) values ({0},{1},{2},{3},{4},{5})", provider.Name, provider.IsActive, provider.Contact, provider.IsForeignProvider, provider.IdBusinessName, DateTime.Now);
var newProv = this.db.Provider.OrderByDescending(x => x.Id).FirstOrDefault();
for (int i = 0; i < provider.Addresses.Count(); i++)
{
this.db.Database.ExecuteSqlCommand(@"INSERT INTO APRV(ADDRESSNAME,DESCRIPTION,IDPRV) values ({0},{1},{2})", provider.Addresses.ElementAt(i), "Descripcion default", newProv.Id);
}
for (int i = 0; i < provider.Telephones.Count(); i++)
{
this.db.Database.ExecuteSqlCommand(@"INSERT INTO TELPROV(NUMBER,DESCRIPTION,IDPRV) values ({0},{1},{2})", provider.Telephones.ElementAt(i), "Descripcion default", newProv.Id);
}
var cCorriente = new CurrentAccountProvider
{
CreatedDate = DateTime.Now,
IdProvider = newProv.Id,
TotalDebt = 0
};
this.db.CurrentAcountProvider.Add(cCorriente);
this.db.SaveChanges();
return(RedirectToAction("Index"));
}
this.ViewBag.IdBusinessName = new SelectList(db.BusinessName, "Id", "Name", provider.IdBusinessName);
return(View(provider));
}
/// <summary>
/// Marks given plan as finished
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public IActionResult Close([FromForm] Guid id)
{
var plan = _balanceFacade.GetPlan(id);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (plan == null || plan.AccountId != account.Id)
{
return(RedirectWithError(ExpenseManagerResource.PlanNotClosedDoesntExist));
}
try
{
_balanceFacade.ClosePlan(plan);
}
catch (Exception)
{
return(RedirectWithError(ExpenseManagerResource.PlanNotClosed));
}
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.PlanClosed }));
}
public IActionResult Store(CreateViewModel model)
{
var costType = _expenseFacade.GetItemType(model.PlannedTypeId);
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
if (!ModelState.IsValid || costType == null || costType.AccountId != account.Id)
{
ModelState.AddModelError(string.Empty, ExpenseManagerResource.InvalidInputData);
model.CostTypes = GetAllCostTypes();
return(View("Create", model));
}
var plan = Mapper.Map <Plan>(model);
plan.AccountId = account.Id;
plan.Start = DateTime.Now;
_balanceFacade.CreatePlan(plan);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.PlanCreated }));
}
public IActionResult Store(CreateViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index", "Error", new { errorMessage = ExpenseManagerResource.InvalidInputData }));
}
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
var existingCategories = _expenseFacade.ListItemTypes(model.Name, account.Id, null);
if (existingCategories.Count != 0)
{
return(RedirectToAction("Index", "Error", new { errorMessage = ExpenseManagerResource.CategoryExists }));
}
var costType = Mapper.Map <CostType>(model);
costType.AccountId = account.Id;
_expenseFacade.CreateItemType(costType);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.CategoryCreated }));
}
public IActionResult AddAccessToAccount(AddAccessViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectWithError(ExpenseManagerResource.InvalidInputData));
}
var user = GetUserFromEmail(model.Email);
if (user == null)
{
return(RedirectWithError(ExpenseManagerResource.EmailDoesntExist));
}
if (user.AccountId != Guid.Empty) // todo this might not be best check
{
return(RedirectWithError(ExpenseManagerResource.AlreadyHasAccount));
}
var account = CurrentAccountProvider.GetCurrentAccount(HttpContext.User);
_accountFacade.AttachAccountToUser(user.Id, account.Id, model.AccessType);
return(RedirectToAction("Index", new { successMessage = ExpenseManagerResource.AccessGranted }));
}
private Models.User.IndexViewModel GetCurrentUser()
{
return(Mapper.Map <Models.User.IndexViewModel>(CurrentAccountProvider.GetCurrentUser(HttpContext.User)));
}
