public void ShouldReturnBadRequestWhenUploadedFileExtensionIsWrong()
{
var formFileConfig = new Mock <IFormFile>();
var dataContextConfig = new Mock <DataContext>();
var mappingServiceProviderConfig = new Mock <IMappingServiceProvider>();
var validationConfigs = new IValidationConfiguration[] { new TransactionXmlValidationConfiguration(), new TransactionCsvValidationConfiguration() };
var validationService = new ValidationService(validationConfigs);
var transactionManager = new TransactionManager(null, validationService, mappingServiceProviderConfig.Object);
var buffer = Encoding.UTF8.GetBytes(wrongxml);
var memoryStream = new MemoryStream(buffer);
formFileConfig.SetupGet(mockSetup => mockSetup.Length).Returns(1024 * 1024);
formFileConfig.SetupGet(mockSetup => mockSetup.ContentType).Returns("text/xml");
formFileConfig.SetupGet(mockSetup => mockSetup.FileName).Returns("file.with a wrong extension");
formFileConfig.Setup(mockSetup => mockSetup.OpenReadStream()).Returns(memoryStream);
var controller = new TransactionController(transactionManager);
var result = controller.Upload(formFileConfig.Object) as BadRequestObjectResult;
var isExpected = result != null && ((List <string>)result.Value).Contains("Unknown format");
Assert.IsTrue(isExpected);
}
public void BalanceIsCorrectAfterDeposit()
{
var fakeDb = new FakeApplicacionDbContext();
fakeDb.CheckingAccounts = new FakeDbSet <CheckingAccount>();
var checkingAccount = new CheckingAccount
{
Id = 1,
AccountNumber = "000123TEST",
Balance = 0,
};
fakeDb.CheckingAccounts.Add(checkingAccount);
fakeDb.Transactions = new FakeDbSet <Transaction>();
var transactionController = new TransactionController(fakeDb);
transactionController.Deposit(new Transaction
{
CheckingAccountId = 1,
Amount = 25
});
Assert.AreEqual(25, checkingAccount.Balance);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
if (Session["userid"] != null)
{
if (Session["userRole"].ToString() != "Administrator")
{
Response.Redirect("Home.aspx");
}
else
{
ReportDocument rpdoc = new ReportDocument();
rpdoc.Load(Server.MapPath("~/Report/CrystalReport1.rpt"));
DataSet1 ds = TransactionController.getDataSetForReport();
rpdoc.SetDataSource(ds);
TransactionReportViewer.ReportSource = rpdoc;
}
}
else
{
Response.Redirect("Home.aspx");
}
}
}
public async void Patch_No_Errors()
{
TransactionControllerMockFacade mock = new TransactionControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiTransactionResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTransactionRequestModel>()))
.Callback <int, ApiTransactionRequestModel>(
(id, model) => model.Amount.Should().Be(1m)
)
.Returns(Task.FromResult <UpdateResponse <ApiTransactionResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiTransactionResponseModel>(new ApiTransactionResponseModel()));
TransactionController controller = new TransactionController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiTransactionModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiTransactionRequestModel>();
patch.Replace(x => x.Amount, 1m);
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTransactionRequestModel>()));
}
public MainWindow()
{
InitializeComponent();
// logging
logger.Info("Initialising main window");
// customer state combo box
comboBox_customerState.Items.Add("NSW");
comboBox_customerState.Items.Add("Vic");
comboBox_customerState.Items.Add("Qld");
comboBox_customerState.Items.Add("ACT");
comboBox_customerState.Items.Add("NT");
comboBox_customerState.Items.Add("SA");
comboBox_customerState.Items.Add("WA");
comboBox_customerState.Items.Add("Other");
// TODO: implement this
scriptingToolStripMenuItem.Enabled = false;
listView_sales.GridLines = true;
setUI();
// controller dependency injection
transController = new TransactionController();
// set title
this.Text = "Retail POS v" + Configuration.VERSION;
}
public async Task GetTransaction_ValidInput_ReturnsOkResult()
{
var customerid = 1001;
List <Financial_Transactions> transaction;
transaction = new List <Financial_Transactions>()
{
new Financial_Transactions
{
Transaction_Id = 5,
Account_Id = 1001,
Counterparty_Id = 1,
Payment_Method_Code = "PMCode1",
Service_Id = 1,
Transaction_Status_Code = "TSC02",
Transaction_Type_Code = "T01",
Date_of_Transaction = DateTime.Now,
Amount_of_Transaction = 1000
}
};
mockservice.Setup(s => s.GetTransactions(customerid)).ReturnsAsync(transaction);
TransactionController control = new TransactionController(mockservice.Object);
var result = await control.GetTransactions(customerid);
var okresult = (IStatusCodeActionResult)result;
Assert.AreEqual(200, okresult.StatusCode);
}
public MainWindow()
{
InitializeComponent();
// logging
logger.Info("Initialising main window");
// customer state combo box
// prepare the customer state comboBox
foreach (var val in States.GetValues(typeof(States)))
{
string state = val.ToString();
if (!state.Equals("Default"))
{
comboBox_customerState.Items.Add(state);
}
}
// TODO: implement this
scriptingToolStripMenuItem.Enabled = false;
listView_sales.GridLines = true;
setUI();
// controller dependency injection
transController = new TransactionController();
// set title
this.Text = "Retail POS v" + Configuration.VERSION;
}
public async Task AddAmount_Controller_Action_Returns_BadRequest_If_Amendment_Fails()
{
// Arrange
var cardId = "ByDJ0lbYcPkzp2Ja";
var newAmount = new AdjustAmount
{
CardId = cardId,
Amount = 10
};
var newBalance = new BalanceDto()
{
Balance = 10
};
var transactionService = new Mock <ITransactionService>();
transactionService.Setup(x => x.AddAmount(It.IsAny <AdjustAmount>())).Returns(() => null);
// Act
var controller = new TransactionController(transactionService.Object);
var result = (StatusCodeResult)controller.AddAmount(newAmount);
// Assert
Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode);
}
public void SetUp()
{
_digitalAccountTransactionBusinessMock = new Mock <IDigitalAccountTransactionBusiness>();
_mapperMock = new Mock <IMapper>();
_controller = new TransactionController(_digitalAccountTransactionBusinessMock.Object, _mapperMock.Object);
}
public void IndexPostNoActiveTransaction()
{
Mock <DataContext> dbMock = new Mock <DataContext>();
dbMock.Setup(q => q.ProfileData).Returns(new []
{
new ProfileData()
{
Id = 1,
FirstName = "Noud",
LastName = "Wijngaards",
Balans = 8,
}
}.AsQueryable().BuildMockDbSet().Object);
Mock <ITransactionManager> transactionManagerMock = new Mock <ITransactionManager>();
TransactionController controller = new TransactionController(dbMock.Object, transactionManagerMock.Object);
// arrange
IActionResult result = controller.IndexPost(new TransactionIndexViewModel()
{
CustomerId = 1,
});
// assert
Assert.IsType <RedirectToActionResult>(result);
transactionManagerMock.Verify(q => q.StartTransaction(It.IsAny <ProfileData>()), Times.Once());
}
public async Task AddAmount_Controller_Action_Returns_Latest_Balance_When_Amount_Added()
{
// Arrange
var cardId = "ByDJ0lbYcPkzp2Ja";
var newAmount = new AdjustAmount
{
CardId = cardId,
Amount = 10
};
var newBalance = new BalanceDto()
{
Balance = 10
};
var transactionService = new Mock <ITransactionService>();
transactionService.Setup(x => x.AddAmount(newAmount)).Returns(newBalance);
// Act
var controller = new TransactionController(transactionService.Object);
var result = controller.AddAmount(newAmount);
var resultMember = (CreatedAtActionResult)result;
// Assert
Assert.Equal(newBalance, resultMember.Value);
}
private void TestScenario(TransactionController transactionController, List <Expense> expenses)
{
List <Expense> oldExpenses = new List <Expense>();
expenses.ForEach(o => oldExpenses.Add(new Expense()
{
Cost = o.Cost, Person = o.Person
}));
decimal average = expenses.Average(o => o.Cost);
List <Transaction> transactions = transactionController.GetTransactions(expenses);
//transactions were made
Assert.Greater(transactions.Count, 0);
//the shares are now fair
expenses.ForEach(o => AssertEqualWith1CentTolerance(o.Cost, average));
//transaction amounts are correct
oldExpenses.Where(o => o.Cost > average).ToList() //we are checking if who overpayed got refunded
.ForEach(o =>
AssertEqualWith1CentTolerance(
transactions
.Where(x => x.ToPerson == o.Person) //money received
.Sum(j => j.Amount)
- transactions
.Where(x => x.FromPerson == o.Person) //money sent
.Sum(j => j.Amount)
+ average,
o.Cost)); //check if money received - sent + average == first expense
}
public async ValueTask TearDown()
{
_systemUnderTest = null;
await DropOrRestoreTestDbs("Dbs_Drop");
ShutdownIoC();
}
public async Task CreateEditDeleteAsync()
{
var userStoreMock = new Mock <IUserStore <ApplicationUser> >();
// Arrange
var bankAccountController = new BankAccountController(new UserManager <ApplicationUser>(userStoreMock.Object,
null, null, null, null, null, null, null, null));
var transactionController = new TransactionController(new UserManager <ApplicationUser>(userStoreMock.Object,
null, null, null, null, null, null, null, null));
var bankAccount = new BankAccount();
var result = await bankAccountController.Create(bankAccount);
// Assert
Assert.IsType <RedirectToActionResult>(result);
// Arrange
var bankAccountId = bankAccount.Id;
// Act
var transactionViewModel = new TransactionViewModel
{
BankAccountId = bankAccountId,
Amount = "100",
IsDeposition = true
};
result = await transactionController.Create(transactionViewModel);
// Assert
Assert.IsType <RedirectToActionResult>(result);
var transactionId = transactionViewModel.Id;
// Act
result = await transactionController.Details(transactionId);
// Assert
Assert.IsType <ViewResult>(result);
// Act
result = await transactionController.Edit(transactionId);
// Assert
Assert.IsType <ViewResult>(result);
// Act
result = await transactionController.Edit(transactionId, transactionViewModel);
// Assert
Assert.IsType <RedirectToActionResult>(result);
// Act
result = await bankAccountController.DeleteConfirmed(bankAccountId);
// Assert
Assert.IsType <RedirectToActionResult>(result);
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override bool Execute(InvokationContext context)
{
var controller = new TransactionController();
Initializer(controller, context);
return(controller.TimestampBeforeYearsAgo(Years));
}
protected void Page_Load(object sender, EventArgs e)
{
accountController = new AccountController();
transactionController = new TransactionController();
if (Session["CurrentAccount"] != null)
{
Account currentAccount = (Account)Session["CurrentAccount"];
if (accountController.isAccountAdmin(currentAccount.Id.ToString()))
{
isAuthorized = true;
reloadTable();
}
else
{
isAuthorized = false;
}
}
else
{
isAuthorized = false;
}
if (!isAuthorized)
{
TransactionGridView.Visible = false;
Response.Redirect("Index.aspx");
}
}
public void CreateWithdrawTransactionTest()
{
TransactionController transaction = new TransactionController(_UserProvider);
Transaction depositTransaction = new Transaction
{
Amount = new Money(1000),
TransactionType = Transaction.Type.DEPOSIT,
UserId = 0
};
Transaction goodTestTransaction = new Transaction
{
Amount = new Money(1000),
TransactionType = Transaction.Type.WITHDRAW,
UserId = 0
};
Transaction badTestTransaction = new Transaction
{
Amount = new Money(100000),
TransactionType = Transaction.Type.WITHDRAW,
UserId = 0
};
StatusCodeResult result = transaction.CreateTransaction(depositTransaction) as StatusCodeResult;
Assert.AreEqual(result.StatusCode, (int)HttpStatusCode.Accepted);
result = transaction.CreateTransaction(goodTestTransaction) as StatusCodeResult;
Assert.AreEqual(result.StatusCode, (int)HttpStatusCode.Accepted);
result = transaction.CreateTransaction(badTestTransaction) as StatusCodeResult;
Assert.AreEqual(result.StatusCode, (int)HttpStatusCode.BadRequest);
}
/// <summary>
/// Initializes a new instance of the <see cref="PurchaseTransactionUC"/> class.
/// </summary>
/// <param name="theGrid">The grid.</param>
public PurchaseTransactionUC(DataGridView theGrid)
{
DataGrid = theGrid;
this.theController = new TransactionController();
InitializeComponent();
UserControlType = UserControls.PurchaseTransaction;
}
public void Page_PageTypeSave(int[] pageIDs, int pageTypeID, int userID)
{
TransactionController transactionController = new TransactionController();
try
{
transactionController.BeginTransaction();
int index = 0;
Page_PageType ppt = new Page_PageType();
ppt.PageTypeID = pageTypeID;
ppt.Verified = true;
for (index = 0; index < pageIDs.Length; index++)
{
ppt.PageID = pageIDs[index];
this.Page_PageTypeSave(ppt, userID, transactionController);
}
transactionController.CommitTransaction();
}
catch
{
transactionController.RollbackTransaction();
}
finally
{
transactionController.Dispose();
}
}
public void TestProcessReturnInReturnController()
{
//Create observer
Observer ob1 = new Observer((string s, State status) => { });
//add transaction through the transaction controller
TransactionController controller = new TransactionController();
controller.RegisterR(ob1);
Tuple <int, int> productIDTransactionTyple = new Tuple <int, int>(1, 1);
List <Tuple <int, int> > tuples = new List <Tuple <int, int> >
{
productIDTransactionTyple
};
controller.CreateTransaction(tuples);
//Create observer
Observer ob = new Observer((string s, State status) => { Assert.AreEqual("Success! Items returned.", s); Assert.AreEqual(status, State.Return); });
//add transaction through the transaction controller
ReturnController returnController = new ReturnController();
returnController.RegisterR(ob);
returnController.ProcessReturn(1, 1, 1);
}
public async void BulkInsert_No_Errors()
{
TransactionControllerMockFacade mock = new TransactionControllerMockFacade();
var mockResponse = new CreateResponse <ApiTransactionResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiTransactionResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiTransactionRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiTransactionResponseModel> >(mockResponse));
TransactionController controller = new TransactionController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiTransactionRequestModel>();
records.Add(new ApiTransactionRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiTransactionResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiTransactionRequestModel>()));
}
protected void BindGridList()
{
int id = int.Parse(Request.QueryString["id"]);
GridView1.DataSource = TransactionController.GetDetailTransaction(id);
GridView1.DataBind();
}
private ReportDataset GetData()
{
ReportDataset dataset = new ReportDataset();
ReportDataset.HeaderTransactionDataTable headerTable = dataset.HeaderTransaction;
ReportDataset.DetailTransactionDataTable detailTable = dataset.DetailTransaction;
List <Header_Transaction> headerTransactions = TransactionController.GetHeaderTransactions();
foreach (Header_Transaction ht in headerTransactions)
{
DataRow headerRow = headerTable.NewRow();
headerRow["TransactionID"] = ht.ID;
headerRow["Username"] = ht.User.Name;
headerRow["PaymentType"] = ht.PaymentType.Type;
headerRow["Date"] = ht.Date;
headerTable.Rows.Add(headerRow);
foreach (Detail_Transaction dt in ht.Detail_Transactions)
{
DataRow detailRow = detailTable.NewRow();
detailRow["ProductName"] = dt.Product.Name;
detailRow["ProductPrice"] = dt.Product.Price;
detailRow["Quantity"] = dt.Quantity;
detailRow["TransactionID"] = dt.TransactionID;
detailTable.Rows.Add(detailRow);
}
}
return(dataset);
}
public void ShouldReturnBadrequestWhenValidationErrorsOccur()
{
var formFileConfig = new Mock <IFormFile>();
var dataContextConfig = new Mock <DataContext>();
var mappingServiceProviderConfig = new Mock <IMappingServiceProvider>();
var validationConfigs = new IValidationConfiguration[] { new TransactionXmlValidationConfiguration(), new TransactionCsvValidationConfiguration() };
var validationService = new ValidationService(validationConfigs);
var transactionManager = new TransactionManager(null, validationService, mappingServiceProviderConfig.Object);
var buffer = Encoding.UTF8.GetBytes(wrongxml);
var memoryStream = new MemoryStream(buffer);
formFileConfig.SetupGet(mockSetup => mockSetup.Length).Returns(1024 * 1024);
formFileConfig.SetupGet(mockSetup => mockSetup.ContentType).Returns("text/xml");
formFileConfig.SetupGet(mockSetup => mockSetup.FileName).Returns("file.xml");
formFileConfig.Setup(mockSetup => mockSetup.OpenReadStream()).Returns(memoryStream);
var controller = new TransactionController(transactionManager);
var result = controller.Upload(formFileConfig.Object);
var isExpected = result.GetType() == typeof(BadRequestObjectResult);
Assert.IsTrue(isExpected);
}
public TransactionViewer()
{
InitializeComponent();
MyController = new TransactionController(this);
Controller = MyController;
CleanEmptyReportButtons();
}
public EditTransaction(TransactionHome transactionHome, TransactionEditDto transactionEdit)
{
InitializeComponent();
transactionController = new TransactionController(transactionService);
categoryController = new CategoryController(categoryService);
_transactionHome = transactionHome;
// this.FormClosing += new FormClosingEventHandler(this.EditTransactionClosing);
this.transactionEditDto = transactionEdit;
transactionName.Text = transactionEdit.transactionName;
transactionAmount.Text = (transactionEdit.transactionAmount).ToString();
transactionNote.Text = transactionEdit.transactionNote;
dateTimePicker1.Value = transactionEdit.transactionDate;
this.transactionId = int.Parse(transactionEdit.transactionId);
MySqlDataReader reader = categoryController.getAllCategories();
while (reader.Read())
{
comboBox1.Items.Add(new KeyValuePair <string, int>(reader["categoryName"].ToString(), reader.GetInt32("categoryId")));
comboBox1.DisplayMember = "key";
comboBox1.ValueMember = "value";
}
reader.Close();
comboBox1.Text = transactionEdit.categoryName;
}
private void button4_Click(object sender, EventArgs e)
{
string var = comboBox2.SelectedValue.ToString();
Console.WriteLine(var);
TransactionController trcon = new TransactionController();
string user_id = "7fa65ff0-4a3e-4cc5-b975-fae5c16b385e";
string date = DateTime.Now.Year.ToString() + '-' + var;
DataTable dt = new DataTable();
MySqlDataAdapter adapt = trcon.get_transactions_by_month_userid(user_id, date);
adapt.Fill(dt);
dataGridView1.DataSource = null;
dataGridView1.Refresh();
dataGridView1.DataSource = dt;
dataGridView1.Columns[0].Visible = false;
dataGridView1.Columns[5].Visible = false;
dataGridView1.Columns[6].Visible = false;
dataGridView1.Columns[2].HeaderText = "Amount (Rs)";
dataGridView1.Columns[7].HeaderText = "Payer or Payee";
this.clear_data();
}
private async void _Fund_Clicked(object sender, EventArgs e)
{
if (!String.IsNullOrWhiteSpace(_Amount.Text) || !String.IsNullOrEmpty(_Amount.Text))
{
Dictionary <int, String[]> Data = new Dictionary <int, string[]>
{
{ 0, new String[] { "user_id", Utilities.ID.ToString() } },
{ 1, new String[] { "amount", _Amount.Text } }
};
try
{
String ResponseJson = await TransactionController.FundAccount(Utilities.PostDataEncoder(Data));
var DecodedJson = JObject.Parse(ResponseJson);
if (Convert.ToBoolean(DecodedJson["status"]))
{
//return to previous page after user closes the alert dialog
await Utilities.CreateAlertDialog("Alert", DecodedJson["message"].ToString(), "Ok", delegate
{
Navigation.PopAsync();
});
}
else
{
await DisplayAlert("Alert", DecodedJson["message"].ToString(), "Ok");
}
}
catch (Exception ex)
{
await DisplayAlert("Alert", ex.Message, "Ok");
}
}
}
private List <int> isAlreadyOrder(string orderDate)
{
List <int> indexRes = new List <int>();
int ShowId = int.Parse(Request.QueryString["ShowId"]);
List <TransactionHeader> transactionHeaders = TransactionController.GetAllTransactionHeaderByShowId(ShowId);
if (transactionHeaders != null)
{
foreach (var header in transactionHeaders)
{
DateTime bookedAt = header.ShowTime;
string str_bookedAt = String.Format("{0:MM/dd/yyyy}", bookedAt);
DateTime order = Convert.ToDateTime(orderDate);
string str_orderDate = String.Format("{0:MM/dd/yyyy}", order);
if (str_orderDate == str_bookedAt)
{
int hour = header.ShowTime.Hour;
indexRes.Add(hour);
}
}
}
return(indexRes);
}
public void BalanceIsCorrectAfterDeposit()
{
//Arrange
var fakeDb = new FakeApplicationDbContext();
fakeDb.CheckingAccounts = new FakeDbSet <CheckingAccount>();
fakeDb.Transactions = new FakeDbSet <Transaction>();
var checkingAccount = new CheckingAccount
{
Id = 1,
AccountNumber = "0000123TEST",
Balance = 0
};
fakeDb.CheckingAccounts.Add(checkingAccount);
var transActionController = new TransactionController(fakeDb);
//Act
transActionController.Deposit(new Transaction {
CheckingAccountId = 1, AmountDecimal = 1000
});
//Assert
//checkingAccount.Balance = 3000; //assert if the assert staement is valid or not
//and passing test the simplest way, otherwise test
//fails as balance is not updated yet
Assert.AreEqual(1000, checkingAccount.Balance);
}
public TransactionSampler(TransactionController controller, String name)
{
transactionController = controller;
SetName(name); // ensure name is available for debugging
transactionSampleResult = new ExecuteResult();
transactionSampleResult.setSampleLabel(name);
// Assume success
transactionSampleResult.Success = true;
transactionSampleResult.sampleStart();
}
public override bool Execute(InvokationContext context)
{
var controller = new TransactionController();
Initializer(controller, context);
return controller.TimestampBeforeYearsAgo(Years);
}
