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