/// <summary>
/// Imports data from a serialization object.
/// </summary>
/// <param name="serial"></param>
private void Import(SerializableCCPCharacter serial)
{
Import((SerializableSettingsCharacter)serial);
// Skill queue
SkillQueue.Import(serial.SkillQueue);
// Market orders
MarketOrdersImport(serial.MarketOrders);
// Contracts
ContractsImport(serial.Contracts);
// Industry jobs
IndustryJobsImport(serial.IndustryJobs);
// EVE mail messages IDs
EVEMailMessages.Import(serial.EveMailMessagesIDs);
// EVE notifications IDs
EVENotifications.Import(serial.EveNotificationsIDs);
// Kill Logs
KillLog.ImportFromCacheFile();
// Wallet Transactions
WalletTransactions.ImportFromCacheFile();
// Fire the global event
EveMonClient.OnCharacterUpdated(this);
}
public static WalletTransaction ToTransaction(this WalletTransactions tx)
{
return(new WalletTransaction
{
Id = tx.Id,
Type = tx.Type,
Date = tx.Date,
Amount = tx.Amount,
WalletId = tx.Wallet.Id,
Currency = tx.Wallet.Currency,
InvestmentProgramRequest = tx.InvestmentRequest == null
? null
: new InvestmentProgramRequestTxInfo
{
Status = tx.InvestmentRequest.Status,
Type = tx.InvestmentRequest.Type
},
InvestmentProgram = tx.InvestmentProgram == null
? null
: new InvestmentProgramTxInfo
{
Id = tx.InvestmentProgram.Id,
Title = tx.InvestmentProgram.Title
},
PaymentTx = tx.PaymentTransaction == null
? null
: new PaymentTxInfo
{
Id = tx.PaymentTransaction.Id,
Hash = tx.PaymentTransaction.Hash,
Address = tx.PaymentTransaction.BlockchainAddress.Address
}
});
}
public static void DisplayWalletTransactions(WalletTransactions transactions)
{
foreach (WalletTransactions.WalletTransactionItem transaction in transactions.WalletTransactionItems)
{
Console.WriteLine("Date: {0} Quantity: {1} Price: {2}", transaction.TransactionDateTimeLocal, transaction.Quantity, transaction.Price);
}
}
public async Task <Tuple <bool, string> > DeleteWalletExpenses(WalletTransactions walletTransactions)
{
int deleteExpensesStatus = -1;
Tuple <bool, string> deleteExpensesResult = null;
try
{
using (SqlConnection con = new SqlConnection(_dcDb))
{
var parameters = new DynamicParameters();
parameters.Add("@ID", walletTransactions.ID, DbType.Int32);
parameters.Add("@userID", UserID, DbType.Int32);
parameters.Add("@TransactionAmount", walletTransactions.TransactionAmount, DbType.Decimal);
deleteExpensesStatus = await con.ExecuteScalarAsync <int>("dbo.Update_WalletExpenses", parameters, commandType : CommandType.StoredProcedure);
if (deleteExpensesStatus == 0)
{
deleteExpensesResult = Tuple.Create(true, "Expenses details deleted successfully.");
}
else
{
deleteExpensesResult = Tuple.Create(false, "Expenses details deleted failed.");
}
}
}
catch (Exception ex)
{
ErrorLog.Write(ex);
deleteExpensesResult = Tuple.Create(false, "Oops! Expenses details deleted failed.Please try again.");
}
return(deleteExpensesResult);
}
public OperationResult CancelInvestmentRequest(Guid requestId)
{
return(InvokeOperations.InvokeOperation(() =>
{
var investmentRequest = context.InvestmentRequests
.Include(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.Id == requestId && x.Status == InvestmentRequestStatus.New);
investmentRequest.Status = InvestmentRequestStatus.Cancelled;
if (investmentRequest.Type == InvestmentRequestType.Invest)
{
var investor = investmentRequest.User;
var wallet = investor.Wallets.First(x => x.Currency == Currency.GVT);
var tx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.CancelInvestmentRequest,
WalletId = wallet.Id,
Amount = investmentRequest.Amount,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentRequest.InvestmentProgramtId
};
context.Add(tx);
wallet.Amount += investmentRequest.Amount;
}
context.SaveChanges();
}));
}
public async Task <IActionResult> Confirm(RegisterViewModel viewModel)
{
Wallet w = new Wallet()
{
Balance = 100
};
WalletTransactions t = new WalletTransactions()
{
Name = "Initial", Amount = 100
};
w.Transactions = new List <WalletTransactions>();
w.Transactions.Add(t);
MoneroUser user = new MoneroUser()
{
Email = viewModel.Email,
UserName = viewModel.Username,
Wallet = w
};
IdentityResult result = await _userManager.CreateAsync(user, viewModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
return(View(viewModel));
}
public async Task <Tuple <bool, string> > InsertWalletExpenses(WalletTransactions obj)
{
int addExpensesStatus = -1;
Tuple <bool, string> addExpensesResult = null;
try
{
using (SqlConnection con = new SqlConnection(_dcDb))
{
var parameters = new DynamicParameters();
if (obj.ID > 0)
{
parameters.Add("@ID", obj.ID, DbType.Int32);
}
parameters.Add("@userID", UserID, DbType.Int32);
parameters.Add("@TransactionAmount", obj.TransactionAmount, DbType.Decimal);
parameters.Add("@Purpose", obj.Purpose, DbType.String);
addExpensesStatus = await con.ExecuteScalarAsync <int>("dbo.Insert_WalletExpenses", parameters, commandType : CommandType.StoredProcedure);
if (addExpensesStatus == 0)
{
addExpensesResult = Tuple.Create(true, "You have Inserted Expenses Details successfully.");
}
}
}
catch (Exception ex)
{
ErrorLog.Write(ex);
addExpensesResult = Tuple.Create(false, "Oops! Expenses Details failed.");
}
return(addExpensesResult);
}
public ActionResult TransferClick(WalletTransactions walltrans)
{
if (!walletList.Contains(walltrans.walletname))
{
ViewBag.Acc = acc;
ViewBag.status = "Ví đích không tồn tại!";
return(View("Transfer"));
}
else
{
var mon = int.Parse(walltrans.money);
var balance = blockChain.GetBalance(acc);
if (balance <= mon)
{
ViewBag.Acc = acc;
ViewBag.status = "Số tiền chuyển không thể vượt quá số tiền trong ví" + " (" + balance.ToString() + " VCOIN) !";
return(View("Transfer"));
}
else
{
blockChain.CreateTransaction(new Transactions(acc, walltrans.walletname, mon));
blockChain.MineBlock(minerAddress);
ViewBag.AllChainContent = blockChain.GetHomeInfor();
return(View("Index"));
}
}
}
public OperationResult <Guid> CreateNewInvestmentRequest(NewInvestmentRequest request)
{
return(InvokeOperations.InvokeOperation(() =>
{
var rate = rateService.GetRate(Currency.GVT, Currency.USD);
if (!rate.IsSuccess)
{
throw new Exception("Cann't get rate GVT/USD");
}
var req = new ManagerRequests
{
Id = Guid.NewGuid(),
UserId = request.UserId,
Date = DateTime.UtcNow,
Type = ManagerRequestType.FromCabinet,
Status = ManagerRequestStatus.Created,
BrokerTradeServerId = request.BrokerTradeServerId,
DepositAmount = request.DepositAmount,
DepositInUsd = request.DepositAmount * rate.Data,
TradePlatformPassword = request.TradePlatformPassword,
TradePlatformCurrency = Currency.USD,
TokenName = request.TokenName,
TokenSymbol = request.TokenSymbol,
Logo = request.Logo,
Description = request.Description,
Title = request.Title,
DateFrom = request.DateFrom ?? DateTime.UtcNow,
DateTo = request.DateTo,
Period = request.Period,
FeeSuccess = request.FeeSuccess ?? 0,
FeeManagement = request.FeeManagement ?? 0,
FeeEntrance = 0,
InvestMaxAmount = request.InvestMaxAmount,
InvestMinAmount = request.InvestMinAmount ?? 0
};
var wallet = context.Wallets.First(x => x.UserId == request.UserId && x.Currency == Currency.GVT);
wallet.Amount -= req.DepositAmount;
var tx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.OpenProgram,
WalletId = wallet.Id,
Amount = request.DepositAmount,
Date = DateTime.UtcNow
};
context.Add(req);
context.Add(tx);
context.SaveChanges();
return req.Id;
}));
}
public async Task <IActionResult> Register(RegisterViewModel viewModel)
{
Wallet w = new Wallet()
{
Balance = 100
};
_dbContext.Add(w);
await _dbContext.SaveChangesAsync();
WalletTransactions t = new WalletTransactions()
{
Name = "Initial", Amount = 100
};
t.WalletId = w.Id;
_dbContext.Add(t);
await _dbContext.SaveChangesAsync();
//w.Transactions = new List<WalletTransactions>();
//w.Transactions.Add(t);
w.Balance = 150;
_dbContext.Update(w);
WalletTransactions transaction2 = new WalletTransactions()
{
Name = "Add Fifty", Amount = 50, WalletId = w.Id
};
_dbContext.Add(transaction2);
await _dbContext.SaveChangesAsync();
MoneroUser user = new MoneroUser()
{
Email = viewModel.Email,
UserName = viewModel.Username,
WalletId = w.Id
};
IdentityResult result = await _userManager.CreateAsync(user, viewModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
return(View(viewModel));
}
public async Task <Tuple <bool, string> > InsertWalletExpenses(WalletTransactions obj)
{
Tuple <bool, string> result = null;
try
{
result = await _repo.InsertWalletExpenses(obj);
}
catch (Exception ex)
{
ErrorLog.Write(ex);
}
return(result);
}
public static void WalletTransactionsExample()
{
bool done = false;
int lastEntrySeen = 0;
while (!done)
{
WalletTransactions transactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Character, 0, 0, "fullApiKey", lastEntrySeen);
DisplayWalletTransactions(transactions);
lastEntrySeen += transactions.WalletTransactionItems.Length;
if (transactions.WalletTransactionItems.Length < 1000)
{
done = true;
}
}
}
public OperationResult CloseInvestmentProgram(Guid invProgramId)
{
return(InvokeOperations.InvokeOperation(() =>
{
var investment = context.InvestmentPrograms
.Include(x => x.Periods)
.ThenInclude(x => x.InvestmentRequests)
.First(x => x.Id == invProgramId);
investment.DateTo = DateTime.UtcNow;
var plannedPeriod = investment.Periods.FirstOrDefault(x => x.Status == PeriodStatus.Planned);
if (plannedPeriod != null)
{
plannedPeriod.Status = PeriodStatus.Closed;
var pendingInvests = plannedPeriod.InvestmentRequests
.Where(x => x.Type == InvestmentRequestType.Invest &&
x.Status == InvestmentRequestStatus.New)
.ToList();
if (pendingInvests.Any())
{
foreach (var request in pendingInvests)
{
var wallet = context.Wallets.First(x => x.UserId == request.UserId && x.Currency == Currency.GVT);
wallet.Amount += request.Amount;
var tx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.CancelInvestmentRequest,
WalletId = wallet.Id,
Amount = request.Amount,
Date = DateTime.UtcNow,
InvestmentProgramtId = invProgramId
};
context.Add(tx);
}
pendingInvests.ForEach(x => x.Status = InvestmentRequestStatus.Cancelled);
}
}
context.SaveChanges();
}));
}
/// <summary>
/// Create a serializable character sheet for this character.
/// </summary>
/// <returns></returns>
public override SerializableSettingsCharacter Export()
{
SerializableCCPCharacter serial = new SerializableCCPCharacter();
Export(serial);
// Skill queue
serial.SkillQueue.AddRange(SkillQueue.Export());
// Market orders
serial.MarketOrders.AddRange(MarketOrdersExport());
// Contracts
serial.Contracts.AddRange(ContractsExport());
// Industry jobs
serial.IndustryJobs.AddRange(IndustryJobsExport());
// Eve mail messages IDs
serial.EveMailMessagesIDs = EVEMailMessages.Export();
// Eve notifications IDs
serial.EveNotificationsIDs = EVENotifications.Export();
// WalletTransactions to XML
WalletTransactions.ExportToCacheFile();
serial.LastWalletTransactionTime = WalletTransactions.Count == 0 ? DateTime.MinValue : WalletTransactions.Max(wt => wt.Date);
// Last API updates
if (QueryMonitors.Any())
{
m_lastAPIUpdates = QueryMonitors.Select(
monitor => new SerializableAPIUpdate
{
Method = monitor.Method.ToString(),
Time = monitor.LastUpdate
}).ToList();
}
serial.LastUpdates.AddRange(m_lastAPIUpdates);
return(serial);
}
public OperationResult Invest(Invest model)
{
return(InvokeOperations.InvokeOperation(() =>
{
var investor = context.Users
.Include(x => x.Wallets)
.First(x => x.Id == model.UserId);
var wallet = investor.Wallets.First(x => x.Currency == Currency.GVT);
var lastPeriod = context.Periods
.Where(x => x.InvestmentProgramId == model.InvestmentProgramId)
.OrderByDescending(x => x.Number)
.First();
var tx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.InvestToProgram,
WalletId = wallet.Id,
Amount = model.Amount,
Date = DateTime.UtcNow,
InvestmentProgramtId = model.InvestmentProgramId
};
var invRequest = new InvestmentRequests
{
Id = Guid.NewGuid(),
UserId = model.UserId,
Amount = model.Amount,
Date = DateTime.UtcNow,
InvestmentProgramtId = model.InvestmentProgramId,
Status = InvestmentRequestStatus.New,
Type = InvestmentRequestType.Invest,
PeriodId = lastPeriod.Id,
WalletTransactionId = tx.Id
};
wallet.Amount -= model.Amount;
context.Add(invRequest);
context.Add(tx);
context.SaveChanges();
}));
}
public void WalletTransactionsPersist()
{
ResponseCache.Clear();
WalletTransactions walletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Corporation, 0, 0, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
WalletTransactions cachedwalletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Corporation, 0, 0, "apiKey");
Assert.AreEqual(walletTransactions.CachedUntilLocal, cachedwalletTransactions.CachedUntilLocal);
for (int i = 0; i < walletTransactions.WalletTransactionItems.Length; i++)
{
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].CharacterId, cachedwalletTransactions.WalletTransactionItems[i].CharacterId);
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].ClientName, cachedwalletTransactions.WalletTransactionItems[i].ClientName);
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].Quantity, cachedwalletTransactions.WalletTransactionItems[i].Quantity);
}
}
public void GetCorpWalletTransactionsTest()
{
WalletTransactions walletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Corporation, 0, 0, "apiKey");
WalletTransactions.WalletTransactionItem transaction = walletTransactions.WalletTransactionItems[0];
Assert.AreEqual(4, walletTransactions.WalletTransactionItems.Length);
Assert.AreEqual(new DateTime(2008, 08, 04, 22, 01, 00), transaction.TransactionDateTime);
Assert.AreEqual(705664738, transaction.TransactionId);
Assert.AreEqual(50000, transaction.Quantity);
Assert.AreEqual("Oxygen Isotopes", transaction.TypeName);
Assert.AreEqual(17887, transaction.TypeId);
Assert.AreEqual(250.00, transaction.Price);
Assert.AreEqual(174312871, transaction.ClientId);
Assert.AreEqual("ACHAR", transaction.ClientName);
Assert.AreEqual(000000000, transaction.CharacterId);
Assert.AreEqual("SELLER", transaction.CharacterName);
Assert.AreEqual(60004375, transaction.StationId);
Assert.AreEqual("SYSTEM IV - Moon 10 - Corporate Police Force Testing Facilities", transaction.StationName);
Assert.AreEqual("buy", transaction.TransactionType);
Assert.AreEqual("corporation", transaction.TransactionFor);
}
public void GetCharWalletTransactionsTest()
{
WalletTransactions walletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Character, 0, 0, "apiKey");
Assert.AreEqual(7, walletTransactions.WalletTransactionItems.Length);
WalletTransactions.WalletTransactionItem transaction = walletTransactions.WalletTransactionItems[0];
Assert.AreEqual(7, walletTransactions.WalletTransactionItems.Length);
Assert.AreEqual(new DateTime(2010, 02, 07, 03, 34, 00), transaction.TransactionDateTime);
Assert.AreEqual(1309776438, transaction.TransactionId);
Assert.AreEqual(1, transaction.Quantity);
Assert.AreEqual("Information Warfare", transaction.TypeName);
Assert.AreEqual(20495, transaction.TypeId);
// Assert.AreEqual(34101.06, transaction.Price);
Assert.AreEqual(1034922339, transaction.ClientId);
Assert.AreEqual("Elthana", transaction.ClientName);
Assert.AreEqual(60003760, transaction.StationId);
Assert.AreEqual("Jita IV - Moon 4 - Caldari Navy Assembly Plant", transaction.StationName);
Assert.AreEqual("buy", transaction.TransactionType);
Assert.AreEqual("personal", transaction.TransactionFor);
}
private async Task LoadWalletTransactions(Wallet wallet)
{
WalletTransactions.Clear();
try
{
var walletConnection = new WalletConnector(wallet.Host, wallet.Port, wallet.User, wallet.Pass, 60000 * 4);
var wallettransactions = await walletConnection.GetTransactionsAsync("", _selectedTransactionType);
var transactions = wallettransactions.Select(x => new WalletTransaction
{
Timestamp = x.Time.ToDateTime(),
Account = x.Account,
Amount = Math.Abs(x.Amount),
Txid = x.Txid,
Type = Cryptopia.WalletAPI.Helpers.Extensions.ToTransactionType(x.Category),
Address = x.Address,
Confirmations = x.Confirmations
})
.OrderByDescending(x => x.Timestamp);
int refesh = 10;
foreach (var item in transactions)
{
WalletTransactions.Add(item);
refesh--;
if (refesh < 0)
{
refesh = 10;
await Task.Delay(1);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Something went wrong \n" + ex.ToString());
}
}
public OperationResult AccrueProfits(InvestmentProgramAccrual accrual)
{
return(InvokeOperations.InvokeOperation(() =>
{
var GVTUSDRate = rateService.GetRate(Currency.GVT, Currency.USD);
if (!GVTUSDRate.IsSuccess)
{
throw new Exception("Error at GetRate: " + string.Join(", ", GVTUSDRate.Errors));
}
var lastPeriod = context.Periods
.Where(x => x.InvestmentProgramId == accrual.InvestmentProgramId)
.OrderByDescending(x => x.Number)
.First();
var investmentProgram = context.InvestmentPrograms
.Include(x => x.ManagerAccount)
.ThenInclude(x => x.BrokerTradeServer)
.ThenInclude(x => x.Broker)
.ThenInclude(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.Id == accrual.InvestmentProgramId);
var totalProfit = accrual.Accruals.Sum(a => a.Amount);
var wallet = investmentProgram.ManagerAccount.BrokerTradeServer.Broker.User.Wallets.First(x => x.Currency == Currency.GVT);
var brokerAmount = totalProfit / GVTUSDRate.Data;
wallet.Amount -= brokerAmount;
var brokerTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.ProfitFromProgram,
Amount = -brokerAmount,
Date = DateTime.UtcNow,
WalletId = wallet.Id,
InvestmentProgramtId = accrual.InvestmentProgramId
};
var brokerProfitDistribution = new ProfitDistributionTransactions
{
PeriodId = lastPeriod.Id,
WalletTransactionId = brokerTx.Id
};
context.Add(brokerTx);
context.Add(brokerProfitDistribution);
foreach (var acc in accrual.Accruals)
{
var investor = context.InvestorAccounts
.Include(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.UserId == acc.InvestorId);
var investorWallet = investor.User.Wallets.First(x => x.Currency == Currency.GVT);
var investorAmount = acc.Amount / GVTUSDRate.Data;
investorWallet.Amount += investorAmount;
var investorTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.ProfitFromProgram,
Amount = investorAmount,
Date = DateTime.UtcNow,
WalletId = investorWallet.Id,
InvestmentProgramtId = accrual.InvestmentProgramId
};
var investorProfitDistribution = new ProfitDistributionTransactions
{
PeriodId = lastPeriod.Id,
WalletTransactionId = investorTx.Id
};
context.Add(investorTx);
context.Add(investorProfitDistribution);
}
//ToDo: update manager's next period balance
context.SaveChanges();
}));
}
public OperationResult <BalanceChange> ProcessInvestmentRequests(Guid investmentProgramId)
{
return(InvokeOperations.InvokeOperation(() =>
{
var result = new BalanceChange();
decimal brokerBalanceChange = 0;
//Todo: manager's threshold amount
var managerThresholdAmount = 1000;
var GVTUSDRate = rateService.GetRate(Currency.GVT, Currency.USD);
if (!GVTUSDRate.IsSuccess)
{
throw new Exception("Error at GetRate: " + string.Join(", ", GVTUSDRate.Errors));
}
var nextPeriod = context.Periods
.Include(x => x.InvestmentRequests)
.First(x => x.InvestmentProgramId == investmentProgramId && x.Status == PeriodStatus.Planned);
var investmentProgram = context.InvestmentPrograms
.Include(x => x.Token)
.Include(x => x.ManagerAccount)
.ThenInclude(x => x.BrokerTradeServer)
.ThenInclude(x => x.Broker)
.ThenInclude(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.Id == investmentProgramId);
var brokerWalletId = investmentProgram.ManagerAccount.BrokerTradeServer.Broker.User.Id;
var GVTToManagerTokenRate = GVTUSDRate.Data / investmentProgram.Token.InitialPrice;
foreach (var request in nextPeriod.InvestmentRequests
.OrderByDescending(x => x.Type)
.ThenBy(x => x.Date)
.Where(x => x.Status == InvestmentRequestStatus.New && x.UserId != investmentProgram.ManagerAccount.UserId))
{
request.Status = InvestmentRequestStatus.Executed;
var investor = context.InvestorAccounts
.Include(x => x.InvestorTokens)
.Include(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.UserId == request.UserId);
var investorTokens = investor.InvestorTokens.FirstOrDefault(x => x.ManagerTokenId == investmentProgram.Token.Id);
if (request.Type == InvestmentRequestType.Invest)
{
//ToDo: Actual value in manager's currency to request
var tokensAmount = request.Amount * GVTToManagerTokenRate;
var gvtAmount = request.Amount;
if (investmentProgram.Token.FreeTokens == 0)
{
//ToDo: separate refund transaction?
CancelInvestmentRequest(request.Id);
continue;
}
if (tokensAmount > investmentProgram.Token.FreeTokens)
{
gvtAmount = investmentProgram.Token.FreeTokens * investmentProgram.Token.InitialPrice / GVTUSDRate.Data;
tokensAmount = investmentProgram.Token.FreeTokens;
var wallet = investor.User.Wallets.First(x => x.Currency == Currency.GVT);
wallet.Amount += request.Amount - gvtAmount;
var tx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.PartialInvestmentExecutionRefund,
WalletId = wallet.Id,
Amount = request.Amount - gvtAmount,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentProgramId
};
context.Add(tx);
}
brokerBalanceChange += gvtAmount;
result.AccountBalanceChange += gvtAmount * GVTUSDRate.Data;
if (investorTokens == null)
{
var newPortfolio = new InvestorTokens
{
Id = Guid.NewGuid(),
InvestorAccountId = request.UserId,
ManagerTokenId = investmentProgram.Token.Id,
Amount = tokensAmount
};
context.Add(newPortfolio);
}
else
{
investorTokens.Amount += tokensAmount;
}
investmentProgram.Token.FreeTokens -= tokensAmount;
}
else
{
var investorTokensValue = investorTokens.Amount * investmentProgram.Token.InitialPrice;
//ToDo: Actual amount to request
var amount = investorTokensValue > request.Amount ? request.Amount : investorTokensValue;
var amountInGVT = amount / GVTUSDRate.Data;
brokerBalanceChange -= amountInGVT;
result.AccountBalanceChange -= amount;
var tokensAmount = amount / investmentProgram.Token.InitialPrice;
investorTokens.Amount -= tokensAmount;
investmentProgram.Token.FreeTokens += tokensAmount;
var wallet = investor.User.Wallets.First(x => x.Currency == Currency.GVT);
wallet.Amount += amountInGVT;
var investorTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.WithdrawFromProgram,
WalletId = wallet.Id,
Amount = amountInGVT,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentProgramId
};
context.Add(investorTx);
}
}
foreach (var request in nextPeriod.InvestmentRequests
.Where(i => i.Status == InvestmentRequestStatus.New && i.UserId == investmentProgram.ManagerAccount.UserId))
{
request.Status = InvestmentRequestStatus.Executed;
if (request.Type == InvestmentRequestType.Invest)
{
brokerBalanceChange += request.Amount;
result.AccountBalanceChange += request.Amount * GVTUSDRate.Data;
result.ManagerBalanceChange += request.Amount * GVTUSDRate.Data;
}
else
{
var amount = nextPeriod.ManagerStartBalance > request.Amount + managerThresholdAmount
? request.Amount
: nextPeriod.ManagerStartBalance - managerThresholdAmount;
var amountInGVT = amount / GVTUSDRate.Data;
brokerBalanceChange -= amountInGVT;
result.AccountBalanceChange -= amount;
result.ManagerBalanceChange -= amount;
var manager = context.Users
.Include(x => x.Wallets)
.First(x => x.Id == investmentProgram.ManagerAccount.UserId);
var wallet = manager.Wallets.First(x => x.Currency == Currency.GVT);
wallet.Amount += amountInGVT;
var managerTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.WithdrawFromProgram,
Amount = amountInGVT,
Date = DateTime.UtcNow,
WalletId = wallet.Id,
InvestmentProgramtId = investmentProgramId
};
context.Add(managerTx);
}
}
//ToDo: Transaction record?
investmentProgram.ManagerAccount.BrokerTradeServer.Broker.User.Wallets.First(x => x.Currency == Currency.GVT).Amount += brokerBalanceChange;
context.SaveChanges();
return result;
}));
}
public OperationResult ProcessClosingProgram(Guid investmentProgramId, decimal managerBalance)
{
return(InvokeOperations.InvokeOperation(() =>
{
decimal brokerBalanceChange = 0;
var USDGVTRate = rateService.GetRate(Currency.USD, Currency.GVT);
if (!USDGVTRate.IsSuccess)
{
throw new Exception("Error at GetRate: " + string.Join(", ", USDGVTRate.Errors));
}
var investmentProgram = context.InvestmentPrograms
.Include(x => x.Token)
.ThenInclude(x => x.InvestorTokens)
.Include(x => x.ManagerAccount)
.ThenInclude(x => x.BrokerTradeServer)
.ThenInclude(x => x.Broker)
.ThenInclude(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.Id == investmentProgramId);
var tokenGVTRate = investmentProgram.Token.InitialPrice * USDGVTRate.Data;
//Process investors
foreach (var holder in investmentProgram.Token.InvestorTokens)
{
var gvtAmount = holder.Amount * tokenGVTRate;
var investor = context.InvestorAccounts
.Include(x => x.User)
.ThenInclude(x => x.Wallets)
.First(x => x.UserId == holder.InvestorAccountId);
var wallet = investor.User.Wallets.First(x => x.Currency == Currency.GVT);
wallet.Amount += gvtAmount;
var investorTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.ClosingProgramRefund,
WalletId = wallet.Id,
Amount = gvtAmount,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentProgramId
};
context.Add(investorTx);
brokerBalanceChange += gvtAmount;
holder.Amount = 0;
}
//Process manager
var managerAmountInGVT = managerBalance * USDGVTRate.Data;
var manager = context.Users
.Include(x => x.Wallets)
.First(x => x.Id == investmentProgram.ManagerAccount.UserId);
var managerWallet = manager.Wallets.First(x => x.Currency == Currency.GVT);
managerWallet.Amount += managerAmountInGVT;
var managerTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.ClosingProgramRefund,
WalletId = managerWallet.Id,
Amount = managerAmountInGVT,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentProgramId
};
context.Add(managerTx);
brokerBalanceChange += managerAmountInGVT;
//Process broker
var brokerWallet = investmentProgram.ManagerAccount.BrokerTradeServer.Broker.User.Wallets.First(x => x.Currency == Currency.GVT);
brokerWallet.Amount -= brokerBalanceChange;
var brokerTx = new WalletTransactions
{
Id = Guid.NewGuid(),
Type = WalletTransactionsType.ClosingProgramRefund,
WalletId = brokerWallet.Id,
Amount = managerAmountInGVT,
Date = DateTime.UtcNow,
InvestmentProgramtId = investmentProgramId
};
context.Add(brokerTx);
context.SaveChanges();
ClosePeriod(investmentProgramId);
}));
}
public async Task <PaymentTransactionInfo> ProcessCallback(ProcessPaymentTransaction request)
{
var blockchainAddress = context.BlockchainAddresses.FirstOrDefault(addr => addr.Address == request.Address);
if (blockchainAddress == null)
{
var msg = $"Eth address not found - {request.Address}";
logger.LogError(msg);
throw new ApplicationException(msg);
}
if (request.Currency != blockchainAddress.Currency)
{
var msg = $"Wallet and Transaction currency should be the same {blockchainAddress.Id}";
logger.LogError(msg);
throw new ApplicationException(msg);
}
var wallet = context.Wallets.First(w => w.UserId == blockchainAddress.UserId && w.Currency == blockchainAddress.Currency);
PaymentTransactionInfo paymentTransactionInfo;
using (var transaction = await context.Database.BeginTransactionAsync())
{
var paymentTransaction = context.PaymentTransactions
.FirstOrDefault(t => t.Hash == request.TransactionHash &&
t.BlockchainAddressId == blockchainAddress.Id);
if (paymentTransaction != null)
{
if (paymentTransaction.Status == PaymentTransactionStatus.Pending ||
paymentTransaction.Status == PaymentTransactionStatus.New)
{
paymentTransaction.Status = request.Status;
paymentTransaction.LastUpdated = DateTime.UtcNow;
context.Update(paymentTransaction);
await context.SaveChangesAsync();
}
else
{
logger.LogError($"Can not override status from {paymentTransaction.Status} to {request.Status}");
}
}
else
{
var walletTransactions = new WalletTransactions()
{
Id = Guid.NewGuid(),
WalletId = wallet.Id,
Type = WalletTransactionsType.Deposit,
Date = DateTime.UtcNow,
Amount = request.Amount
};
context.WalletTransactions.Add(walletTransactions);
await context.SaveChangesAsync();
paymentTransaction = new PaymentTransactions
{
Id = Guid.NewGuid(),
Hash = request.TransactionHash,
Type = PaymentTransactionType.Deposit,
BlockchainAddressId = blockchainAddress.Id,
Amount = request.Amount,
Fee = request.Fee,
DateCreated = DateTime.UtcNow,
Status = request.Status,
PayoutTxHash = request.PayoutTxHash,
PayoutServiceFee = request.PayoutServiceFee,
PayoutMinerFee = request.PayoutMinerFee,
WalletTransaction = walletTransactions
};
context.PaymentTransactions.Add(paymentTransaction);
if (paymentTransaction.Status == PaymentTransactionStatus.ConfirmedAndValidated)
{
wallet.Amount += paymentTransaction.Amount;
await context.SaveChangesAsync();
}
}
transaction.Commit();
paymentTransactionInfo = new PaymentTransactionInfo
{
TransactionId = paymentTransaction.Id,
TransactionHash = paymentTransaction.Hash,
Amount = paymentTransaction.Amount,
Currency = request.Currency.ToString(),
GatewayCode = request.GatewayCode,
Status = paymentTransaction.Status,
IsValid = true
};
}
return(paymentTransactionInfo);
}
