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();
}
