/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public FundsValidationService(ITransactionService transactionService, IFundsPersistenceRepository
fundsPersistenceRepository, IBalanceRepository balanceRepository,
IFeeCalculationService feeCalculationService, IWithdrawFeesRepository withdrawFeesRepository,
IWithdrawIdGeneratorService withdrawIdGeneratorService, ILedgerRepository ledgerRepository,
IDepositLimitEvaluationService depositLimitEvaluationService, IDepositLimitRepository depositLimitRepository,
IWithdrawLimitEvaluationService withdrawLimitEvaluationService, IWithdrawLimitRepository withdrawLimitRepository,
ITierLevelRetrievalService tierLevelRetrievalService,
IWithdrawRepository withdrawRepository, ITierValidationService tierValidationService,
ILimitsConfigurationService limitsConfigurationService)
{
_transactionService = transactionService;
_fundsPersistenceRepository = fundsPersistenceRepository;
_balanceRepository = balanceRepository;
_feeCalculationService = feeCalculationService;
_withdrawFeesRepository = withdrawFeesRepository;
_withdrawIdGeneratorService = withdrawIdGeneratorService;
_ledgerRepository = ledgerRepository;
_depositLimitEvaluationService = depositLimitEvaluationService;
_depositLimitRepository = depositLimitRepository;
_withdrawLimitEvaluationService = withdrawLimitEvaluationService;
_withdrawLimitRepository = withdrawLimitRepository;
_tierLevelRetrievalService = tierLevelRetrievalService;
_withdrawRepository = withdrawRepository;
_tierValidationService = tierValidationService;
_limitsConfigurationService = limitsConfigurationService;
}
public void AddDepositAndCheckReturnedParameterTest_TestsIfTheReturnedLedgerFromDepositContainsSameValuesAsGivenDeposit_ComparesVariables()
{
ITransactionService transactionService = (ITransactionService)ContextRegistry.GetContext()["TransactionService"];
ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
Deposit deposit = new Deposit(new Currency("LTC"), "depositid123", DateTime.Now, DepositType.Default, 300, 0, TransactionStatus.Pending,
new AccountId(123), new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
deposit.IncrementConfirmations();
bool response = transactionService.CreateDepositTransaction(deposit, 300);
Assert.IsTrue(response);
Ledger depositTransaction1 = ledgerRepository.GetLedgerByAccountId(new AccountId(123)).Single();
Assert.IsNotNull(depositTransaction1);
Assert.AreEqual(deposit.Currency.Name, depositTransaction1.Currency.Name);
Assert.AreEqual(deposit.Amount, depositTransaction1.Amount);
Assert.AreEqual(300, depositTransaction1.Balance);
Assert.AreEqual(deposit.DepositId, depositTransaction1.DepositId);
Assert.AreEqual(deposit.AccountId.Value, depositTransaction1.AccountId.Value);
}
public List <Ledger> GetLedgersByCompany(Company company)
{
if (company == null)
{
throw new ArgumentNullException(nameof(company));
}
return(ExecuteFaultHandledOperation(() =>
{
ILedgerRepository ledger_repo = _data_repository_factory.GetDataRepository <ILedgerRepository>();
// _business_engine_factory
List <Ledger> ledgers = new List <Ledger>();
CompanyData comp = new CompanyData();
comp.CompanyKey = company.CompanyKey;
IEnumerable <LedgerData> ledgers_data = ledger_repo.GetAll(comp);
foreach (LedgerData ledger_data in ledgers_data)
{
Ledger ledger = MapLedgerDataToLedger(ledger_data);
ledgers.Add(ledger);
}
return ledgers;
}));
}
/// ---------------------------------------------------------------------
/// <summary>
/// Base Constructor
/// </summary>
/// ---------------------------------------------------------------------
public LedgerController()
{
var conndirection = Convert.ToInt32(Resources.CONN_DIRECTION);
string server, database, userid, password;
ConnectionHelpers.ConnStringParameters(conndirection, out server, out database, out userid, out password);
_ledgerRepository = new LedgerRepository(conndirection, server, database, userid, password);
}
public void AddDepositTest_TestsIfBalanceEndsUpAsExpected_VerifiesThroughDatabaseQuery()
{
ITransactionService transactionService = (ITransactionService)ContextRegistry.GetContext()["TransactionService"];
ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
Deposit deposit = new Deposit(new Currency("LTC"), "depositid123", DateTime.Now, DepositType.Default, 300, 0, TransactionStatus.Pending,
new AccountId(123), new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
deposit.IncrementConfirmations(7);
bool response = transactionService.CreateDepositTransaction(deposit, 300);
Assert.IsTrue(response);
Ledger depositTransaction1 = ledgerRepository.GetLedgerByAccountId(new AccountId(123)).Single();
Assert.IsNotNull(depositTransaction1);
List <Ledger> ledgerByAccountId = ledgerRepository.GetLedgerByAccountId(deposit.AccountId);
// There will be no ledgers yet as the deposit did not had 7 confirmations
Assert.AreEqual(1, ledgerByAccountId.Count);
Assert.AreEqual("LTC", ledgerByAccountId.Single().Currency.Name);
Assert.AreEqual(300, ledgerByAccountId.Single().Amount);
Assert.AreEqual(300, ledgerByAccountId.Single().Balance);
Assert.AreEqual("depositid123", ledgerByAccountId.Single().DepositId);
Assert.AreEqual(123, ledgerByAccountId.Single().AccountId.Value);
}
public SellableItemService(IMapper mapper, ISellableItemRepository sellableItemRepository,
ILedgerRepository ledgerRepository, ITokenService tokenService)
{
_tokenService = tokenService;
_mapper = mapper;
_sellableItemRepository = sellableItemRepository;
_ledgerRepository = ledgerRepository;
}
public BuyerService(ISellerRepository sellerRepository,
IBuyerRepository buyerRepository,
ILedgerRepository ledgerRepository)
{
_sellerRepository = sellerRepository;
_buyerRepository = buyerRepository;
_ledgerRepository = ledgerRepository;
}
public LedgereTests()
{
var connectionString = "mongodb://localhost:27017";
var databaseName = "invoicito_test";
this.client = new MongoClient(connectionString);
this.db = this.client.GetDatabase(databaseName);
this.ledgerRepository = new LedgerRepository(this.db);
}
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 void Setup()
{
_ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
_persistanceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
var connection = ConfigurationManager.ConnectionStrings["MySql"].ToString();
_databaseUtility = new DatabaseUtility(connection);
_databaseUtility.Create();
_databaseUtility.Populate();
}
public bool LedgerDelete(Ledger ledger)
{
return(ExecuteFaultHandledOperation(() =>
{
ILedgerRepository ledger_repo = _data_repository_factory.GetDataRepository <ILedgerRepository>();
LedgerData ledger_data = MapLedgerToLedgerData(ledger);
ledger_repo.Delete(ledger_data);
return true;
}));
}
public int LedgerSave(Ledger ledger)
{
if (ledger == null)
{
throw new ArgumentNullException(nameof(ledger));
}
return(ExecuteFaultHandledOperation(() =>
{
ILedgerRepository ledger_repo = _data_repository_factory.GetDataRepository <ILedgerRepository>();
int ledger_key;
LedgerData prod_data = MapLedgerToLedgerData(ledger);
ledger_key = ledger_repo.Insert(prod_data);
return ledger_key;
}));
}
public Ledger GetLedgerByID(int ledger_key)
{
Log.Info("Accessing LedgerBusinessEngine GetLedgerByID function");
return(ExecuteFaultHandledOperation(() =>
{
ILedgerRepository ledger_repo = _data_repository_factory.GetDataRepository <ILedgerRepository>();
LedgerData ledger_data = ledger_repo.GetByID(ledger_key);
Log.Info("LedgerBusinessEngine GetByID function completed");
if (ledger_data.LedgerKey != 0)
{
Ledger ledger = MapLedgerDataToLedger(ledger_data);
return ledger;
}
else
{
NotFoundException ex = new NotFoundException(string.Format("Ledger with key {0} is not in database", ledger_key));
throw new FaultException <NotFoundException>(ex, ex.Message);
}
}));
}
public Ledger(ILedgerRepository ledgerRepository)
{
this.ledgerRepository = ledgerRepository;
}
public AccountService(IAccountRepository accountRepository, ILedgerRepository ledgerRepository)
{
_accountRepository = accountRepository;
_ledgerRepository = ledgerRepository;
}
public EntriesController(ILedgerRepository repo, IMapper mapper, IVMFactory vmFactory)
{
_repo = repo;
_mapper = mapper;
_vmFactory = vmFactory;
}
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 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 LedgerSvcController(ILedgerRepository aLedgerRepo,
IAccountRepository aAccRepo)
{
LedgerRepo = aLedgerRepo;
AccRepo = aAccRepo;
}
public LedgerHeadController(ILedgerRepository repo)
{
ledgerRepository = repo;
}
public ReportController(ITransactionRepository repoTran, ILedgerRepository repoLedg)
{
transactionRepository = repoTran;
ledgerRepository = repoLedg;
}
public LedgerTypeController(ILedgerRepository repo)
{
ledgerRepository = repo;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public LedgerQueryService(ILedgerRepository ledgerRepository)
{
_ledgerRepository = ledgerRepository;
}
public TokenService(IMapper mapper, ILedgerRepository repository)
{
_mapper = mapper;
_repository = repository;
}
public LedgerService()
{
_repository = new SqlLedgerRepository();
}
/// <summary>
/// Constructor for Demo Data Generator
/// </summary>
/// <param name="ledgerRepo">Repository provider for Ledger</param>
/// <param name="tranRepo">Repository provider for Transaction</param>
public IDemoDataGenerator(ILedgerRepository ledgerRepo, ITransactionRepository tranRepo)
{
LedgerRepository = ledgerRepo;
TransactionRepository = tranRepo;
}
public LedgerService(ILedgerRepository repository)
{
this._repository = repository;
}
public LedgerAccountController(ILedgerRepository repo)
{
ledgerRepository = repo;
}
public LedgersController(ILedgerRepository ledgerRepository)
{
this.ledgerRepository = ledgerRepository;
}
public LedgerController(ILedgerRepository repo)
{
_repo = repo;
}
public SampleData(ILedgerRepository ledgerRepo, ITransactionRepository tranRepo) : base(ledgerRepo, tranRepo)
{
}
