public DepositController(IDepositRepository depositRepository, ICustomerRepository customerRepository, IPublishEndpoint publishEndpoint) { _depositRepository = depositRepository; _customerRepository = customerRepository; _publishEndpoint = publishEndpoint; }
public BankAccountsWithoutActiveDepositHandle( IDepositRepository depositRepository, IBankAccountRepository bankAccountRepository) { _accountRepository = bankAccountRepository; _depositRepository = depositRepository; }
public ApplyDepositHandler(IDepositRepository depositRepository, ILogger <ApplyDepositHandler> logger, IMediator mediator, IBankAccountRepository bankAccountRepository) { _depositRepository = depositRepository; _logger = logger; _mediator = mediator; _bankAccountRepository = bankAccountRepository; }
public ResidueJournalViewModel( ResidueFilterViewModel filterViewModel, IEmployeeService employeeService, IRepresentationEntityPicker representationEntityPicker, IMoneyRepository moneyRepository, IDepositRepository depositRepository, IBottlesRepository bottlesRepository, IUnitOfWorkFactory unitOfWorkFactory, ICommonServices commonServices, IEntityAutocompleteSelectorFactory employeeSelectorFactory ) : base(filterViewModel, unitOfWorkFactory, commonServices) { this.employeeSelectorFactory = employeeSelectorFactory ?? throw new ArgumentNullException(nameof(employeeSelectorFactory)); TabName = "Журнал остатков"; this.employeeService = employeeService ?? throw new ArgumentNullException(nameof(employeeService)); this.representationEntityPicker = representationEntityPicker ?? throw new ArgumentNullException(nameof(representationEntityPicker)); this.moneyRepository = moneyRepository ?? throw new ArgumentNullException(nameof(moneyRepository)); this.depositRepository = depositRepository ?? throw new ArgumentNullException(nameof(depositRepository)); this.bottlesRepository = bottlesRepository ?? throw new ArgumentNullException(nameof(bottlesRepository)); this.unitOfWorkFactory = unitOfWorkFactory ?? throw new ArgumentNullException(nameof(unitOfWorkFactory)); this.commonServices = commonServices ?? throw new ArgumentNullException(nameof(commonServices)); SetOrder(x => x.Date, true); UpdateOnChanges( typeof(Residue) ); }
public void DepositArrivedAndConfirmedTest_ChecksThatANewDepositInstanceIsCreatedAndConfirmedAsExpected_VerifiesThroughDatabaseQuery() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); string category = BitcoinConstants.ReceiveCategory; 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"); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); // Provide the amount which is greater than the daily limit transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, depositLimit.DailyLimit - 0.01M, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); // Deposit Transaction first arrival Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount); Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(TransactionStatus.Pending, deposit.Status); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNull(balance); // Deposit Confirmation depositApplicationService.OnDepositConfirmed(transactionId.Value, 7); deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount); Assert.AreEqual(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 instance now will have been created balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.AvailableBalance); Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.CurrentBalance); Assert.AreEqual(0, balance.PendingBalance); Assert.IsFalse(balance.IsFrozen); }
public CancelDepositChargeCommandHandler( INotificationHandler notificationHandler, IDepositRepository depositRepository, IEventBus eventBus) : base(notificationHandler) { _depositRepository = depositRepository; _eventBus = eventBus; }
public ScopedDepositService(ILogger <ScopedDepositService> logger, IMediator mediator, IDepositRepository depositRepository, IBankAccountRepository bankAccountRepository) { _logger = logger; _mediator = mediator; _depositRepository = depositRepository; _bankAccountRepository = bankAccountRepository; }
public OrderRepository(CustomerContext context, IProductRepository productRepository, ISiteRepository siteRepository, IDepositRepository depositRepository) { _context = context; _productRepository = productRepository; _siteRepository = siteRepository; _depositRepository = depositRepository; }
public TransactionsServiceTest() { accountRepository = Substitute.For <IAccountRepository>(); depositRepository = Substitute.For <IDepositRepository>(); withdrawRepository = Substitute.For <IWithdrawRepository>(); transferRepository = Substitute.For <ITransferRepository>(); transactionsService = new TransactionsService(accountRepository, depositRepository, withdrawRepository, transferRepository); }
public void DepositArrivedStandaloneFailedTest_TestsIfTheOperationIsAbortedWhenAmountIshigherThanThresholdLimit_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"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService; Assert.IsNotNull(tierLevelRetrievalService); 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"); 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); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(amount, deposit.Amount); Assert.AreEqual(currency.Name, deposit.Currency.Name); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value); Assert.AreEqual(TransactionStatus.Frozen, deposit.Status); // Confirm that the balance for the user has been frozen for this account balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.IsTrue(balance.IsFrozen); }
public TransactionsService( IAccountRepository accountRepository, IDepositRepository depositRepository, IWithdrawRepository withdrawRepository, ITransferRepository transferRepository) { this.accountRepository = accountRepository; this.depositRepository = depositRepository; this.withdrawRepository = withdrawRepository; this.transferRepository = transferRepository; }
public DepositService(IDepositRepository depositRepository, IMapper mapper, IPushpayService pushpayService, IConfigurationWrapper configurationWrapper, IRestClient restClient = null) { _depositRepository = depositRepository; _mapper = mapper; _pushpayService = pushpayService; _restClient = restClient ?? new RestClient(); _financePath = Environment.GetEnvironmentVariable("FINANCE_PATH") ?? configurationWrapper.GetMpConfigValue("CRDS-FINANCE", "FinanceMicroservicePath", true); _depositProcessingOffset = configurationWrapper.GetMpConfigIntValue("CRDS-FINANCE", "DepositProcessingOffset", true).GetValueOrDefault(); }
/// <summary> /// Default Constructor /// </summary> private DepositApplicationService(IFundsValidationService fundsValidationService, IClientInteractionService clientInteractionService, IFundsPersistenceRepository fundsPersistenceRepository, IDepositAddressRepository depositAddressRepository, IBalanceRepository balanceRepository, IDepositRepository depositRepository, IDepositLimitRepository depositLimitRepository) { _fundsValidationService = fundsValidationService; _clientInteractionService = clientInteractionService; _fundsPersistenceRepository = fundsPersistenceRepository; _depositAddressRepository = depositAddressRepository; _balanceRepository = balanceRepository; _depositRepository = depositRepository; _depositLimitRepository = depositLimitRepository; _clientInteractionService.DepositArrived += OnDepositArrival; _clientInteractionService.DepositConfirmed += OnDepositConfirmed; }
public DepositService(IDepositTypeRepository typeRepository, IDepositRepository repository, ILogger logger, ITransactionsRepository transactionsService, ICardService cardService, IAccountRepository accountRepository, IDepositTermService depositTermService, IUnitOfWork unitOfWork, IServiceRepository serviceRepository) { _depositTypeRepo = typeRepository; _DepositRepository = repository; _logger = logger; _transactionsService = transactionsService; _cardService = cardService; _accountRepository = accountRepository; _depositTermService = depositTermService; _unitOfWork = unitOfWork; _serviceRepository = serviceRepository; }
public DepositRepositoryTest() { _apiUserRepository = new Mock <IApiUserRepository>(MockBehavior.Strict); _restRequestBuilder = new Mock <IMinistryPlatformRestRequestBuilderFactory>(MockBehavior.Strict); _configurationWrapper = new Mock <IConfigurationWrapper>(MockBehavior.Strict); _restRequest = new Mock <IMinistryPlatformRestRequestBuilder>(MockBehavior.Strict); _mapper = new Mock <IMapper>(MockBehavior.Strict); _request = new Mock <IMinistryPlatformRestRequest>(); _apiUserRepository.Setup(r => r.GetDefaultApiUserToken()).Returns(token); _restRequestBuilder.Setup(m => m.NewRequestBuilder()).Returns(_restRequest.Object); _restRequest.Setup(m => m.WithAuthenticationToken(token)).Returns(_restRequest.Object); _restRequest.Setup(m => m.Build()).Returns(_request.Object); _fixture = new DepositRepository(_restRequestBuilder.Object, _apiUserRepository.Object, _configurationWrapper.Object, _mapper.Object); }
public UnitOfWork( BankDbContext context , IAccountRepository accountRepository , ICardRepository cardRepository , ICityRepository cityRepository , ICurrencyRepository currencyRepository , IDepositRepository depositRepository , IDepositTypeRepository depositTypeRepository , IEmploymentRepository employmentRepository , IEmploymentTypeRepository employmentTypeRepository , IInterestPaymentTypeRepository interestPaymentTypeRepository , ILoanRepository loanRepository , ILoanRequestRepository loanRequestRepository , ILoanTypeRepository loanTypeRepository , IQuestionRepository questionRepository , IServiceCategoryRepository serviceCategoryRepository , IServiceRepository serviceRepository , ITransactionsRepository transactionsRepository , IAccountPropertyRepository accountPropertyRepository ) { _context = context; _accountRepository = new Lazy <IAccountRepository>(accountRepository); _cardRepository = new Lazy <ICardRepository>(cardRepository); _cityRepository = new Lazy <ICityRepository>(cityRepository); _currencyRepository = new Lazy <ICurrencyRepository>(currencyRepository); _depositRepository = new Lazy <IDepositRepository>(depositRepository); _depositTypeRepository = new Lazy <IDepositTypeRepository>(depositTypeRepository); _employmentRepository = new Lazy <IEmploymentRepository>(employmentRepository); _employmentTypeRepository = new Lazy <IEmploymentTypeRepository>(employmentTypeRepository); _interestPaymentTypeRepository = new Lazy <IInterestPaymentTypeRepository>(interestPaymentTypeRepository); _loanRepository = new Lazy <ILoanRepository>(loanRepository); _loanRequestRepository = new Lazy <ILoanRequestRepository>(loanRequestRepository); _loanTypeRepository = new Lazy <ILoanTypeRepository>(loanTypeRepository); _questionRepository = new Lazy <IQuestionRepository>(questionRepository); _serviceCategoryRepository = new Lazy <IServiceCategoryRepository>(serviceCategoryRepository); _serviceRepository = new Lazy <IServiceRepository>(serviceRepository); _transactionsRepository = new Lazy <ITransactionsRepository>(transactionsRepository); _accountPropertyRepository = new Lazy <IAccountPropertyRepository>(accountPropertyRepository); }
public void DepositArrivedFailTest_VerifiesThatNewDepositWithAMountGreaterThanLimitsIsSuspendedAndAccountBalanceFrozen_VerifiesThroughDatabaseQuery() { IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"]; AccountId accountId = new AccountId(123); Currency currency = new Currency("BTC", true); BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1"); TransactionId transactionId = new TransactionId("transactionid1"); string category = BitcoinConstants.ReceiveCategory; 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"); List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >(); // Provide the amount which is greater than the daily limit transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, depositLimit.DailyLimit + 0.001M, category)); depositApplicationService.OnDepositArrival(currency.Name, transactionsList); Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId); Assert.IsNotNull(deposit); Assert.AreEqual(TransactionStatus.Frozen, deposit.Status); Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId); Assert.IsNotNull(balance); Assert.IsTrue(balance.IsFrozen); }
public ResidueViewModel( IEntityUoWBuilder uowBuilder, IUnitOfWorkFactory uowFactory, IEmployeeService employeeService, IRepresentationEntityPicker entityPicker, IBottlesRepository bottlesRepository, IDepositRepository depositRepository, IMoneyRepository moneyRepository, ICommonServices commonServices, IEntityAutocompleteSelectorFactory employeeSelectorFactory ) : base(uowBuilder, uowFactory, commonServices) { this.employeeService = employeeService ?? throw new ArgumentNullException(nameof(employeeService)); this.entityPicker = entityPicker ?? throw new ArgumentNullException(nameof(entityPicker)); this.bottlesRepository = bottlesRepository ?? throw new ArgumentNullException(nameof(bottlesRepository)); this.depositRepository = depositRepository ?? throw new ArgumentNullException(nameof(depositRepository)); this.moneyRepository = moneyRepository ?? throw new ArgumentNullException(nameof(moneyRepository)); TabName = "Ввод остатков"; if (CurrentEmployee == null) { AbortOpening("Ваш пользователь не привязан к действующему сотруднику, вы не можете создавать складские документы, " + "так как некого указывать в качестве кладовщика.", "Невозможно открыть ввод остатков"); } if (UoW.IsNew) { Entity.Author = CurrentEmployee; Entity.Date = new DateTime(2017, 4, 23); } CreateCommands(); ConfigureEntityPropertyChanges(); UpdateResidue(); GuiltyItemsVM = new GuiltyItemsViewModel( new Complaint(), UoW, commonServices, new SubdivisionRepository(new ParametersProvider()), employeeSelectorFactory); Entity.ObservableEquipmentDepositItems.PropertyOfElementChanged += OnObservableEquipmentItemsPropertyOfElementChanged; }
protected void RefreshSpinButtons(IBottlesRepository bottlesRepository, IDepositRepository depositRepository) { if (depositRepository == null) { throw new ArgumentNullException(nameof(depositRepository)); } if (bottlesRepository == null) { throw new ArgumentNullException(nameof(bottlesRepository)); } int bottlesMax = bottlesRepository.GetBottlesDebtAtCouterpartyAndDeliveryPoint(UoWGeneric, Entity.FromClient, Entity.FromDeliveryPoint, Entity.TimeStamp); decimal depositsBottlesMax = depositRepository.GetDepositsAtCounterpartyAndDeliveryPoint(UoWGeneric, Entity.FromClient, Entity.FromDeliveryPoint, DepositType.Bottles, Entity.TimeStamp); decimal depositsEquipmentMax = depositRepository.GetDepositsAtCounterpartyAndDeliveryPoint(UoWGeneric, Entity.FromClient, Entity.FromDeliveryPoint, DepositType.Equipment, Entity.TimeStamp); if (Entity.OutBottlesOperation != null) { spinBottles.Value = Entity.OutBottlesOperation.Returned != 0 ? Entity.OutBottlesOperation.Returned : (Entity.OutBottlesOperation.Delivered * -1); } else { spinBottles.Value = 0; } if (Entity.OutBottlesDepositOperation != null) { spinDepositsBottles.Value = (double)(Entity.OutBottlesDepositOperation.RefundDeposit != 0 ? Entity.OutBottlesDepositOperation.RefundDeposit : (Entity.OutBottlesDepositOperation.ReceivedDeposit * -1)); } else { spinDepositsBottles.Value = 0; } if (Entity.OutEquipmentDepositOperation != null) { spinDepositsEquipment.Value = (double)(Entity.OutEquipmentDepositOperation.RefundDeposit != 0 ? Entity.OutEquipmentDepositOperation.RefundDeposit : (Entity.OutEquipmentDepositOperation.ReceivedDeposit * -1)); } else { spinDepositsEquipment.Value = 0; } if (Math.Abs(bottlesMax) < Math.Abs(spinBottles.Value) || Math.Abs(depositsBottlesMax) < Math.Abs((decimal)spinDepositsBottles.Value) || Math.Abs(depositsEquipmentMax) < Math.Abs((decimal)spinDepositsEquipment.Value)) { checkbuttonLock.Active = false; } spinBottles.Sensitive = Entity.FromClient != null; labelBottlesMax.LabelProp = bottlesMax.ToString(); spinDepositsBottles.Sensitive = Entity.FromClient != null; labelDepositsBottlesMax.LabelProp = depositsBottlesMax.ToString(); spinDepositsEquipment.Sensitive = Entity.FromClient != null; labelDepositsEquipmentMax.LabelProp = depositsEquipmentMax.ToString(); if (checkbuttonLock.Active) { spinBottles.Adjustment.Upper = bottlesMax > 0 ? bottlesMax : 0; spinBottles.Adjustment.Lower = bottlesMax < 0 ? bottlesMax : 0; spinDepositsBottles.Adjustment.Upper = (double)(depositsBottlesMax > 0 ? depositsBottlesMax : 0); spinDepositsBottles.Adjustment.Lower = (double)(depositsBottlesMax < 0 ? depositsBottlesMax : 0); spinDepositsEquipment.Adjustment.Upper = (double)(depositsEquipmentMax > 0 ? depositsEquipmentMax : 0); spinDepositsEquipment.Adjustment.Lower = (double)(depositsEquipmentMax < 0 ? depositsEquipmentMax : 0); } else { spinBottles.Adjustment.Upper = 1000; spinBottles.Adjustment.Lower = -1000; spinDepositsBottles.Adjustment.Upper = 100000; spinDepositsBottles.Adjustment.Lower = -100000; spinDepositsEquipment.Adjustment.Upper = 100000; spinDepositsEquipment.Adjustment.Lower = -100000; } }
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); }
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); }
public DepositController(IMediator mediator, IDepositRepository depositRepository) { _mediator = mediator; _depositRepository = depositRepository; }
public void DepositCheckNewTransactionsTest_TestIfDepositHandlingIsDoneAsExpected_VerifiesThroughReturnedValue() { // Submits withdraw to own address, after the first NewTransactionInterval has been elapsed. // Checks if new deposit has been created by the DepositAPplicationService and DepositAddress marked used if (_shouldRunTests) { ICoinClientService coinClientService = (ICoinClientService)ContextRegistry.GetContext()["BitcoinClientService"]; IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"]; IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"]; IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"]; Currency currency = new Currency("BTC", true); AccountId accountId = new AccountId(1); string newAddress = coinClientService.CreateNewAddress(); BitcoinAddress bitcoinAddress = new BitcoinAddress(newAddress); DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId); fundsPersistenceRepository.SaveOrUpdate(depositAddress); // Check that there is no deposit with htis address present List <Deposit> deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress); Assert.AreEqual(0, deposits.Count); ManualResetEvent manualResetEvent = new ManualResetEvent(false); // Wait for the first interval to elapse, and then withdraw, because only then we will be able to figure if a // new transaction has been received manualResetEvent.WaitOne(Convert.ToInt32(coinClientService.PollingInterval + 3000)); manualResetEvent.Reset(); bool eventFired = false; coinClientService.DepositArrived += delegate(string curr, List <Tuple <string, string, decimal, string> > pendingList) { eventFired = true; manualResetEvent.Set(); }; Withdraw withdraw = new Withdraw(currency, Guid.NewGuid().ToString(), DateTime.Now, WithdrawType.Bitcoin, Amount, 0.001m, TransactionStatus.Pending, accountId, new BitcoinAddress(newAddress)); string withdrawTransactionId = coinClientService.CommitWithdraw(withdraw.BitcoinAddress.Value, withdraw.Amount); Assert.IsNotNull(withdrawTransactionId); Assert.IsFalse(string.IsNullOrEmpty(withdrawTransactionId)); manualResetEvent.WaitOne(); Assert.IsTrue(eventFired); depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress); Assert.IsNotNull(depositAddress); Assert.AreEqual(AddressStatus.Used, depositAddress.Status); // See If DepositApplicationService created the deposit instance deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress); Deposit deposit = deposits.Single(); Assert.IsNotNull(deposit); Assert.AreEqual(Amount, deposit.Amount); Assert.AreEqual(currency.Name, deposit.Currency.Name); Assert.IsFalse(string.IsNullOrEmpty(deposit.TransactionId.Value)); Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value); Assert.AreEqual(DepositType.Default, deposit.Type); Assert.AreEqual(0, deposit.Confirmations); Assert.AreEqual(accountId.Value, deposit.AccountId.Value); Assert.AreEqual(TransactionStatus.Pending, deposit.Status); Assert.AreEqual(withdrawTransactionId, deposit.TransactionId.Value); } }
public DepositService(IDepositTypeRepository depositTypeRepository, IDepositRepository depositRepository, IDateService dateService) { this.depositTypeRepository = depositTypeRepository; this.depositRepository = depositRepository; this.dateService = dateService; }
public DepositService(IDepositRepository repositoryDeposit) : base(repositoryDeposit) { _repositoryDeposit = repositoryDeposit; }
public CreateDepositCommandHandler( INotificationHandler notificationHandler, IDepositRepository depositRepository) : base(notificationHandler) { _depositRepository = depositRepository; }
public DepositController(IDepositRepository npRepo, IMapper mapper, ILoggerService logger) { _npRepo = npRepo; _mapper = mapper; _logger = logger; }
public DepositService(IDepositRepository depositRepository) { _depositRepository = depositRepository; }
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); }
public DepositService(IDepositRepository depositRepository, IMapper mapper, IOwnerRepository ownerRepository) { _depositRepository = depositRepository; _mapper = mapper; _ownerRepository = ownerRepository; }
public DepositService(IDepositRepository repo, IValidation <Deposit> validation) : base(repo, validation) { this.repo = repo; }
public DepositPaymentService(IDepositPaymentRepository depositPaymentRepository, IDepositRepository depositRepository, IDateService dateService) { this.depositPaymentRepository = depositPaymentRepository; this.depositRepository = depositRepository; this.dateService = dateService; }