public TransactionsManager() { _transactionsRepository = new TransactionsRepository(); _statusCodeRepository = new StatusCodeRepository(); _cardBinRepository = new CardBinRepository(); _bankRepository = new BankRepository(); }
public TransactionsController( IAuthorizationService authorizationService, TransactionsRepository transactionsRepository ) : base(authorizationService) { this.transactionsRepository = transactionsRepository; }
public TransactionsService(TransactionsRepository transactionsRepository, ILogger <TransactionsService> logger, PublishingRouter publishingRouter, ReportsDataFetcher reportsDataFetcher) { this.transactionsRepository = transactionsRepository; this.logger = logger; this.publishingRouter = publishingRouter; this.reportsDataFetcher = reportsDataFetcher; }
public async Task <CurrencyExchangeTransactionModel> SubmitTransactionAsync(CurrencyExchangeModel currencyExchangeModel, double foreignCurrencyAmount, DateTime transactionDate, int rateId) { Rate rate = await RatesRepository.GetRateByIdAsync(rateId); CurrencyExchangeTransaction transaction = new CurrencyExchangeTransaction() { LocalCurrencyAmount = currencyExchangeModel.LocalCurrencyAmount, ForeignCurrencyAmount = foreignCurrencyAmount, ForeignCurrencyCode = currencyExchangeModel.ForeignCurrencyCode, Rate = rate, TransactionDate = transactionDate, UserId = currencyExchangeModel.UserId }; TransactionsRepository.AddTransaction(transaction); await TransactionsRepository.SaveChangesAsync(); return(new CurrencyExchangeTransactionModel() { Id = transaction.Id, UserId = transaction.UserId, LocalCurrencyAmount = transaction.LocalCurrencyAmount, ForeignCurrencyAmount = transaction.ForeignCurrencyAmount, ForeignCurrencyCode = transaction.ForeignCurrencyCode, TransactionDate = transaction.TransactionDate, }); }
public IHttpActionResult GetTransactions(Guid id) { var repo = new TransactionsRepository(); var transactionList = repo.GetTransactions(_connectionString, id); return(Ok(transactionList)); }
public MoveTaskTransactionHandler(ProjectsRepository projectsRepository, WorkingHoursRepository workingHoursRepository, TasksRepository tasksRepository, RequestsRepository requestsRepository, TransactionsRepository transactionsRepository) : base(requestsRepository, transactionsRepository) { _projectsRepository = projectsRepository; _workingHoursRepository = workingHoursRepository; _tasksRepository = tasksRepository; }
public void SetProjectionListener(TransactionsRepository repository, IServiceCollection services) { var config = new RabbitMqConfig(); configuration.GetSection("RabbitMq").Bind(config); var logger = services.BuildServiceProvider().GetService <ILogger <RabbitMqPublisher> >(); var rabbitMq = new RabbitMqChannelFactory().CreateReadChannel <Models.Transaction, string>(config, "TransactionsRead", logger); rabbitMq.Received += (sender, projection) => { if (projection.Upsert != null && projection.Upsert.Length > 0) { repository.Upsert(projection.Upsert); } if (projection.Upsert != null && projection.Upsert.Length == 0) { repository.Clear(); } if (projection.Remove != null) { repository.Remove(projection.Remove); } }; }
public MoveTaskTransactionHandler(ListsRepository listsRepository, ProjectsRepository projectsRepository, TransactionsRepository transactionsRepository, RequestsRepository requestsRepository, RabbitMqTopicManager rabbit) : base(requestsRepository, transactionsRepository) { _listsRepository = listsRepository; _projectsRepository = projectsRepository; }
public TransactionsController(IHostingEnvironment hostingEnvironment) { IKernel kernel = new StandardKernel(new BankingModule()); this.Repository = kernel.Get <TransactionsRepository>(); this._hostingEnvironment = hostingEnvironment; }
public TransactionsWriteService(TransactionsRepository transactionsRepository, ILogger <TransactionsWriteService> logger, Mapper mapper, RabbitMqPublisher projectionChannel) { this.transactionsRepository = transactionsRepository; this.logger = logger; this.mapper = mapper; this.projectionChannel = projectionChannel; }
public StatsController(TransactionsRepository transactionsRepository, TransferRepository transferRepository, OutcomeTransactionRepository outcomeRepository, TradeRepository tradeRepository, UsersInfoRepository usersInfoRepository, UserRepository userRepository) { _transactionsRepository = transactionsRepository; _transferRepository = transferRepository; _outcomeRepository = outcomeRepository; _tradeRepository = tradeRepository; _usersInfoRepository = usersInfoRepository; _userRepository = userRepository; }
public void Add(TransactionRequest transaction) { if (transaction.Date == null) { transaction.Date = DateTime.UtcNow; } using var db = new TransactionsRepository(); //var bson = db.Add(transaction); }
private void txtSn_Leave(object sender, EventArgs e) { TransactionsRepository repository = new TransactionsRepository(); if (String.IsNullOrEmpty(txtSn.Text)) { return; } GrnMaster grnMaster = new GrnMaster(); grnMaster = repository.GetGrnMaster(Convert.ToInt32(txtSn.Text)); if (grnMaster == null) { MessageBox.Show("Invalid Grn Number."); txtSn.Text = ""; txtSn.Focus(); } else { txtSn.Text = grnMaster.SerialNumber.ToString(); txtInv.Text = grnMaster.InvoiceNumber; txtgdsupcd.Text = grnMaster.SuppCd; lblsupnm.Text = grnMaster.SuppNm; lblNetAmt.Text = grnMaster.NetAmount.ToString(); lblVatAmt.Text = grnMaster.VatAmount.ToString(); lblTtlAmt.Text = (grnMaster.VatAmount + grnMaster.NetAmount).ToString(); dtgd.Value = grnMaster.DateReceived.Date; try { using (SqlConnection con = new SqlConnection(DbCon.connection)) { SqlCommand cmd = new SqlCommand("Select * from Grndetails where GrnSrNo =@srno", con); cmd.Parameters.AddWithValue("@srno", grnMaster.SerialNumber); if (con.State == ConnectionState.Closed) { con.Open(); } SqlDataReader rdr = cmd.ExecuteReader(); dgvgd.Rows.Clear(); if (rdr.HasRows) { while (rdr.Read()) { dgvgd.Rows.Add(rdr["ProdCd"], rdr["ProdNm"], rdr["UnitCd"], rdr["Quantity"], rdr["CostPrice"], rdr["LineVatAmt"], rdr["LineNetAmt"]); } } } btngdPrint.Enabled = true; } catch (Exception) { throw; } } }
public ZCashService(IConfiguration config, WalletsRepository walletsRepository, EventsRepository eventsRepository, TransactionsRepository transactionsRepository, BalanceProvider balanceProvider, OutcomeTransactionRepository outcomeTransactionRepository) { _client = new(config); _walletsRepository = walletsRepository; _eventsRepository = eventsRepository; _transactionsRepository = transactionsRepository; _balanceProvider = balanceProvider; _outcomeTransactionRepository = outcomeTransactionRepository; }
public IHttpActionResult AddTransaction(Guid id, ApiModels.Transaction transaction) { var repo = new TransactionsRepository(); if (repo.Add(_connectionString, transaction, id)) { return(Ok()); } return(BadRequest("Could not update account amount"));; }
public UnitOfWork(ApplicationDbContext context) { _context = context; Individuals = new IndividualRepository(context); BankAccounts = new BankAccountRepository(context); Requests = new RequestRepository(context); Users = new ApplicationUserRepository(context); BankAccountTypes = new BankAccountTypeRepository(context); BankAccountRequests = new BankAccountRequestRepository(context); Transactions = new TransactionsRepository(context); TransactionTypes = new TransactionTypeRepository(context); }
public Blockchain CreateBlockchain() { var transactionsRepository = new TransactionsRepository(); var pendingTransactionRepository = new PendingTransactionRepository(); var transactionValidator = new TransactionValidator(transactionsRepository); var blockValidator = new BlockValidator(transactionValidator); var blockRepository = new Blockchain(transactionsRepository, pendingTransactionRepository, blockValidator, transactionValidator); return(blockRepository); }
public async void Should_AddAsync_Valid() { await using var context = new TestContext(ContextOptions); var repository = new TransactionsRepository( new Mock <ILogger <AbstractRepository <TransactionsContext, TransactionEntity> > >().Object, context ); var newEntity = new TransactionEntity(); var result = await repository.AddAsync(newEntity); Assert.NotNull(result); }
public TransactionManager(TransactionsRepository transactionsRepository, ICoinManager coinManager, WalletsRepository walletsRepository, EventsRepository eventsRepository, ZCashService zecService, BalanceProvider balanceProvider) { _transactionsRepository = transactionsRepository; _coinManager = coinManager; _walletsRepository = walletsRepository; _eventsRepository = eventsRepository; _zecService = zecService; _balanceProvider = balanceProvider; }
public async Task <double> GetUserRemainingLimitAsync(int userId, string currencyCode, DateTime transactionDate) { double?currencyTransactionLimitPerMonth = await TransactionsRepository.GetCurrencyTransactionLimitAsync(currencyCode); if (!currencyTransactionLimitPerMonth.HasValue) { throw new InvalidOperationException($"Currency transaction limite not found for currency code {currencyCode}"); } double amountAlreadyExchanged = await TransactionsRepository.GetUserAmountExchangedPerMonthAsync(userId, currencyCode, transactionDate); return(currencyTransactionLimitPerMonth.Value - amountAlreadyExchanged); }
public void GetsTransactionsFromContext() { // Assert. TransactionsRepository repository = new TransactionsRepository(this.mockDbContext.Object); repository.GetTransactions(); // Act. this.mockDbContext.Verify(m => m.Transactions, Times.Once); ////this.mockDbContext.VerifyNoOtherCalls(); this.mockDbSet.Verify(m => m.AsQueryable(), Times.Once); ////this.mockDbSet.VerifyNoOtherCalls(); }
// This method gets called by the runtime. Use this method to add services to the container. // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940 public void ConfigureServices(IServiceCollection services) { services.AddLogging(c => c.AddSerilog().AddFile("log.txt")); var repository = new TransactionsRepository(); services.AddGrpc(options => { options.Interceptors.Add <LoggingInterceptor>("TransactionsRead"); options.MaxReceiveMessageSize = 16 * 1024 * 1024; }); services.AddSingleton(CreateMapper()); services.AddSingleton(repository); SetProjectionListener(repository, services); }
public TasksManager(TasksRepository tasksRepository, RequestsRepository requestsRepository, ListsRepository listsRepository, UsersRepository usersRepository, LabelsRepository labelsRepository, ProjectMembersRepository projectMembersRepository, TransactionsRepository transactionsRepository, IMapper mapper) : base(requestsRepository) { _tasksRepository = tasksRepository; _requestsRepository = requestsRepository; _listsRepository = listsRepository; _usersRepository = usersRepository; _labelsRepository = labelsRepository; _projectMembersRepository = projectMembersRepository; _transactionsRepository = transactionsRepository; _mapper = mapper; }
private void Button5_Click(object sender, EventArgs e) { richTextBox1.Clear(); TransactionsRepository tranRepo = TransactionsRepository.getInstance(); EntityList list = tranRepo.getList(); Transaction[] transactions = (Transaction[])list.fetch(); foreach (Transaction t in transactions) { richTextBox1.Text += t.Id + " " + t.ArticleId + " " + t.Amount + "\n"; } }
public void ReturnsTransactionsFromContext() { // Assert. TransactionsRepository repository = new TransactionsRepository(this.mockDbContext.Object); IEnumerable <Transaction> actual = repository.GetTransactions(); Assert.AreEqual(2, actual.Count()); var a = this.entities; var b = this.entities.AsEnumerable(); var c = this.entities.AsEnumerable().First(); var d = actual.First(); Assert.AreEqual(this.entities.AsEnumerable().First(), actual.First()); ////Assert.AreEqual(this.entities.ElementAt(0).Id, actual.ElementAt(0).Id); ////Assert.AreEqual(this.entities.ElementAt(1).Id, actual.ElementAt(1).Id); }
public async void Should_GetOneByParameterAsync_Valid() { await using var context = new TestContext(ContextOptions); var repository = new TransactionsRepository( new Mock <ILogger <AbstractRepository <TransactionsContext, TransactionEntity> > >().Object, context ); var newEntity = new TransactionEntity { Version = 99 }; var _ = await repository.AddAsync(newEntity); var result = await repository.GetOneByParameterAsync( e => e.Version == 99 ); Assert.NotNull(result); }
public void Setup() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; _context = new ApplicationDbContext(options); _repos = new TransactionsRepository <TransactionsModel>(_context, _mapper); var _accountrepos = new AccountsRepository <AccountsModel>(_context, _mapper); _dateTimeHelper = new Mock <IDateTimeHelper>(); var fakeDate = DateTime.Parse("2021/03/21"); _dateTimeHelper.Setup(o => o.GetDateTimeNow()).Returns(fakeDate); _service = new TransactionsService(_context, _mapper, _repos, _accountrepos, _dateTimeHelper.Object); _repos = new TransactionsRepository <TransactionsModel>(_context, _mapper); PrefillRepo(); }
private void PrintMethod(string Comment) { List <GrnDetails> grnDetails1 = new List <GrnDetails>(); foreach (DataGridViewRow row in dgvgd.Rows) { GrnDetails grnDetails = new GrnDetails(); grnDetails.ProdCd = row.Cells[0].Value.ToString(); grnDetails.ProdNm = row.Cells[1].Value.ToString(); grnDetails.Unitcd = row.Cells[2].Value.ToString(); grnDetails.Quantity = Convert.ToDecimal(row.Cells[3].Value.ToString()); grnDetails.Cp = Convert.ToDecimal(row.Cells[4].Value.ToString()); grnDetails.LineVatAmount = Convert.ToDecimal(row.Cells[5].Value.ToString()); grnDetails.LineNetAmount = Convert.ToDecimal(row.Cells[6].Value.ToString()); grnDetails1.Add(grnDetails); } GrnMaster grnMaster = new GrnMaster(); TransactionsRepository transactions = new TransactionsRepository(); grnMaster = transactions.GetGrnMaster(Convert.ToInt32(txtSn.Text)); GrnReport grnReport = new GrnReport(); grnReport.SetDataSource(grnDetails1); grnReport.SetParameterValue("@Company", Properties.Settings.Default.COMPANYNAME); grnReport.SetParameterValue("@Branch", Properties.Settings.Default.BRANCHNAME); grnReport.SetParameterValue("@UserName", Properties.Settings.Default.USERNAME); grnReport.SetParameterValue("@SuppCd", grnMaster.SuppCd); grnReport.SetParameterValue("@SuppNm", grnMaster.SuppNm); grnReport.SetParameterValue("@InvoiceNo", grnMaster.InvoiceNumber); grnReport.SetParameterValue("@SrNo", grnMaster.SerialNumber); grnReport.SetParameterValue("@Date", grnMaster.DateReceived); grnReport.SetParameterValue("@VatAmt", grnMaster.VatAmount); grnReport.SetParameterValue("@NetAmt", grnMaster.NetAmount); grnReport.SetParameterValue("@TotalAmt", grnMaster.VatAmount + grnMaster.NetAmount); grnReport.SetParameterValue("@UserRcvd", grnMaster.UserName); grnReport.SetParameterValue("@Comment", Comment); Form form = new frmPrint(grnReport); form.Text = "Print Grn"; form.Show(); }
public async Task <List <CurrencyExchangeTransactionModel> > GetTransactionsAsync() { List <CurrencyExchangeTransaction> transactions = await TransactionsRepository.GetTransactionsAsync(); List <CurrencyExchangeTransactionModel> transactionModels = new List <CurrencyExchangeTransactionModel>(); foreach (CurrencyExchangeTransaction transaction in transactions) { transactionModels.Add(new CurrencyExchangeTransactionModel() { Id = transaction.Id, UserId = transaction.UserId, LocalCurrencyAmount = transaction.LocalCurrencyAmount, ForeignCurrencyAmount = transaction.ForeignCurrencyAmount, ForeignCurrencyCode = transaction.ForeignCurrencyCode, TransactionDate = transaction.TransactionDate, }); } return(transactionModels); }
public TransactionsApiController(TransactionsRepository repository) { this.repository = repository; this.OnCreated(); }