コード例 #1
0
 public BalanceService(IBalanceRepository repository)
 {
     _repository = repository;
 }
コード例 #2
0
 public BalanceServices()
 {
     this._dbContextScopeFactory = new TiendaDbContext();
     _repository = new BalanceRepository(this._dbContextScopeFactory);
     this.OnCreated();
 }
コード例 #3
0
 public BankAccountV3(int accountId, IBalanceRepository repository)
 {
     AccountId   = accountId;
     _repository = repository;
 }
コード例 #4
0
 public BalanceController(ILoggerFactory loggerFactory, IBalanceRepository balanceRepository)
 {
     _logger = loggerFactory.CreateLogger <BalanceController>();
     _logger.LogInformation("BalanceController initialized.");
     _balanceRepository = balanceRepository;
 }
コード例 #5
0
        public ProductsAdminController(IProductRepository repo, IReceiptRepository receiptRepo, IMapper mapper, ICategoryRepository catRepo, IColorRepository colRepo, IOptions <CloudinarySettings> cloudinaryConfig, IPhotoRepository photoRepo, IBalanceRepository balanceRepo)
        {
            _receiptRepo      = receiptRepo;
            _balanceRepo      = balanceRepo;
            _photoRepo        = photoRepo;
            _catRepo          = catRepo;
            _colRepo          = colRepo;
            _mapper           = mapper;
            _repo             = repo;
            _cloudinaryConfig = cloudinaryConfig;
            Account acc = new Account(
                _cloudinaryConfig.Value.CloudName,
                _cloudinaryConfig.Value.ApiKey,
                _cloudinaryConfig.Value.ApiSecret
                );

            _cloudinary = new Cloudinary(acc);
        }
コード例 #6
0
 public BalancesService(IBalanceRepository balanceRepository, IMapper mapper)
 {
     _balanceRepository = balanceRepository;
     _mapper            = mapper;
 }
コード例 #7
0
 public ExchangeBalanceDataReceivedIntegrationEventHandler(IBalanceRepository balanceRepository, IExchangeAccessIntegrationEventService exchangeAccessIntegrationEventService)
 {
     _balanceRepository = balanceRepository ?? throw new ArgumentNullException(nameof(balanceRepository));
     _exchangeAccessIntegrationEventService = exchangeAccessIntegrationEventService ?? throw new ArgumentNullException(nameof(exchangeAccessIntegrationEventService));
 }
コード例 #8
0
        public void DepositArrivedAndConfirmedEventTest_TestsThatDepositArrivedEventIsHandledAsExpected_VerifiesThroughRaisedEvent()
        {
            // Withdraw is submitted and events are actually raised from the CoinClientService
            // Over the limit deposit so account and deposit are frozen
            IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
            IBalanceRepository          balanceRepository          = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
            IDepositRepository          depositRepository          = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
            IWithdrawRepository         withdrawRepository         = (IWithdrawRepository)ContextRegistry.GetContext()["WithdrawRepository"];
            IDepositLimitRepository     depositLimitRepository     = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
            IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];

            AccountId      accountId      = new AccountId(123);
            Currency       currency       = new Currency("BTC", true);
            BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
            TransactionId  transactionId  = new TransactionId("transactionid1");

            DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
                                                               accountId);

            fundsPersistenceRepository.SaveOrUpdate(depositAddress);
            DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default");

            Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later");
            decimal amount = depositLimit.DailyLimit - 0.001M;

            ManualResetEvent manualResetEvent = new ManualResetEvent(false);

            Balance balance = new Balance(currency, accountId, 10, 10);

            fundsPersistenceRepository.SaveOrUpdate(balance);
            CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(
                                                                                                            accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount));

            Assert.IsNotNull(commitWithdrawResponse);
            Assert.IsTrue(commitWithdrawResponse.CommitSuccessful);
            // Get the interval after which the withdraw will be submitted. Once submitted to the StubClientService, the events
            // of DepositArrived will be raised and handled in Deposit APplicationService, which will create a new Deposit
            // instance and save in database
            int withdrawInterval = Convert.ToInt16(ConfigurationManager.AppSettings.Get("WithdrawSubmitInterval"));

            manualResetEvent.WaitOne(withdrawInterval + 2000);

            Withdraw withdraw = withdrawRepository.GetWithdrawByWithdrawId(commitWithdrawResponse.WithdrawId);

            Assert.IsNotNull(withdraw);
            Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);

            Assert.IsNotNull(deposit);
            Assert.AreEqual(amount - withdraw.Fee, deposit.Amount);
            Assert.AreEqual(withdraw.TransactionId.Value, deposit.TransactionId.Value);
            Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
            Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
            Assert.AreEqual(TransactionStatus.Confirmed, deposit.Status);
            balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
            Assert.IsNotNull(balance);

            // Balance instance now will have been created
            balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
            Assert.IsNotNull(balance);
            Assert.AreEqual(0, balance.PendingBalance);
            Assert.IsFalse(balance.IsFrozen);
        }
コード例 #9
0
 public BalancesController(IBalanceRepository balanceRepository)
 {
     _balanceRepository = balanceRepository;
 }
コード例 #10
0
        public void DepositArrivedStandaloneTest_TestsIfTheOperationProceedsAsExpectedWHenANewDepositArrives_VerifiesThroughQueryingDatabaseIsntances()
        {
            // Tests the event handler DepositArrived by directly sending data
            IDepositApplicationService    depositApplicationService  = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
            IFundsPersistenceRepository   fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
            IBalanceRepository            balanceRepository          = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
            ILedgerRepository             ledgerRepository           = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
            IDepositRepository            depositRepository          = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
            IDepositAddressRepository     depositAddressRepository   = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
            IDepositLimitRepository       depositLimitRepository     = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
            StubTierLevelRetrievalService tierLevelRetrieval         = (StubTierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"];

            tierLevelRetrieval.SetTierLevel(TierConstants.TierLevel1);
            AccountId      accountId      = new AccountId(123);
            Currency       currency       = new Currency("BTC", true);
            BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
            TransactionId  transactionId  = new TransactionId("transactionid1");
            DepositLimit   depositLimit   = depositLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1,
                                                                                                  LimitsCurrency.Default.ToString());
            decimal amount   = depositLimit.DailyLimit - 0.001M;
            string  category = BitcoinConstants.ReceiveCategory;

            DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
                                                               accountId);

            fundsPersistenceRepository.SaveOrUpdate(depositAddress);

            Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);

            Assert.IsNull(balance);

            IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);

            Assert.AreEqual(ledgers.Count, 0);

            List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();

            transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category));
            depositApplicationService.OnDepositArrival(currency.Name, transactionsList);

            ManualResetEvent manualResetEvent = new ManualResetEvent(false);

            manualResetEvent.WaitOne(2000);
            Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);

            Assert.IsNotNull(deposit);
            Assert.AreEqual(deposit.Amount, amount);
            Assert.AreEqual(deposit.Currency.Name, currency.Name);
            Assert.IsTrue(deposit.Currency.IsCryptoCurrency);
            Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value);
            Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value);
            Assert.AreEqual(deposit.Status, TransactionStatus.Pending);

            depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress);
            Assert.IsNotNull(depositAddress);
            Assert.AreEqual(depositAddress.Status, AddressStatus.Used);

            balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
            Assert.IsNull(balance);

            ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
            Assert.AreEqual(ledgers.Count, 0);
        }
コード例 #11
0
        public void DepositConfirmedTest_TestsIfTheOperationProceedsAsExpectedWhenADepositIsConfirmed_VerifiesThroughQueryingDatabaseIsntances()
        {
            IDepositApplicationService    depositApplicationService  = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
            IFundsPersistenceRepository   fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
            IBalanceRepository            balanceRepository          = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
            ILedgerRepository             ledgerRepository           = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
            IDepositRepository            depositRepository          = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
            IDepositAddressRepository     depositAddressRepository   = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
            StubTierLevelRetrievalService tierLevelRetrievalService  = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;

            if (tierLevelRetrievalService != null)
            {
                tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
            }
            AccountId      accountId      = new AccountId(123);
            Currency       currency       = new Currency("BTC", true);
            BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
            TransactionId  transactionId  = new TransactionId("transactionid1");
            decimal        amount         = 1.02m;
            string         category       = BitcoinConstants.ReceiveCategory;

            DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
                                                               accountId);

            fundsPersistenceRepository.SaveOrUpdate(depositAddress);

            Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);

            Assert.IsNull(balance);

            IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);

            Assert.AreEqual(ledgers.Count, 0);

            List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();

            transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category));
            depositApplicationService.OnDepositArrival(currency.Name, transactionsList);

            Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);

            Assert.IsNotNull(deposit);
            Assert.AreEqual(deposit.Amount, amount);
            Assert.AreEqual(deposit.Currency.Name, currency.Name);
            Assert.IsTrue(deposit.Currency.IsCryptoCurrency);
            Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value);
            Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value);
            Assert.AreEqual(TransactionStatus.Pending, deposit.Status);

            depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress);
            Assert.IsNotNull(depositAddress);
            Assert.AreEqual(AddressStatus.Used, depositAddress.Status);

            balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
            Assert.IsNull(balance);

            ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
            Assert.AreEqual(0, ledgers.Count);

            depositApplicationService.OnDepositConfirmed(transactionId.Value, 7);

            deposit = depositRepository.GetDepositByTransactionId(transactionId);
            Assert.IsNotNull(deposit);
            Assert.AreEqual(deposit.Status, TransactionStatus.Confirmed);

            balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
            Assert.IsNotNull(balance);
            Assert.AreEqual(amount, balance.AvailableBalance);
            Assert.AreEqual(amount, balance.CurrentBalance);
            Assert.AreEqual(0, balance.PendingBalance);

            ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
            Assert.AreEqual(1, ledgers.Count);
            var ledger = ledgers.SingleOrDefault();

            Assert.IsNotNull(ledger);
            Assert.AreEqual(LedgerType.Deposit, ledger.LedgerType);
            Assert.AreEqual(accountId.Value, ledger.AccountId.Value);
            Assert.AreEqual(amount, ledger.Amount);
            Assert.AreEqual(deposit.DepositId, ledger.DepositId);
            Assert.AreEqual(0, ledger.Fee);
        }
コード例 #12
0
 public BalanceBusiness()
 {
     _repo = new BalanceRepository();
 }
コード例 #13
0
 public BalanceBusiness(IBalanceRepository balanceRepository, IMapper mapper)
 {
     this.balanceRepository = balanceRepository;
     this.mapper            = mapper;
 }
コード例 #14
0
 public BalanceExportService(IBalanceRepository balanceRepository, ICsvExporter balanceExporter)
 {
     _balanceRepository = balanceRepository;
     _csvExporter       = balanceExporter;
 }
コード例 #15
0
 public BalanceController(IBalanceRepository repository)
 {
     _repository = repository;
 }
コード例 #16
0
 public ExchangeAccessService(IMarketRepository marketRepository, IBalanceRepository balanceRepository, ICandleChartRepository candleChartRepository)
 {
     this._marketRepository      = marketRepository ?? throw new ArgumentNullException(nameof(marketRepository));
     this._balanceRepository     = balanceRepository ?? throw new ArgumentNullException(nameof(balanceRepository));
     this._candleChartRepository = candleChartRepository ?? throw new ArgumentNullException(nameof(candleChartRepository));
 }
コード例 #17
0
 public BalanceService(IBalanceRepository balanceRepository)
 {
     _balanceRepository = balanceRepository;
 }
コード例 #18
0
 public BalancesController(ExchangeAccessContext context, IBalanceRepository balanceRepository)
 {
     _context           = context;
     _balanceRepository = balanceRepository ?? throw new ArgumentNullException(nameof(balanceRepository));
 }
コード例 #19
0
 public ClientService(IClientRepository clientsRepository, IBalanceRepository balanceRepository, IValidator validator)
 {
     this.clientsRepository = clientsRepository;
     this.balanceRepository = balanceRepository;
     this.validator         = validator;
 }
コード例 #20
0
 public SpendingRepository(DataContext context, IBalanceRepository balanceRepository)
 {
     _context           = context;
     _balanceRepository = balanceRepository;
 }
コード例 #21
0
 public BankAccountV2(int accountId)
 {
     AccountId   = accountId;
     _repository = StaticKernel.Instance.Get <IBalanceRepository>();
 }
コード例 #22
0
ファイル: SrvBalanceAccess.cs プロジェクト: amigin/Lykee
 public SrvBalanceAccess(IBalanceRepository balanceRepository)
 {
     _balanceRepository = balanceRepository;
 }
コード例 #23
0
 public AnualBalanceRepository(DataContext context, IBalanceRepository balanceRepository)
 {
     _context           = context;
     _balanceRepository = balanceRepository;
 }
コード例 #24
0
 public BalanceService(IBalanceRepository balanceRepository, IValidator validator)
 {
     this.balanceRepository = balanceRepository;
     this.validator         = validator;
 }
コード例 #25
0
 public GetBalanceHandler(IBalanceRepository balanceRepository, IMapper mapper)
 {
     _balanceRepository = balanceRepository ?? throw new ArgumentNullException(nameof(balanceRepository));
     _mapper            = mapper ?? throw new ArgumentNullException(nameof(mapper));
 }
コード例 #26
0
ファイル: UnitOfWork.cs プロジェクト: mimcomp/FundTrack
        /// <summary>
        /// Initializes a new instance of the <see cref="UnitOfWork"/> class.
        /// </summary>
        /// <param name="contextParam">The context parameter.</param>
        /// <param name="organizationsListRepositoryParam">The organizations list repository parameter.</param>
        public UnitOfWork(FundTrackContext contextParam,
                          IOrganizationsForFilteringRepository organizationsListRepositoryParam,
                          IUserResporitory userListRepositoryParam,
                          IEventManagementRepository eventRepository,
                          IOrganizationRepository organizationRepository,
                          IMembershipRepository membershipRepositoryParam,
                          IRepository <Address> addressRepository,
                          IRepository <OrgAddress> orgAddressRepository,
                          IRepository <BankAccount> bankAccountRepository,
                          IRequestedItemRepository requestedItemRepository,
                          IRepository <Role> roleRepository,
                          IRepository <EventImage> eventImageRepositoryParam,
                          IRepository <OfferedItem> offeredItemRepository,
                          IStatusRepository statusRepository,
                          IUserResponseRepository userResponseRepository,
                          IGoodsCategoryRepository goodsCategoryRepository,
                          IRequestedItemImageRepository requestedItemImageRepository,
                          IGoodsTypeRepository goodsTypeRepository,
                          IOfferImagesRepository offeredItemImageRepository,
                          IBankImportDetailRepository bankImportDetailRepository,
                          IOrganizationAccountRepository organizationAccountRepository,
                          IRepository <Currency> currencyRepository,
                          ITargetRepository targetRepository,
                          IDonationRepository donationRepository,
                          IFinOpRepository finOpRepository,
                          IPhoneRepository phoneRepository,
                          IRepository <FinOpImage> finOpImagesRepository,
                          IUserResporitory userRepository,
                          IBalanceRepository balanceRepository,
                          IBankRepository bankRepository,
                          IImportIntervalRepository importIntervalRepository

                          )
        {
            this._context = contextParam;
            this._organizationsListRepository = organizationsListRepositoryParam;
            //this._usersListRepository = userListRepositoryParam;
            this._membershipRepository     = membershipRepositoryParam;
            _eventRepository               = eventRepository;
            _organizationRepository        = organizationRepository;
            _addressRepository             = addressRepository;
            _orgAddressRepository          = orgAddressRepository;
            _bankAccountRepository         = bankAccountRepository;
            _roleRepository                = roleRepository;
            _eventImageRepository          = eventImageRepositoryParam;
            _offeredItemRepository         = offeredItemRepository;
            _goodsCategoryRepository       = goodsCategoryRepository;
            _userResponseRepository        = userResponseRepository;
            _requestedItemRepository       = requestedItemRepository;
            _statusRepository              = statusRepository;
            _requestedItemImageRepository  = requestedItemImageRepository;
            _goodsTypeRepository           = goodsTypeRepository;
            _offeredItemImageRepository    = offeredItemImageRepository;
            _bankImportDetailRepository    = bankImportDetailRepository;
            _organizationAccountRepository = organizationAccountRepository;
            _currencyRepository            = currencyRepository;
            _targetRepository              = targetRepository;
            _donationRepository            = donationRepository;
            _finOpRepository               = finOpRepository;
            this._phoneRepository          = phoneRepository;
            _finOpImagesRepository         = finOpImagesRepository;
            _userRepository                = userRepository;
            _balanceRepository             = balanceRepository;
            _bankRepository                = bankRepository;
            _importIntervalRepository      = importIntervalRepository;
        }
コード例 #27
0
 public BalanceState(IBalanceRepository repository, ulong txAmount, IReadOnlyList <TransferInfo> internalTransfers)
 {
     this.repository        = repository;
     this.TxAmount          = txAmount;
     this.internalTransfers = internalTransfers;
 }
コード例 #28
0
 public TransactionManager(IBalanceRepository balanceRepository,
                           ITransferTransactionRepository transferTransactionRepository)
 {
     _balanceRepository             = balanceRepository;
     _transferTransactionRepository = transferTransactionRepository;
 }
コード例 #29
0
 public LiveRoundtripExitOrderSubmittedIntegrationEventHandler(IExchangeAccessIntegrationEventService exchangeAccessIntegrationEventService, IMarketRepository marketRepository, IBalanceRepository balanceRepository, IExchangeAccessService exchangeAccessService)
 {
     _exchangeAccessIntegrationEventService = exchangeAccessIntegrationEventService ?? throw new ArgumentNullException(nameof(exchangeAccessIntegrationEventService));
     _marketRepository      = marketRepository ?? throw new ArgumentNullException(nameof(marketRepository));
     _balanceRepository     = balanceRepository ?? throw new ArgumentNullException(nameof(balanceRepository));
     _exchangeAccessService = exchangeAccessService ?? throw new ArgumentNullException(nameof(exchangeAccessService));
 }
コード例 #30
0
 public UserAssetsService(IBalanceRepository iBalanceRepository)
 {
     _iBalanceRepository = iBalanceRepository;
 }
コード例 #31
0
 public BalanceServiceDomain(IBalanceRepository balanceRepository)
     : base(balanceRepository)
 {
     _balanceRepository = balanceRepository;
 }
コード例 #32
0
 public SrvBalanceAccess(IBalanceRepository balanceRepository, IAssetsDictionary assetsDictionary)
 {
     _balanceRepository = balanceRepository;
     _assetsDictionary = assetsDictionary;
 }