/// <summary>
/// Edit action for custom reports
/// </summary>
/// <param name="reportId">Identifier of the report to edit</param>
/// <returns>View with the custom report to edit</returns>
public async Task <IActionResult> EditCustomReport(int reportId)
{
var allCategories = await _categoryService.GetAllCategoriesForCurrentUser();
try
{
var report = await _customReportService.GetCustomReportByIdForCurrentUser(reportId);
var availableCategories = allCategories.Select(category => new BasicCheckBoxItem
{
Id = category.Id,
Name = category.Name,
Checked = report.Categories.Any(reportCategory => reportCategory.CategoryId == category.Id)
}).ToList();
return(View("UpsertCustomReport", new UpsertCustomReportModel
{
AvailableCategories = availableCategories,
CustomReport = report
}));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CustomReportNotFound);
return(View("Home", "Index"));
}
}
/// <summary>
/// Index action for account overview
/// </summary>
/// <param name="bankAccountId">Id of the bank account to show</param>
/// <returns>View containing the overview</returns>
public async Task <IActionResult> Index(int bankAccountId)
{
try
{
var bankAccount = await _bankAccountService.GetBankAccountByIdForCurrentUser(bankAccountId);
var transactions = await _transactionService.GetTransactionsForBankAccountForCurrentUser(bankAccountId, 200, skip : 0);
var availableCategories = await _categoryService.GetAllCategoriesForCurrentUser();
var model = new AccountOverviewViewModel
{
Account = bankAccount,
Transactions = transactions.Take(200).ToList(),
AccountBalance = bankAccount.CurrentBalance.GetValueOrDefault(),
AvailableCategories = availableCategories
};
return(View("index", model));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
return(RedirectToAction(actionName: "Index", controllerName: "Home"));
}
}
public async Task <IActionResult> UpsertTransaction(UpsertTransactionViewModel model)
{
if (ModelState.IsValid)
{
try
{
if (model.Transaction.Id > 0)
{
await _transactionService.UpdateTransactionForCurrentUser(model.Transaction);
return(Json(new SinanceJsonResult
{
Success = true
}));
}
else
{
await _transactionService.CreateTransactionForCurrentUser(model.Transaction);
return(Json(new SinanceJsonResult
{
Success = true
}));
}
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
}
}
return(PartialView("UpsertTransactionPartial", model));
}
public async Task <IActionResult> SaveImport(ImportModel model)
{
try
{
var(skippedTransactions, savedTransactions) = await _importService.SaveImport(model);
var message = string.Format(CultureInfo.CurrentCulture, Resources.TransactionsAddedAndSkippedFormat, savedTransactions, skippedTransactions);
TempDataHelper.SetTemporaryMessage(tempData: TempData,
state: savedTransactions != 0 ? MessageState.Success : MessageState.Warning,
message: message);
return(RedirectToAction("Index", "AccountOverview", new { @bankAccountId = model.BankAccountId }));
}
catch (NotFoundException exc)
{
if (exc.ItemName == nameof(ImportModel))
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.ImportTimeOut);
}
else
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
}
return(RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> Import(IFormFile file, ImportModel model)
{
try
{
using var stream = file.OpenReadStream();
await _importService.CreateImportPreview(stream, model);
return(View("ImportResult", model));
}
catch (NotFoundException exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.BankAccountNotFound);
return(RedirectToAction("Index"));
}
catch (ImportFileException exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.ErrorWhileProcessingImport);
return(RedirectToAction("Index"));
}
catch (Exception exc)
{
Log.Error(exc, "Exception during Import");
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, message: Resources.Error);
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Starts the edit action for a model
/// </summary>
/// <param name="transactionId">Id of the model to edit</param>
/// <returns>Partial view for editing the model</returns>
public async Task <IActionResult> EditTransaction(int transactionId)
{
try
{
var transaction = await _transactionService.GetTransactionByIdForCurrentUser(transactionId);
var userCategories = await _categoryService.GetAllCategoriesForCurrentUser();
var availableCategories = CreateAvailableCategoriesSelectList(userCategories);
var model = new UpsertTransactionViewModel
{
AvailableCategories = availableCategories,
Transaction = transaction
};
return(PartialView("UpsertTransactionPartial", model));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.TransactionNotFound);
}
return(View("Index"));
}
/// <summary>
/// Upserts a category mapping to the database
/// </summary>
/// <param name="model">Model to upsert</param>
/// <returns>Result of the upsert</returns>
public async Task <IActionResult> UpsertCategoryMapping(CategoryMappingModel model)
{
if (ModelState.IsValid)
{
// Placeholder extra validation, in the future all mappings should be possible
if (model.ColumnTypeId != ColumnType.Description &&
model.ColumnTypeId != ColumnType.Name &&
model.ColumnTypeId != ColumnType.DestinationAccount)
{
ModelState.AddModelError("", Resources.UnsupportedColumnTypeMapping);
return(PartialView("UpsertCategoryMapping", model));
}
if (model.Id > 0)
{
try
{
await _categoryMappingService.UpdateCategoryMappingForCurrentUser(model);
return(Json(new SinanceJsonResult
{
Success = true
}));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryMappingNotFound);
return(PartialView("UpsertCategoryMapping", model));
}
}
else
{
try
{
await _categoryMappingService.CreateCategoryMappingForCurrentUser(model);
return(Json(new SinanceJsonResult
{
Success = true
}));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
return(PartialView("UpsertCategoryMapping", model));
}
}
}
return(PartialView("UpsertCategoryMapping", model));
}
/// <summary>
/// Start an edit account action
/// </summary>
/// <param name="accountId">Id of account to edit</param>
/// <returns>Actionresult with details of the account</returns>
public async Task <IActionResult> EditAccount(int accountId)
{
try
{
var bankAccount = await _bankAccountService.GetBankAccountByIdForCurrentUser(accountId);
return(View("UpsertAccount", bankAccount));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Starts the process of editing a category mapping
/// </summary>
/// <param name="categoryMappingId">Category mapping to edit</param>
/// <returns>Partial view to edit the mapping</returns>
public async Task <IActionResult> EditCategoryMapping(int categoryMappingId)
{
try
{
var model = await _categoryMappingService.GetCategoryMappingByIdForCurrentUser(categoryMappingId);
return(PartialView("UpsertCategoryMapping", model));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryMappingNotFound);
return(View("Index"));
}
}
/// <summary>
/// Removes the given account
/// </summary>
/// <param name="accountId">Id of account to remove</param>
/// <returns>ActionResult with details of the remove action</returns>
public async Task <IActionResult> RemoveAccount(int accountId)
{
try
{
await _bankAccountService.DeleteBankAccountByIdForCurrentUser(accountId);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.BankAccountRemoved);
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.BankAccountNotFound);
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Deletes a model
/// </summary>
/// <param name="transactionId">Id of model to delete</param>
/// <returns>Result of the delete action</returns>
public async Task <IActionResult> DeleteTransaction(int transactionId, int bankAccountId)
{
try
{
await _transactionService.DeleteTransactionForCurrentUser(transactionId);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.TransactionDeleted);
return(RedirectToAction("Index", new { bankAccountId }));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.TransactionNotFound);
return(RedirectToAction("Index", "Home"));
}
}
/// <summary>
/// Removes a category mapping from the database
/// </summary>
/// <param name="categoryMappingId">Id of the mapping to remove</param>
/// <returns>Redirect to the edit category view</returns>
public async Task <IActionResult> RemoveCategoryMapping(int categoryMappingId, int categoryId)
{
try
{
await _categoryMappingService.DeleteCategoryMappingByIdForCurrentUser(categoryMappingId);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.CategoryMappingDeleted);
return(RedirectToAction("EditCategory", "Category", new { categoryId }));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryMappingNotFound);
return(RedirectToAction("Index", "Category"));
}
}
/// <summary>
/// Assigns the category to the previously previewed transactions
/// </summary>
/// <param name="categoryId">Id of the category to assign</param>
/// <returns>Redirect to the edit category action</returns>
public async Task <IActionResult> UpdateCategoryToMappedTransactions(int categoryId, IEnumerable <int> transactionIds)
{
try
{
await _categoryService.MapCategoryToTransactionsForCurrentUser(categoryId, transactionIds);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.CategoryMappingsAppliedToTransactions);
return(RedirectToAction("EditCategory", new { categoryId }));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Starts the add process for a new categorymapping
/// </summary>
/// <param name="categoryId">Id of the category to add the mapping to</param>
/// <returns>Partial view for adding the mapping</returns>
public async Task <IActionResult> AddCategoryMapping(int categoryId)
{
try
{
var categoryModel = await _categoryService.GetCategoryByIdForCurrentUser(categoryId);
return(PartialView("UpsertCategoryMapping", new CategoryMappingModel
{
CategoryName = categoryModel.Name,
CategoryId = categoryModel.Id
}));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
return(View("Index"));
}
}
/// <summary>
/// Removes the given category from the database
/// </summary>
/// <param name="categoryId">Id of category to remove</param>
/// <returns>Index page</returns>
public async Task <IActionResult> RemoveCategory(int categoryId)
{
try
{
await _categoryService.DeleteCategoryByIdForCurrentUser(categoryId);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.CategoryRemoved);
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
}
catch (DeleteStandardCategoryException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.DeleteStandardCategoryExceptionMessage);
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Upserts the category model to the database
/// </summary>
/// <param name="model">Model to upsert</param>
/// <returns>Index page and message if success</returns>
public async Task <IActionResult> UpsertCategory(UpsertCategoryModel model)
{
if (model.CategoryModel.Id > 0)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("EditCategory", new { model.CategoryModel.Id }));
}
try
{
await _categoryService.UpdateCategoryForCurrentUser(model.CategoryModel);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.CategoryUpdated);
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
}
}
else
{
if (!ModelState.IsValid)
{
return(RedirectToAction("AddCategory"));
}
try
{
await _categoryService.CreateCategoryForCurrentUser(model.CategoryModel);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.CategoryCreated);
}
catch (AlreadyExistsException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, string.Format(Resources.CategoryAlreadyExists, model.CategoryModel.Name));
}
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Upserts an account
/// </summary>
/// <param name="model">Model to use for upsert</param>
/// <returns>ActionResult with the outcome</returns>
public async Task <IActionResult> UpsertAccount(BankAccountModel model)
{
ActionResult result = View(model);
if (ModelState.IsValid)
{
try
{
if (model.Id > 0)
{
await _bankAccountService.UpdateBankAccountForCurrentUser(model);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.BankAccountCreated);
}
else
{
await _bankAccountService.CreateBankAccountForCurrentUser(model);
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Success, Resources.BankAccountUpdated);
}
}
catch (NotFoundException)
{
ModelState.AddModelError("Message", Resources.BankAccountNotFound);
}
catch (AlreadyExistsException)
{
ModelState.AddModelError("Message", Resources.BankAccountNotFound);
}
catch (ArgumentException exc)
{
ModelState.AddModelError("Message", exc.Message);
}
return(RedirectToAction("Index"));
}
return(result);
}
/// <summary>
/// Provides an actionresult for editing a new category
/// </summary>
/// <param name="categoryId">Id of category to edit</param>
/// <param name="includeTransactions">Include transactions or not for overview</param>
/// <returns>Actionresult for editing a new category</returns>
public async Task <IActionResult> EditCategory(int categoryId)
{
try
{
var category = await _categoryService.GetCategoryByIdForCurrentUser(categoryId);
var availableParentCategories = await CreateAvailableParentCategoriesSelectList(category);
var model = new UpsertCategoryModel
{
CategoryModel = category,
AvailableParentCategories = availableParentCategories
};
return(View("UpsertCategory", model));
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CategoryNotFound);
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Upserts a custom report to the database
/// </summary>
/// <param name="model">Model to upsert</param>
/// <returns>Redirect to the upserted custom report</returns>
public async Task <IActionResult> UpsertCustomReport(UpsertCustomReportModel model)
{
if (!ModelState.IsValid)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.Error);
}
if (model.CustomReport.Id > 0)
{
try
{
model.CustomReport.Categories = model.AvailableCategories.Where(x => x.Checked).Select(x => new CustomReportCategoryModel
{
CategoryId = x.Id
}).ToList();
await _customReportService.UpdateCustomReport(model.CustomReport);
}
catch (NotFoundException)
{
TempDataHelper.SetTemporaryMessage(TempData, MessageState.Error, Resources.CustomReportNotFound);
return(View("Home", "Index"));
}
}
else
{
model.CustomReport.Categories = model.AvailableCategories.Where(x => x.Checked).Select(x => new CustomReportCategoryModel
{
CategoryId = x.Id
}).ToList();
await _customReportService.CreateCustomReport(model.CustomReport);
}
return(RedirectToAction("CustomReport", new { reportId = model.CustomReport.Id }));
}