static async Task Main(string[] args)
{
var stockRepository = new StockRepository();
var walletRepository = new WalletRepository();
var twoPhaseTransactions = new List<TwoPhaseTransaction>()
{
new DecreaseStockQuantityTransaction(stockRepository,
new Dictionary<string, string>() {{"productId", "12"}, {"quantity", "10"}}),
new DecreaseWalletBalanceTransaction(walletRepository,
new Dictionary<string, string>() {{"userId", "150"}, {"totalPrice", "4000"}})
};
var tasks = new List<Task>();
twoPhaseTransactions.ForEach(x => tasks.Add(x.PrepareTransaction()));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
if (twoPhaseTransactions.All(x => x.Status is TransactionStatus.Prepared))
{
twoPhaseTransactions.ForEach(x => tasks.Add(x.CommitTransaction()));
}
else
{
twoPhaseTransactions.Where(x => x.Status is TransactionStatus.Prepared)
.ToList().ForEach(x => tasks.Add(x.RollBackTransaction()));
}
Task.WaitAll(tasks.ToArray());
}
public WalletsController(StoreRepository repo,
AtomicSwapRepository atomicSwapRepository,
WalletRepository walletRepository,
CurrencyNameTable currencyTable,
BTCPayNetworkProvider networkProvider,
UserManager <ApplicationUser> userManager,
MvcNewtonsoftJsonOptions mvcJsonOptions,
NBXplorerDashboard dashboard,
RateFetcher rateProvider,
IAuthorizationService authorizationService,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
BTCPayWalletProvider walletProvider,
AtomicSwapClientFactory atomicSwapClientFactory)
{
_currencyTable = currencyTable;
Repository = repo;
WalletRepository = walletRepository;
RateFetcher = rateProvider;
_authorizationService = authorizationService;
NetworkProvider = networkProvider;
_userManager = userManager;
_serializerSettings = mvcJsonOptions.SerializerSettings;
_dashboard = dashboard;
ExplorerClientProvider = explorerProvider;
_feeRateProvider = feeRateProvider;
_walletProvider = walletProvider;
AtomicSwapClientFactory = atomicSwapClientFactory;
AtomicSwapRepository = atomicSwapRepository;
}
private static async Task CreateIndexesAsync(string settingsUrl)
{
if (!Uri.TryCreate(settingsUrl, UriKind.Absolute, out _))
{
Console.WriteLine($"{SettingsUrl} should be a valid uri");
return;
}
var logFactory = LogFactory.Create()
.AddConsole();
var settings = new SettingsServiceReloadingManager <AppSettings>(settingsUrl, p => { }).Nested(x => x.BlockchainWalletsService.Db.DataConnString);
var defaultWalletsRepository = (WalletRepository)WalletRepository.Create(settings, logFactory);
string continuationToken = null;
Console.WriteLine("Creating Indexes...");
var progressCounter = 0;
do
{
try
{
IEnumerable <WalletDto> wallets;
(wallets, continuationToken) = await defaultWalletsRepository.GetAllAsync(100, continuationToken);
foreach (var defaultWallet in wallets)
{
await defaultWalletsRepository.AddAsync
(
defaultWallet.BlockchainType,
defaultWallet.AssetId,
defaultWallet.ClientId,
defaultWallet.Address
);
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write($"{++progressCounter} indexes created");
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace + " " + e.Message);
}
} while (continuationToken != null);
if (progressCounter == 0)
{
Console.WriteLine("Nothing to create");
}
else
{
Console.WriteLine();
Console.WriteLine($"Added indexes to {progressCounter} wallets");
}
}
public void TestOutOfStockFromOrderPanel()
{
// setup the tested class instance and dependencies with the test case initialization.
MockDisplayPanel displayPanel = new MockDisplayPanel();
MockOrderPanel orderPanel = new MockOrderPanel();
MockPaymentReceiver paymentReceiver = new MockPaymentReceiver();
MockVendingMessageRepository messageRepository = new MockVendingMessageRepository();
ProductRepository productRepository = new ProductRepository();
WalletRepository walletRepository = new WalletRepository();
SoldRecord saleRecord = new SoldRecord();
VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository);
InitProductRepository(productRepository, 0, 0);
// !!! setup order state
vendingMachineController.VendingMachineState = VendingMachineState.Order;
// Test subject Action - out of stock
orderPanel.InvokeOrderAction(OrderCmdEvent.OutOfStock, null);
Assert.Equal(VendingMachineState.OutOfStock, vendingMachineController.VendingMachineState);
// verify - out of stock
Assert.True(orderPanel.OffCalled);
Assert.Equal(0, productRepository.CountProduct(PrdA.Code));
// verify the message flow
List <MessageCode> TestCatchedCodes = new List <MessageCode>
{
MessageCode.OutOfStock
};
Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes);
Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList);
}
public void TestSelectOrderFromOrderPanel()
{
// setup the tested class instance and dependencies with the test case initialization.
MockDisplayPanel displayPanel = new MockDisplayPanel();
MockOrderPanel orderPanel = new MockOrderPanel();
MockPaymentReceiver paymentReceiver = new MockPaymentReceiver();
MockVendingMessageRepository messageRepository = new MockVendingMessageRepository();
ProductRepository productRepository = new ProductRepository();
WalletRepository walletRepository = new WalletRepository();
SoldRecord saleRecord = new SoldRecord();
VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository);
InitProductRepository(productRepository, 1, 1);
// !!! setup order state
vendingMachineController.VendingMachineState = VendingMachineState.Order;
// Test subject Action - select order as product A
orderPanel.InvokeOrderAction(OrderCmdEvent.Select, PrdA);
Assert.Equal(VendingMachineState.Payment, vendingMachineController.VendingMachineState);
// verify - select order as product A
Assert.True(orderPanel.OffCalled);
Assert.True(paymentReceiver.OnCalled);
Assert.Equal(0, productRepository.CountProduct(PrdA.Code));
// verify the message flow
List <MessageCode> TestCatchedCodes = new List <MessageCode>
{
MessageCode.Checkout
};
Assert.Equal(TestCatchedCodes, messageRepository.CatchedCodes);
Assert.Equal(messageRepository.ReturnList, displayPanel.DisplayList);
}
public async Task <WalletRecord> IncomeOfOrderRebate(UserIdentifier userIdentifier, decimal money, string remark, Order order)
{
WalletRecord walletRecord = BuildWalletRecord(WalletRecordType.Recharge, userIdentifier.UserId, money, remark);
WalletRecordRepository.Insert(walletRecord);
Wallet wallet = GetWalletOfUser(userIdentifier);
wallet.Money += money;
WalletRepository.Update(wallet);
CurrentUnitOfWork.SaveChanges();
string openid = WechatUserManager.GetOpenid(userIdentifier);
if (!string.IsNullOrEmpty(openid))
{
OrderRebateTemplateMessageData data = new OrderRebateTemplateMessageData(
new TemplateDataItem(remark),
new TemplateDataItem(order.Number),
new TemplateDataItem(order.PayMoney.ToString()),
new TemplateDataItem(order.PaymentDatetime.ToString()),
new TemplateDataItem(money.ToString()),
new TemplateDataItem(L("ThankYouForYourPatronage"))
);
await TemplateMessageManager.SendTemplateMessageOfOrderRebateAsync(order.TenantId, openid, null, data);
}
return(walletRecord);
}
public StoreOnChainWalletsController(
IAuthorizationService authorizationService,
BTCPayWalletProvider btcPayWalletProvider,
BTCPayNetworkProvider btcPayNetworkProvider,
WalletRepository walletRepository,
ExplorerClientProvider explorerClientProvider,
CssThemeManager cssThemeManager,
NBXplorerDashboard nbXplorerDashboard,
WalletsController walletsController,
PayjoinClient payjoinClient,
DelayedTransactionBroadcaster delayedTransactionBroadcaster,
EventAggregator eventAggregator,
WalletReceiveService walletReceiveService)
{
_authorizationService = authorizationService;
_btcPayWalletProvider = btcPayWalletProvider;
_btcPayNetworkProvider = btcPayNetworkProvider;
_walletRepository = walletRepository;
_explorerClientProvider = explorerClientProvider;
_cssThemeManager = cssThemeManager;
_nbXplorerDashboard = nbXplorerDashboard;
_walletsController = walletsController;
_payjoinClient = payjoinClient;
_delayedTransactionBroadcaster = delayedTransactionBroadcaster;
_eventAggregator = eventAggregator;
_walletReceiveService = walletReceiveService;
}
private ReturnObject AddSendTransactionToBlockchainAddress(UserSendTransaction sendTransaction)
{
try
{
using (var walletRepository = new WalletRepository(_connectionDb))
{
var walletBusiness =
new WalletBusiness.WalletBusiness(_vakapayRepositoryFactory, false);
var wallet =
walletRepository.FindByUserAndNetwork(sendTransaction.UserId, sendTransaction.Currency);
if (wallet == null)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message =
$"UserId {sendTransaction.UserId} with {sendTransaction.Currency} wallet is not found!"
});
}
var res = walletBusiness.Withdraw(wallet, sendTransaction.To, sendTransaction.Amount,
sendTransaction.PricePerCoin, sendTransaction.Description);
return(res);
}
}
catch (Exception e)
{
_logger.Error(e.Message);
throw;
}
}
public void TestOff()
{
// setup the tested class instance and dependencies with the test case initialization.
MockDisplayPanel displayPanel = new MockDisplayPanel();
MockOrderPanel orderPanel = new MockOrderPanel();
MockPaymentReceiver paymentReceiver = new MockPaymentReceiver();
MockVendingMessageRepository messageRepository = new MockVendingMessageRepository();
ProductRepository productRepository = new ProductRepository();
WalletRepository walletRepository = new WalletRepository();
SoldRecord saleRecord = new SoldRecord();
VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository);
// Test subject Action - off
vendingMachineController.Off();
// verify - off
Assert.True(orderPanel.OffCalled);
Assert.True(paymentReceiver.OffCalled);
Assert.Equal(VendingMachineState.TurnedOff, vendingMachineController.VendingMachineState);
// verify the message flow
List <MessageCode> TestCatchedCodes = new List <MessageCode>
{
MessageCode.OutOfServise
};
Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes);
Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList);
}
protected override void Load(ContainerBuilder builder)
{
var connectionString = _dbSettings.Nested(x => x.DataConnString);
builder
.Register(c => WalletRepository.Create(connectionString, c.Resolve <ILogFactory>()))
.As <IWalletRepository>()
.SingleInstance();
builder
.Register(c => BlockchainWalletsRepository.Create(connectionString, c.Resolve <ILogFactory>()))
.As <IBlockchainWalletsRepository>()
.SingleInstance();
builder
.Register(c => FirstGenerationBlockchainWalletRepository.Create(_dbSettings.Nested(x => x.ClientPersonalInfoConnString), c.Resolve <ILogFactory>()))
.As <IFirstGenerationBlockchainWalletRepository>()
.SingleInstance();
builder
.Register(c => MonitoringSubscriptionRepository.Create(connectionString, c.Resolve <ILogFactory>()))
.As <IMonitoringSubscriptionRepository>()
.SingleInstance();
builder
.Register(c => WalletCredentialsHistoryRepository.Create(_dbSettings.Nested(x => x.ClientPersonalInfoConnString), c.Resolve <ILogFactory>()))
.As <IWalletCredentialsHistoryRepository>()
.SingleInstance();
}
public GreenfieldStoreOnChainWalletsController(
IAuthorizationService authorizationService,
BTCPayWalletProvider btcPayWalletProvider,
BTCPayNetworkProvider btcPayNetworkProvider,
WalletRepository walletRepository,
ExplorerClientProvider explorerClientProvider,
NBXplorerDashboard nbXplorerDashboard,
PoliciesSettings policiesSettings,
UIWalletsController walletsController,
PayjoinClient payjoinClient,
DelayedTransactionBroadcaster delayedTransactionBroadcaster,
EventAggregator eventAggregator,
WalletReceiveService walletReceiveService,
IFeeProviderFactory feeProviderFactory,
LabelFactory labelFactory
)
{
_authorizationService = authorizationService;
_btcPayWalletProvider = btcPayWalletProvider;
_btcPayNetworkProvider = btcPayNetworkProvider;
_walletRepository = walletRepository;
_explorerClientProvider = explorerClientProvider;
PoliciesSettings = policiesSettings;
_nbXplorerDashboard = nbXplorerDashboard;
_walletsController = walletsController;
_payjoinClient = payjoinClient;
_delayedTransactionBroadcaster = delayedTransactionBroadcaster;
_eventAggregator = eventAggregator;
_walletReceiveService = walletReceiveService;
_feeProviderFactory = feeProviderFactory;
_labelFactory = labelFactory;
}
public void ExceptionsWalletTest()
{
WalletRepository wallet = new WalletRepository();
Assert.Throws <InvalidDataException>(() => { wallet.AddToWallet(p10, -1); });
Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, 1); });
Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, 0); });
Assert.Throws <ArgumentNullException>(() => { wallet.AddToWallet(null, -1); });
Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 1); });
wallet.AddToWallet(p10, 1);
Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, -1); });
Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 2); });
wallet.RemoveFromWallet(p10, 1);
Assert.Throws <InvalidDataException>(() => { wallet.RemoveFromWallet(p10, 1); });
Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, -1); });
Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, 0); });
Assert.Throws <ArgumentNullException>(() => { wallet.RemoveFromWallet(null, 1); });
Assert.Throws <NotImplementedException>(() => { wallet.ClearMoney(); });
try
{
PaymentWalletRepository pwallet = new PaymentWalletRepository();
pwallet.ClearMoney();
}
catch
{
Assert.True(false);
}
}
public void AddWalletTest()
{
WalletRepository wallet = new WalletRepository();
// Add
wallet.AddToWallet(p5, 1);
wallet.AddToWallet(p10, 2);
wallet.AddToWallet(p20, 3);
wallet.AddToWallet(p50, 4);
wallet.AddToWallet(p100, 5);
// verify
var content = wallet.WalletList;
Assert.Single(content.Where(c => c.Item1.MoneyValue == p5.MoneyValue));
Assert.Single(content.Where(c => c.Item1.MoneyValue == p10.MoneyValue));
Assert.Single(content.Where(c => c.Item1.MoneyValue == p20.MoneyValue));
Assert.Single(content.Where(c => c.Item1.MoneyValue == p50.MoneyValue));
Assert.Single(content.Where(c => c.Item1.MoneyValue == p100.MoneyValue));
Assert.Equal(1, content.Single(c => c.Item1.Nominal == p5.Nominal).Item2);
Assert.Equal(2, content.Single(c => c.Item1.Nominal == p10.Nominal).Item2);
Assert.Equal(3, content.Single(c => c.Item1.Nominal == p20.Nominal).Item2);
Assert.Equal(4, content.Single(c => c.Item1.Nominal == p50.Nominal).Item2);
Assert.Equal(5, content.Single(c => c.Item1.Nominal == p100.Nominal).Item2);
}
public async Task GetLastWalletEntryAsync_SingleEntry_ReturnsTheEntry()
{
//// Arrange
// Setup In-Memory Database at desired state
DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>()
.UseInMemoryDatabase(databaseName: "GetLastWalletEntryAsync_SingleEntry_ReturnsTheEntry")
.Options;
WalletEntry expectedEntry = new WalletEntry {
Id = Guid.NewGuid().ToString(), EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0
};
using (WalletContext context = new WalletContext(dbContextOptions))
{
context.Add(expectedEntry);
context.SaveChanges();
}
//// Act
WalletEntry actualEntry;
using (WalletContext context = new WalletContext(dbContextOptions))
{
IWalletRepository walletRepository = new WalletRepository(context);
actualEntry = await walletRepository.GetLastWalletEntryAsync();
}
//// Assert
Assert.NotNull(actualEntry);
actualEntry.ShouldCompare(expectedEntry);
}
public void TestGetUserWalletSubscriptionAndLastPaymentsInner()
{
var user = conn.PLATFORM_USER.First(u => u.SUBSCRIPTION.Count > 2 && u.TRANSFER.Count > 5);
var subsCount = user.SUBSCRIPTION.Count;
int paymentsTotal;
List <Contract.Entity.Subscription> subscriptions;
List <Transfer> transfers;
WalletError error;
var repo = new WalletRepository();
var wallet = repo.GetUserWalletSubscriptionAndLastPaymentsInner(user.Login,
100, out paymentsTotal, out subscriptions, out transfers, out error);
Assert.AreEqual(WalletError.OK, error, "GetUserWalletSubscriptionAndLastPaymentsInner - должно быть ОК");
Assert.IsNotNull(wallet, "GetUserWalletSubscriptionAndLastPaymentsInner - кошелек должен быть получен");
Assert.Greater(paymentsTotal, 5, "GetUserWalletSubscriptionAndLastPaymentsInner - платежей должно быть больше N");
Assert.Greater(transfers.Count, 0, "GetUserWalletSubscriptionAndLastPaymentsInner - платежи должны быть получены");
Assert.AreEqual(subscriptions.Count, subsCount, "GetUserWalletSubscriptionAndLastPaymentsInner - подписки должны быть получены");
var distinctSubscriptionServiceAccounts =
subscriptions.Select(s => s.PaidService.AccountId).Distinct().Count();
Assert.AreEqual(distinctSubscriptionServiceAccounts, subscriptions.Count,
"GetUserWalletSubscriptionAndLastPaymentsInner - инф. о подписке должна быть заполнена");
}
public async Task InsertWalletAsync_MissingId_ThrowsInvalidOperationException()
{
//// Arrange
// Setup In-Memory Database at desired state
DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>()
.UseInMemoryDatabase(databaseName: "InsertWalletAsync_MissingId_ThrowsInvalidOperationException")
.Options;
// Initialize Entry
WalletEntry missingIdEntry = new WalletEntry {
Id = null, EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0
};
//// Act / Assert
using (WalletContext context = new WalletContext(dbContextOptions))
{
IWalletRepository walletRepository = new WalletRepository(context);
await Assert.ThrowsAsync <InvalidOperationException>(() =>
walletRepository.InsertWalletEntryAsync(missingIdEntry)
);
}
}
public async Task InsertWalletAsync_NoEntries_SingleWalletEntry()
{
//// Arrange
// Setup In-Memory Database at desired state
DbContextOptions <WalletContext> dbContextOptions = new DbContextOptionsBuilder <WalletContext>()
.UseInMemoryDatabase(databaseName: "InsertWalletAsync_NoEntries_SingleWalletEntry")
.Options;
// Initialize Entry
WalletEntry expectedEntry = new WalletEntry {
Id = Guid.NewGuid().ToString(), EventTime = DateTime.UtcNow, Amount = 10, BalanceBefore = 0
};
//// Act
using (WalletContext context = new WalletContext(dbContextOptions))
{
IWalletRepository walletRepository = new WalletRepository(context);
await walletRepository.InsertWalletEntryAsync(expectedEntry);
}
//// Assert
DbSet <WalletEntry> actualWalletEntries;
using (WalletContext context = new WalletContext(dbContextOptions))
{
actualWalletEntries = context.Transactions;
Assert.Collection(actualWalletEntries, actualWalletEntry => actualWalletEntry.ShouldCompare(expectedEntry));
}
}
public unit_test_WalletRepo()
{
//Setting up In memory dbs.
userdb = new SqliteConnection("DataSource=:memory:");
passdb = new SqliteConnection("DataSource=:memory:");
walletdb = new SqliteConnection("DataSource=:memory:");
userdb.Open();
passdb.Open();
walletdb.Open();
var userbuild = new DbContextOptionsBuilder <UserModelContext>()
.UseSqlite(userdb).Options;
var passbuild = new DbContextOptionsBuilder <PassModelContext>()
.UseSqlite(passdb).Options;
var walletbuild = new DbContextOptionsBuilder <WalletContext>()
.UseSqlite(walletdb).Options;
var userContext = new UserModelContext(userbuild);
var passContext = new PassModelContext(passbuild);
var walletContext = new WalletContext(walletbuild);
//Drop and create
userContext.Database.EnsureDeleted();
userContext.Database.EnsureCreated();
passContext.Database.EnsureDeleted();
passContext.Database.EnsureCreated();
walletContext.Database.EnsureDeleted();
walletContext.Database.EnsureCreated();
//Seeding data to test on
SeedUsers.seedUsers(userContext, passContext, walletContext);
_uut = new WalletRepository(walletContext);
}
public void TestOrderPaymentChangeGivenFromOrderPanel()
{
// setup the tested class instance and dependencies with the test case initialization.
MockDisplayPanel displayPanel = new MockDisplayPanel();
MockOrderPanel orderPanel = new MockOrderPanel();
MockPaymentReceiver paymentReceiver = new MockPaymentReceiver();
MockVendingMessageRepository messageRepository = new MockVendingMessageRepository();
ProductRepository productRepository = new ProductRepository();
WalletRepository walletRepository = new WalletRepository();
SoldRecord saleRecord = new SoldRecord();
VendingMachineController vendingMachineController = new VendingMachineController(displayPanel, paymentReceiver, orderPanel, productRepository, walletRepository, saleRecord, messageRepository);
InitProductRepository(productRepository, 1, 1);
// !!! setup order state
vendingMachineController.VendingMachineState = VendingMachineState.Order;
// setup wallet repository
walletRepository.AddToWallet(new Coin(5), 1);
walletRepository.AddToWallet(new Coin(10), 1);
walletRepository.AddToWallet(new Coin(20), 1);
walletRepository.AddToWallet(new Coin(50), 1);
var before = walletRepository.WalletList.Aggregate(Money.Zero, (m, p) => m + new Money(0, (int)p.Item1.Nominal * p.Item2));
// Test subject Action - select order as product A
orderPanel.InvokeOrderAction(OrderCmdEvent.Select, PrdA);
Assert.Equal(VendingMachineState.Payment, vendingMachineController.VendingMachineState);
// verify reserved product
Assert.Equal(PrdA, vendingMachineController.OrderedProducts[0]);
// complete payment without change
paymentReceiver.InvokeCoinAction(PaymentCmdEvent.Payment, new Coin(100));
// verify switch back to order state
Assert.True(paymentReceiver.OffCalled);
Assert.True(orderPanel.OnCalled);
Assert.Equal(VendingMachineState.Order, vendingMachineController.VendingMachineState);
// verify money in the wallet
var total = walletRepository.WalletList.Aggregate(Money.Zero, (m, p) => m + new Money(0, (int)p.Item1.Nominal * p.Item2));
Assert.Equal(before + PrdA.Price, total);
// verify the message flow
List <MessageCode> TestCatchedCodes = new List <MessageCode>
{
MessageCode.Checkout,
MessageCode.BalancePayment,
MessageCode.GivenChange,
MessageCode.GivenChange,
MessageCode.GivenChange,
MessageCode.CollectYourPurchase,
MessageCode.ReadyToService,
};
Assert.Equal((IEnumerable <MessageCode>)TestCatchedCodes, (IEnumerable <MessageCode>)messageRepository.CatchedCodes);
Assert.Equal((IEnumerable <string>)messageRepository.ReturnList, (IEnumerable <string>)displayPanel.DisplayList);
}
public GameController(IOptions <ConnectionStrings> connIn)
{
_gameRepo = new GameRepository(connIn.Value.DefaultConnection);
_engine = new GameEngineRepository(connIn.Value.DefaultConnection);
_diceRepo = new DiceRepository(connIn.Value.DefaultConnection);
_shake = new ShakeValueRepository(connIn.Value.DefaultConnection);
_wallets = new WalletRepository(connIn.Value.DefaultConnection);
}
public UnitOfWorkMock(IPlayersWalletContext context)
{
Context = context;
Players = new PlayerRepository(Context);
Wallets = new WalletRepository(Context);
Transactions = new TransactionRepository(Context);
TransactionResponseCache = new TransactionResponseCacheRepository(Context);
}
public LabelFactory(
LinkGenerator linkGenerator,
WalletRepository walletRepository
)
{
_linkGenerator = linkGenerator;
_walletRepository = walletRepository;
}
public ReturnObject ValidateWithdrawAmount(string userId,
bool sendByBlockchainAddress, decimal amount, string sendTransactionFee, string currency)
{
try
{
// Validate amount
if (amount <= 0)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message = "Withdraw balance must be positive."
});
}
using (var walletRepository = new WalletRepository(_connectionDb))
{
var wallet = walletRepository.FindByUserAndNetwork(userId, currency);
if (sendByBlockchainAddress == true)
{
if (amount + GetFee(currency) > wallet.Balance)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message = "Withdraw balance + fee is larger than wallet balance."
});
}
}
else
{
if (amount > wallet.Balance)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message = "Withdraw balance larger than wallet balance."
});
}
}
return(new ReturnObject()
{
Status = Status.STATUS_SUCCESS
});
}
}
catch (Exception e)
{
return(new ReturnObject()
{
Status = Status.STATUS_ERROR,
Message = "Validate amount throw exception."
});
}
}
public async Task UpdateBalance_ReturnsUpdatedWalletForExistingTransaction()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json");
var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson).First(w => w.User.Id == TESTING_USER_ID);
string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json");
var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson)
.First(c => c.IsCustom && c.User.Id == TESTING_USER_ID);
string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Transactions.json");
var transaction = JsonConvert.DeserializeObject <List <Transaction> >(transactionsJson)
.First(t => t.User.Id == TESTING_USER_ID && t.Category.Id == category.Id);
transaction.User = user;
transaction.Category = category;
transaction.Wallet = wallet;
double initBalance = wallet.Balance;
const string newTitle = "Test title";
const double newAmount = 100;
DateTime newDate = DateTime.Today.AddDays(-1);
var newTransaction = new Transaction
{
Id = transaction.Id,
User = user,
Category = category,
Wallet = wallet,
Amount = newAmount,
Title = newTitle,
Date = newDate
};
WalletRepository.Setup(w => w.Update(wallet)).ReturnsAsync(wallet);
var resultWallet = await WalletService.UpdateBalance(newTransaction, transaction, isUpdate : true);
Assert.NotNull(resultWallet);
Assert.NotNull(resultWallet.Currency);
Assert.Equal(wallet.Currency.Abbreviation, resultWallet.Currency.Abbreviation);
Assert.Equal(wallet.Name, resultWallet.Name);
Assert.Equal(wallet.IsDefault, resultWallet.IsDefault);
if (category.Type.Name == TransactionType.Options.Income.ToString())
{
Assert.Equal(initBalance - transaction.Amount - newAmount, resultWallet.Balance);
}
else if (category.Type.Name == TransactionType.Options.Expense.ToString())
{
Assert.Equal(initBalance + transaction.Amount - newAmount, resultWallet.Balance);
}
}
public WalletControllerTest(ContextFixture contextFixture)
{
var walletRepository = new WalletRepository(contextFixture.ApiContext);
var cryptoRepository = new CryptoRepository(contextFixture.ApiContext);
var emailEmailService = new EmailService();
var coinMarketCapApiService = new WalletOperationsService(emailEmailService);
_walletController = new WalletController(walletRepository, cryptoRepository, coinMarketCapApiService);
}
public async Task Delete_ReturnsDeletedTransaction()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json");
var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson)
.First(c => c.IsCustom && c.User.Id == TESTING_USER_ID);
string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json");
var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson)
.First(w => w.IsDefault);
string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Transactions.json");
var transaction = JsonConvert.DeserializeObject <List <Transaction> >(transactionsJson)
.First(u => u.User.Id == TESTING_USER_ID && u.Category.Id == category.Id);
double initBalance = wallet.Balance;
transaction.User = user;
transaction.Category = category;
transaction.Wallet = wallet;
WalletRepository.Setup(w => w.Update(wallet)).ReturnsAsync(wallet);
TransactionRepository.Setup(t => t.GetByKey(transaction.Id)).Returns(transaction);
TransactionRepository.Setup(t => t.Delete(transaction.Id)).ReturnsAsync(transaction);
ContextProvider
.Setup(c => c.GetService <IWalletService>())
.Returns(WalletService);
var resultTransaction = await TransactionService.Delete(transaction.Id);
Assert.NotNull(resultTransaction);
Assert.NotNull(resultTransaction.User);
Assert.NotNull(resultTransaction.Category);
Assert.NotNull(resultTransaction.Wallet);
Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id);
Assert.Equal(category.Id, resultTransaction.Category.Id);
Assert.Equal(wallet.Id, resultTransaction.Wallet.Id);
Assert.Equal(transaction.Title, resultTransaction.Title);
Assert.Equal(transaction.Amount, resultTransaction.Amount);
Assert.Equal(transaction.Date, resultTransaction.Date);
if (category.Type.Name == TransactionType.Options.Income.ToString())
{
Assert.Equal(initBalance - transaction.Amount, resultTransaction.Wallet.Balance);
}
else if (category.Type.Name == TransactionType.Options.Expense.ToString())
{
Assert.Equal(initBalance + transaction.Amount, resultTransaction.Wallet.Balance);
}
}
public ControlCashDbContext()
: base("name=ControlCashDb")
{
LimitRepository = new LimitRepository(this);
MovimentHistoryRepository = new MovimentHistoryRepository(this);
UserRepository = new UserRepository(this);
WalletRepository = new WalletRepository(this);
LimitHistoryRepository = new LimitHistoryRepository(this);
}
public void SetUp()
{
_wallet = new PlayerWallet();
_repository = Substitute.For <WalletRepository>();
_repository.Get().Returns(Observable.Return(_wallet));
_walletService = new WalletService(_repository);
}
public async Task Create_ReturnsNewTransaction()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json");
var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson)
.First(c => !c.IsCustom || c.User.Id == TESTING_USER_ID);
string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json");
var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson)
.First(w => !w.IsDefault && w.User.Id == TESTING_USER_ID);
const string newTitle = "Test title";
const double newAmount = 101;
string newInterval = RegularTransaction.IntervalOptions.Month.ToString();
DateTime newNextDate = DateTime.Today.AddDays(7);
var newTransaction = new RegularTransaction
{
Title = newTitle,
Amount = newAmount,
CategoryId = category.Id,
NextTransactionDate = newNextDate,
Interval = newInterval,
WalletId = wallet.Id
};
UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user);
CategoryRepository.Setup(c => c.GetByKey(category.Id)).Returns(category);
RecurringTransactionRepository
.Setup(t => t.Create(newTransaction))
.ReturnsAsync(newTransaction);
WalletRepository.Setup(w => w.GetByKey(wallet.Id)).Returns(wallet);
var resultTransaction = await RecurringTransactionService.Create(newTransaction);
Assert.NotNull(resultTransaction);
Assert.NotNull(resultTransaction.User);
Assert.NotNull(resultTransaction.Category);
Assert.NotNull(resultTransaction.Wallet);
Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id);
Assert.Equal(category.Id, resultTransaction.Category.Id);
Assert.Equal(wallet.Id, resultTransaction.Wallet.Id);
Assert.Equal(newTitle, resultTransaction.Title);
Assert.Equal(newAmount, resultTransaction.Amount);
Assert.Equal(newInterval, resultTransaction.Interval);
Assert.Equal(DateTime.Today, resultTransaction.Date);
Assert.Equal(newNextDate, resultTransaction.NextTransactionDate);
}
private Wallet CreateWalletOfUser(UserIdentifier userIdentifier)
{
Wallet wallet = new Wallet()
{
UserId = userIdentifier.UserId
};
WalletRepository.Insert(wallet);
unitOfWorkManager.Current.SaveChanges();
return(wallet);
}
