public IActionResult Create()
{
var categories = _categoryService.GetAll();
var categorySelectList = categories.Select(c => new SelectListItem
{
Text = c.Name,
Value = c.Id.ToString()
});
var viewModel = new TransactionViewModel();
viewModel.CategorySelectList = categorySelectList.ToList();
return(View("Create", viewModel));
}
public ActionResult Create(TransactionViewModel model)
{
if (ModelState.IsValid)
{
var result = Service.CreateTransaction(model.ToServiceModel(), ((OwnerModel)Session["SelectedAccount"]).Id);
if (result)
{
return(RedirectToAction("List"));
}
ModelState.AddModelError("", "Request could not be completed");
}
OnCreate();
return(View(model));
}
public async Task <TransactionViewModel> Update(int id, TransactionViewModel transaction)
{
try
{
TransactionDTO newTransaction = mapper.Map <TransactionDTO>(transaction);
TransactionDTO updatedTransaction = await transactionService.UpdateAsync(id, newTransaction);
return(mapper.Map <TransactionViewModel>(updatedTransaction));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async void ShouldNot_CreateNewTransactionAsync_Invalid()
{
var transactionViewModel = new TransactionViewModel
{
AccountId = 0.ToGuid().ToString(),
Amount = 0f,
Info = "Info"
};
var transactionDto = transactionViewModel.ToTransactionModel <TransactionDto>(1.ToGuid().ToString());
var newCreatedAccount = await _manager.CreateNewTransactionAsync(transactionDto);
Assert.Null(newCreatedAccount);
}
public ActionResult Create(TransactionViewModel obj)
{
var data = db.products.Find(obj.Products_id);
if (data.orginal_Qty > obj.saled_Qty)
{
if (obj.check == true)
{
transaction x = new transaction();
x.saled_Qty = obj.saled_Qty * 12;
x.saled_Price = (decimal)obj.saled_Price;
x.Products_id = obj.Products_id;
x.total_price = (obj.saled_Qty * 12) * ((decimal)obj.saled_Price);
x.date = DateTime.Now.ToString();
db.transactions.Add(x);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
transaction x = new transaction();
x.saled_Qty = obj.saled_Qty;
x.saled_Price = (decimal)obj.saled_Price;
x.Products_id = obj.Products_id;
x.total_price = (obj.saled_Qty) * ((decimal)obj.saled_Price);
x.date = DateTime.Now.ToString();
db.transactions.Add(x);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
else
{
ViewBag.name = new SelectList(db.products, "id", "name");
ViewBag.message = "هذا الصنف به عجز ";
return(View());
}
}
public async Task <IActionResult> ConvertMiles(TransactionViewModel model)
{
try
{
var user = await GetCurrentUser();
if (user == null)
{
return(RedirectToAction(nameof(AccountController.LoginClient), "Account"));
}
if (user.BonusMiles < model.Value)
{
throw new Exception("You do not have enough miles to complete this operation");
}
var operation = _transactionRepository.GetTransactionHistory(user);
if (operation + model.Value > 20000)
{
throw new Exception("Cannot complete this operation. The amount exceeds your maximum amount per year.");
}
var trans = _clientConverterHelper.CreateConversionTransaction(model, user);
trans.StartBalance = user.BonusMiles;
trans.EndBalance = user.BonusMiles;
user.StatusMiles += model.Value;
var result = await _userHelper.UpdateUserAsync(user);
if (!result.Succeeded)
{
throw new Exception("Cannot process this operation at the moment. Please try again later.");
}
var response = await _transactionRepository.AddTransanctionAsync(trans);
if (!response.Success)
{
//TODO enviar notificação para superuser ou admin para introduzir a transacção à mão
throw new Exception("Culpa do utilizador");
}
return(Json("Purchase successfull"));
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public ActionResult AccountDetails(int id)
{
BankDB.DataRepository db = new BankDB.DataRepository();
var transaction = db.GetTransactionsForAccount(id);
var account = db.GetAccount(id);
var viewModel = new TransactionViewModel
{
Account = account,
Transaction = transaction
};
return(PartialView(viewModel));
}
public IHttpActionResult PutTransaction(TransactionViewModel entity)
{
return(TryResult(
ResponseMessage(
Request
.CreateResponse(HttpStatusCode.OK,
entity != null &&
entity.TransactionModel != null &&
entity.TransactionDetailModel != null &&
_TransactionCRUDService.Update(entity.TransactionModel) &&
_TransactionDetailCRUDService.Update(entity.TransactionDetailModel) &&
_TransactionDetailCRUDService.Save())
)
));
}
public ActionResult Create(TransactionViewModel transactionModel)
{
transactionModel.CreatedDate = DateTime.UtcNow;
transactionModel.UpdatedDate = DateTime.UtcNow;
var model = _mapper.Map <TransactionModel>(transactionModel);
if (ModelState.IsValid)
{
_transactionService.Create(model);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult CreateSellTransaction()
{
var coins = _context.Coins.ToList();
var userID = User.Identity.GetUserId();
var portfolios = _context.Portfolios.Where(x => x.UserID == userID);
var ViewModel = new TransactionViewModel
{
Coins = coins,
Portfolios = portfolios
};
return(View(ViewModel));
}
public IActionResult Settle(Int64 Id)
{
TransactionViewModel viewModel = new TransactionViewModel();
if (Id > 0)
{
Transaction transaction = _unitOfWork.MerchantTransactionRepo.GetById(Id);
if (transaction != null)
{
viewModel = ModelAdapter.ModelMap(viewModel, transaction);
}
}
return(View(viewModel));
}
public void WithdrawalErrorTest(int amount, int from)
{
BankRepository.BankAccounts.Add(new Account()
{
AccountNumber = 1, Balance = 100
});
var model = new TransactionViewModel {
Amount = amount, From = from
};
var result1 = BankRepository.Withdraw(model);
Assert.False(result1);
}
public ActionResult TransactionDetails(int id)
{
var transaction = BLL.TransactionServices.GetById(id);
var transactionViewModel = new TransactionViewModel()
{
Descripcion = transaction.Description,
Fecha = transaction.TransactionDate,
Monto = transaction.Amount.ToString(),
Notas = transaction.Notes,
Transaccion = transaction.TransactionCode.ToString()
};
return(PartialView("TransactionDetails", transactionViewModel));
}
/// <summary>
/// Throw an exception if name is exist.
/// </summary>
/// <param name="model">Transaction view model</param>
public void ThrowExceptionIfExist(TransactionViewModel model)
{
ConditionFilter <Transaction, long> condition = new ConditionFilter <Transaction, long>
{
Query = (entity =>
//entity.Name == model.Name &&
entity.Id != model.Id)
};
var existEntity = this._TransactionsRepository.Get(condition).FirstOrDefault();
if (existEntity != null)
{
throw new ItemAlreadyExistException();
}
}
public SearchDashBoardViewModel(TransactionViewModel transactionDetails, TransferViewModel transferDetails)
: base(transactionDetails, transferDetails)
{
Icon = new MagnifyIcon();
TransactionRecords.CollectionChanged += (sender, args) => NotifyOfPropertyChange(() => Name);
Translator.CultureChanged += delegate
{
StartDate = DateTime.Now;
EndDate = StartDate;
NotifyOfPropertyChange(() => Name);
SearchStatus = Resources.Strings.PostingViewModelBase_SearchStatus_Search;
};
sourceAccountsViewSource.Source = accountsRepository.Entities;
}
public ActionResult Index()
{
TransactionViewModel model = new TransactionViewModel();
List <TransactionModel> list = this.SelectListModel();
if (list != null)
{
model.WalletModel = this.SelectWalletModel();
model.TransactionListModel.ListModel.AddRange(list);
model.TransactionListModel.PageSize = BaseController.pageSize;
model.TransactionListModel.Total = SelectTransactionCount();
}
return(View(model));
}
/// <summary>
/// Update an entity.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public TransactionViewModel Update(TransactionViewModel model)
{
this.ThrowExceptionIfExist(model);
var entity = model.ToEntity();
entity = this._TransactionsRepository.Update(entity);
#region Commit Changes
this._unitOfWork.Commit();
#endregion
model = entity.ToModel();
return(model);
}
public async Task <IActionResult> MakeIncome(int id)
{
var wallet = await walletWebService.Get(id);
var categories = await transactionWebService.GetIncomeCategories();
var transaction = new TransactionViewModel
{
TargetWalletId = (int)wallet.Id,
TargetWallet = wallet.Description
};
ViewBag.Categories = categories;
return(View(transaction));
}
public IActionResult Delete(Guid id, TransactionViewModel model)
{
try
{
_commandDispatcher.Execute(new TransactionRemoveCommand(id, model.OriginalVersion));
return(RedirectToAction("Index"));
}
catch (DomainValidationException validationException)
{
ModelState.AddModelError(validationException.Property, validationException.Message);
}
return(View(model));
}
public ActionResult Index(DateTime?startDate, DateTime?endDate)
{
var userName = this.User.Identity.Name;
var transactionViewModel = new TransactionViewModel()
{
UserName = userName,
StartDate = startDate,
EndDate = endDate
};
var allTrransactions = this.transactionService.GetClientTransactionsFromDateToDate(transactionViewModel);
return(this.View(allTrransactions));
}
public ActionResult Edit(int id, TransactionViewModel transaction)
{
try
{
//Updating transaction isfraud value
TransactionRepository transacRep = new TransactionRepository();
transacRep.SetIsFraud(transaction.Id, transaction.IsFraud);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View());
}
}
public async Task <TransactionViewModel> SaveTransactionAsync(int accountId, double amount)
{
TransactionViewModel newTransaction = null;
//mock asynchronous data saving to data source - only for exercise purposes!
await Task.Factory.StartNew(() =>
{
var transaction = new Transaction {
AccountId = accountId, Amount = amount
};
_data.Add(transaction);
newTransaction = AutoMapper.Mapper.Map <TransactionViewModel>(transaction);
});
return(newTransaction);
}
public string CreateTransaction(TransactionViewModel model)
{
var newTrans = new Transaction()
{
UsersTransaction = model.User,
TakerCompany = model.TakerCompany,
ReasonForPayment = model.ReasonForPaymont,
Date = model.Data,
Cash = model.Cash
};
db.Transactions.Add(newTrans);
db.SaveChanges();
return("You successful pay ");
}
public ActionResult Delete(TransactionViewModel model)
{
var deleteModel = _mapper.Map <TransactionModel>(model);
try
{
_transactionService.Delete(deleteModel);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult AddRecurringPayment(int id, TransactionViewModel model)
{
if (ModelState.IsValid)
{
var recurringTransaction = new RecurringTransaction
{
Name = model.Name,
StartDate = (DateTime)model.StartDate,
EndDate = model.EndDate,
PeriodId = (int)model.PeriodId,
};
db.RecurringTransactions.Add(recurringTransaction);
var transaction = new Transaction
{
Name = model.Name,
Amount = model.Amount,
Date = (DateTime)model.StartDate,
TrackerId = id,
PersonId = currentPersonId,
RecurringTransactionId = recurringTransaction.Id
};
db.Transactions.Add(transaction);
if (model.TagIds != null)
{
foreach (int t in model.TagIds)
{
var tag = new Transaction_Tag
{
TransactionId = transaction.Id,
TagId = t,
};
db.TransactionTags.Add(tag);
}
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
model.TagCollection = from t in db.Tags where t.PersonId == currentPersonId select t;
model.PeriodCollection = db.Periods.ToList <Period>();
model.Tracker = (from t in db.Trackers where t.Id == id select t).First();
return(PartialView(model));
}
}
public async Task <IActionResult> TransferMiles()
{
var user = await GetCurrentUser();
if (user == null)
{
return(RedirectToAction(nameof(AccountController.LoginClient), "Account"));
}
var model = new TransactionViewModel
{
Values = GetBlocks()
};
return(PartialView("_TransferMiles", model));
}
public TransactionViewModel ToTransactionViewModel(Transaction transaction, User user)
{
var model = new TransactionViewModel
{
Id = transaction.Id,
EndBalance = transaction.EndBalance,
//Todo PremiumOffer = transaction.Product.Title,
Price = transaction.Price,
StartBalance = transaction.StartBalance,
TransferTo = transaction.TransferTo,
Type = transaction.TransactionType,
Value = transaction.Value
};
return(model);
}
public ActionResult <Models.Transaction> Post([FromBody] TransactionViewModel transaction)
{
var user = rocketDbContext.Users.Find(transaction.UserId);
var newTransaction = new Models.Transaction {
Id = transaction.Id,
Type = transaction.Type,
Amount = transaction.Amount,
Comment = transaction.Comment,
User = user
};
rocketDbContext.Transactions.Add(newTransaction);
rocketDbContext.SaveChanges();
return(CreatedAtAction(nameof(Post), new { id = newTransaction.Id }, newTransaction));
}
public IActionResult TransferMoney(int accountId)
{
var account = _accountService.GetAccountById(accountId);
var customer = _customerService.GetCustomerByAccountId(account.AccountId);
var transactionModel = new TransactionViewModel
{
AccountId = account.AccountId,
CustomerId = customer.CustomerId,
Balance = account.Balance,
Name = customer.Givenname + " " + customer.Surname,
OperationList = LoadOperations(),
};
return(View(transactionModel));
}
public IActionResult Transfer(long id)
{
Transaction transaction = transactionRepository.GetTransaction(id);
TransactionViewModel model = new TransactionViewModel
{
transDate = transaction.transDate,
transAmount = transaction.transAmount,
fromAccount = transaction.fromAccount,
toAccount = transaction.toAccount,
typeId = transaction.typeId
};
transactionRepository.SaveTransaction(model);
return(View("Transfer"));
}
public async void PostValidTransactionReturnsSavedTransaction()
{
var user = UserHelper.BuildUser();
var catTypeOne = new CategoryType { Name = "Test" };
var catTypeTwo = new CategoryType { Name = "Test" };
var from = new Category { Name = "FromCategory", AccountingUser = user, CategoryType = catTypeTwo };
var to = new Category { Name = "ToCategory", AccountingUser = user, CategoryType = catTypeOne };
var transType = new TransactionType { Name = "Category", To = catTypeOne, From = catTypeTwo };
var server = StartupServer.Create();
server.Setup = async (context) =>
{
await UserHelper.CreateUser(context, user);
var dbCtx = context.RequestServices.GetRequiredService<AccountingContext>();
dbCtx.CategoryTypes.Add(catTypeOne);
dbCtx.CategoryTypes.Add(catTypeTwo);
dbCtx.Categories.Add(from);
dbCtx.Categories.Add(to);
dbCtx.TransactionTypes.Add(transType);
dbCtx.SaveChanges();
};
await server.RunSetup();
var transaction = new TransactionViewModel
{
FromId = from.Id,
ToId = to.Id,
TransactionTypeId = transType.Id,
DateTime = DateTime.UtcNow,
Total = 250
};
var cookies = await UserHelper.SignIn(server, user);
var result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies, method: HttpMethod.Post, body: transaction, tokens: true);
result.StatusCode.Should().Be(HttpStatusCode.Created, "because it created a resource");
result.ResponseText.Should().NotBeNullOrWhiteSpace("because it returns the created transaction");
var transResult = JsonConvert.DeserializeObject<TransactionViewModel>(result.ResponseText);
transResult.Total.Should().Be(transaction.Total, "because it should have the same total");
transResult.Id.Should().NotBe(0, "because the database should assign it a new id");
result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}/{transResult.Id}", cookieHeader: cookies);
transResult = JsonConvert.DeserializeObject<TransactionViewModel>(result.ResponseText);
transResult.Should().NotBeNull("because it should've persisted");
transResult.Total.Should().Be(transaction.Total, "because it should have the same total");
}
public async void PostValidTransactionSavesForUser()
{
var user = UserHelper.BuildUser();
var otherUser = UserHelper.BuildUser(username: "******", email: "*****@*****.**");
var catTypeOne = new CategoryType { Name = "Test" };
var catTypeTwo = new CategoryType { Name = "Test" };
var from = new Category { Name = "FromCategory", AccountingUser = user, CategoryType = catTypeTwo };
var to = new Category { Name = "ToCategory", AccountingUser = user, CategoryType = catTypeOne };
var transType = new TransactionType { Name = "Category", To = catTypeOne, From = catTypeTwo };
var server = StartupServer.Create();
server.Setup = async (context) =>
{
await UserHelper.CreateUser(context, user);
await UserHelper.CreateUser(context, otherUser);
var dbCtx = context.RequestServices.GetRequiredService<AccountingContext>();
dbCtx.CategoryTypes.Add(catTypeOne);
dbCtx.CategoryTypes.Add(catTypeTwo);
dbCtx.Categories.Add(from);
dbCtx.Categories.Add(to);
dbCtx.TransactionTypes.Add(transType);
dbCtx.SaveChanges();
};
await server.RunSetup();
var transaction = new TransactionViewModel
{
FromId = from.Id,
ToId = to.Id,
TransactionTypeId = transType.Id,
DateTime = DateTime.UtcNow,
Total = 250
};
var cookies = await UserHelper.SignIn(server, user);
var result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies, method: HttpMethod.Post, body: transaction, tokens: true);
result.StatusCode.Should().Be(HttpStatusCode.Created, "because it created a resource");
result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies);
var transactions = JsonConvert.DeserializeObject<List<TransactionViewModel>>(result.ResponseText);
transactions.Count.Should().Be(1, "because the created transaction should be associated with this user");
await UserHelper.SignOut(server, cookies);
cookies = await UserHelper.SignIn(server, otherUser);
result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies);
transactions = JsonConvert.DeserializeObject<List<TransactionViewModel>>(result.ResponseText);
transactions.Count.Should().Be(0, "because the created transaction shouldn't be associated with this user");
}
public async void PostInvalidTransactionWithoutTransactionTypeReturns400()
{
var user = UserHelper.BuildUser();
var from = new Category { Name = "FromCategory", AccountingUser = user };
var to = new Category { Name = "ToCategory", AccountingUser = user };
var server = StartupServer.Create();
server.Setup = async (context) =>
{
await UserHelper.CreateUser(context, user);
var dbCtx = context.RequestServices.GetRequiredService<AccountingContext>();
dbCtx.Categories.Add(from);
dbCtx.Categories.Add(to);
dbCtx.SaveChanges();
};
await server.RunSetup();
var transaction = new TransactionViewModel
{
FromId = from.Id,
ToId = to.Id,
TransactionTypeId = 0,
DateTime = DateTime.UtcNow,
Total = 700
};
var cookies = await UserHelper.SignIn(server, user);
var result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies, method: HttpMethod.Post, body: transaction, tokens: true);
result.StatusCode.Should().Be(HttpStatusCode.BadRequest, "because it was invalid");
result.ResponseText.Should().NotBeNullOrWhiteSpace("because it returns an error");
var error = JsonConvert.DeserializeObject<ErrorViewModel>(result.ResponseText);
error.Error.Should().ContainEquivalentOf(string.Format(TransactionErrors.ValidationErrors.TransactionTypeNotFoundError, transaction.TransactionTypeId), "because the transaction type doesn't exist");
}
public async void PostInvalidTransactionSameFromAndToCategoryReturns400()
{
var user = UserHelper.BuildUser();
var catTypeOne = new CategoryType { Name = "Test" };
var to = new Category { Name = "ToCategory", AccountingUser = user, CategoryType = catTypeOne };
var transType = new TransactionType { Name = "Category", To = catTypeOne, From = catTypeOne };
var server = StartupServer.Create();
server.Setup = async (context) =>
{
await UserHelper.CreateUser(context, user);
var dbCtx = context.RequestServices.GetRequiredService<AccountingContext>();
dbCtx.CategoryTypes.Add(catTypeOne);
dbCtx.Categories.Add(to);
dbCtx.TransactionTypes.Add(transType);
dbCtx.SaveChanges();
};
await server.RunSetup();
var transaction = new TransactionViewModel
{
FromId = to.Id,
ToId = to.Id,
TransactionTypeId = transType.Id,
DateTime = DateTime.UtcNow,
Total = 250
};
var cookies = await UserHelper.SignIn(server, user);
var result = await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies, method: HttpMethod.Post, body: transaction, tokens: true);
result.StatusCode.Should().Be(HttpStatusCode.BadRequest, "because it was invalid");
result.ResponseText.Should().NotBeNullOrWhiteSpace("because it returns an error");
var error = JsonConvert.DeserializeObject<ErrorViewModel>(result.ResponseText);
error.Error.Should().ContainEquivalentOf(TransactionErrors.ValidationErrors.TransactionToSameCategoryError);
}
public bool ValidateAndMapCreateTransaction(TransactionViewModel vm, Controller controller, string userId, out Transaction transaction, out ErrorViewModel errors)
{
var modelState = controller.ModelState;
transaction = null;
errors = null;
if (vm.Total == null || vm.Total <= 0)
{
errors = new ErrorViewModel { Error = TransactionErrors.ValidationErrors.TransactionInvalidTotalError };
return false;
}
var transactionType = this.transTypeRepo.FindById(vm.TransactionTypeId, tt => tt.From, tt => tt.To);
if (transactionType == null)
{
errors = new ErrorViewModel { Error = string.Format(TransactionErrors.ValidationErrors.TransactionTypeNotFoundError, vm.TransactionTypeId) };
return false;
}
if (vm.FromId == vm.ToId)
{
errors = new ErrorViewModel { Error = TransactionErrors.ValidationErrors.TransactionToSameCategoryError };
return false;
}
var fromCategory = this.categoryRepo.FindById(vm.FromId, c => c.CategoryType);
if (fromCategory == null || !string.Equals(fromCategory.AccountingUserId, userId))
{
errors = new ErrorViewModel { Error = string.Format(TransactionErrors.ValidationErrors.TransactionFromCategoryNotFoundError, vm.FromId) };
return false;
}
var toCategory = this.categoryRepo.FindById(vm.ToId, c => c.CategoryType);
if (toCategory == null || !string.Equals(toCategory.AccountingUserId, userId))
{
errors = new ErrorViewModel { Error = string.Format(TransactionErrors.ValidationErrors.TransactionToCategoryNotFoundError, vm.ToId) };
return false;
}
if (toCategory.CategoryType.Id != transactionType.To.Id || fromCategory.CategoryType.Id != transactionType.From.Id)
{
errors = new ErrorViewModel { Error = TransactionErrors.ValidationErrors.TransactionTypeCategoryTypeMismatchError };
return false;
}
if (!modelState.IsValid)
{
modelState.Clear();
controller.TryValidateModel(vm);
}
if (!modelState.IsValid)
{
errors = new ErrorViewModel
{
Error = TransactionErrors.ValidationErrors.TransactionInvalidError,
Errors = modelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage).ToList()
};
this.logger.LogWarning("Invalid transaction model:" + string.Join(";",
modelState.Values.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage)));
return false;
}
transaction = Mapper.Map<Transaction>(vm);
transaction.Id = 0;
transaction.Total = Math.Round(transaction.Total, 2);
transaction.From = fromCategory;
transaction.To = toCategory;
transaction.TransactionType = transactionType;
transaction.AccountingUserId = userId;
return true;
}
public async void PostValidTransactionWithoutTokensFails()
{
var user = UserHelper.BuildUser();
var from = new Category { Name = "FromCategory", AccountingUser = user };
var to = new Category { Name = "ToCategory", AccountingUser = user };
var transType = new TransactionType { Name = "Category" };
var server = StartupServer.Create();
server.Setup = async (context) =>
{
await UserHelper.CreateUser(context, user);
var dbCtx = context.RequestServices.GetRequiredService<AccountingContext>();
dbCtx.Categories.Add(from);
dbCtx.Categories.Add(to);
dbCtx.TransactionTypes.Add(transType);
dbCtx.SaveChanges();
};
await server.RunSetup();
var transaction = new TransactionViewModel
{
FromId = from.Id,
ToId = to.Id,
TransactionTypeId = transType.Id,
DateTime = DateTime.UtcNow,
Total = 250
};
var cookies = await UserHelper.SignIn(server, user);
Func<Task> action = async () =>
{
await TestServerHelper.SendAsync(server, $"{TestServerHelper.BaseUrl}/{transactionUrl}", cookieHeader: cookies, method: HttpMethod.Post, body: transaction);
};
await Assert.ThrowsAsync<InvalidOperationException>(action);
}