public JsonResult GetTransactionData()
{
try
{
var transactions = TransactionBusiness.GetTransactionData();
if (transactions != null)
{
return(new JsonResult {
Data = transactions, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
else
{
return(new JsonResult {
Data = "Error!!"
});
}
}
catch (Exception ex)
{
return(new JsonResult {
Data = ex
});
}
}
public bool Transfer(int senderId, int receiverId, decimal amount)
{
try
{
using (var transactionBussiness = new TransactionBusiness())
{
Transactions transaction = new Transactions()
{
TransactorAccountNumber = senderId,
ReceiverAccountNumber = receiverId,
TransactionAmount = amount,
TransactionDate = DateTime.Now,
isSuccess = false
};
using (var customerBussiness = new CustomersBusiness())
{
return(transactionBussiness.MakeTransaction(transaction, customerBussiness.SelectCustomerById(senderId), customerBussiness.SelectCustomerById(receiverId)));
}
}
}
catch (Exception e)
{
LogHelper.Log(LogTarget.File, "Transfer failed betweeen: " + senderId + " and " + receiverId + "." + "\n" + ExceptionHelper.ExceptionToString(e));
return(false);
}
}
public JsonResult AddTransaction(TransactionData newTransaction)
{
try
{
var transactions = TransactionBusiness.PostTransactionData(newTransaction);
if (transactions != null)
{
return(new JsonResult {
Data = transactions
});
}
else
{
return(new JsonResult {
Data = "Error!!"
});
}
}
catch (Exception ex)
{
return(new JsonResult {
Data = ex
});
}
}
public Ulaz()
{
this.transactionBusiness = new TransactionBusiness();
this.userBusiness = new UserBusiness();
this.balanceBusiness = new BalanceBusiness();
InitializeComponent();
}
public bool Withdraw(int senderId, decimal amount)
{
try
{
using (var transactionBussiness = new TransactionBusiness())
{
Transactions transaction = new Transactions()
{
TransactorAccountNumber = senderId,
ReceiverAccountNumber = null,
TransactionAmount = amount,
TransactionDate = DateTime.Now,
isSuccess = false
};
using (var customerBussiness = new CustomersBusiness())
{
return(transactionBussiness.WithdrawMoney(transaction, customerBussiness.SelectCustomerById(senderId)));
}
}
}
catch (Exception e)
{
LogHelper.Log(LogTarget.File, "Withdraw failed: " + senderId + "." + "\n" + ExceptionHelper.ExceptionToString(e));
return(false);
}
}
public void MakeTransactions()
{
var pendingCreation = EscrowResultBusiness.ListPendingCreation();
foreach (var pending in pendingCreation)
{
try
{
var from = UserBusiness.GetWithWallet(pending.LastTransaction.UserId).Wallet.Address;
var value = Math.Max(pending.OwnerTokenResult, pending.BuyerTokenResult);
string to;
if (pending.OwnerTokenResult > 0)
{
to = UserBusiness.GetOwner(pending.BuyId).Wallet.Address;
}
else
{
to = from;
}
var transactionHash = Web3.Web3Business.MakeEscrowResultTransaction(from, to, value).TransactionHash;
TransactionBusiness.SetTransactionHash(pending.LastTransaction, transactionHash);
}
catch (Exception ex)
{
Logger.LogCritical(ex, $"Exception on make escrow result transaction for {pending.Id}");
}
}
}
private void Create(int userId, int buyId, string transactionHash)
{
TransactionBusiness.ValidateTransaction(transactionHash);
using (var transaction = new TransactionalDapperCommand())
{
InternalCreate(transaction, userId, buyId, transactionHash);
transaction.Commit();
}
}
private void InternalCreate(TransactionalDapperCommand transaction, int userId, int buyId, string transactionHash)
{
var trans = TransactionBusiness.SetNew(userId, transactionHash);
transaction.Insert(trans);
var buyTrans = BuyTransactionBusiness.SetNew(buyId, trans.Id);
transaction.Insert(buyTrans);
}
public async Task ListTransactions_WithoutParameters_InvokesRefreshTransactionsMethodFromDataLayer()
{
Mock <ITransactionData> data = new Mock <ITransactionData>();
data.Setup(m => m.ListTransactions()).Returns(Task.FromResult(oneTransaction));
data.Setup(m => m.RefreshTransactions(oneTransaction));
ITransactionBusiness sut = new TransactionBusiness(data.Object, commonFakes.Mapper);
List <Transaction> result = await sut.ListTransactions();
data.Verify(m => m.RefreshTransactions(oneTransaction), Times.Once());
}
public async Task ListTransactions_WithoutParameters_ReturnsATransactionList()
{
Mock <ITransactionData> data = new Mock <ITransactionData>();
data.Setup(m => m.ListTransactions()).Returns(Task.FromResult(oneTransaction));
data.Setup(m => m.RefreshTransactions(oneTransaction));
ITransactionBusiness sut = new TransactionBusiness(data.Object, commonFakes.Mapper);
List <Transaction> result = await sut.ListTransactions();
Assert.IsTrue(result is List <Transaction>, "result is not a 'Transaction list'");
}
public async Task ListTransactions_CallsListTransactionsMethodFromServicesLayer_WichReturnsAnEmptyList()
{
Mock <ITransactionData> data = new Mock <ITransactionData>();
data.Setup(m => m.ListTransactions()).Returns(Task.FromResult(emptyTransactions));
data.Setup(m => m.RefreshTransactions(emptyTransactions));
ITransactionBusiness sut = new TransactionBusiness(data.Object, commonFakes.Mapper);
List <Transaction> result = await sut.ListTransactions();
Assert.AreEqual(emptyTransactions.Count, result.Count);
}
public void Cancel(string email, int buyId)
{
var user = UserBusiness.GetValidUser(email);
var buy = BuyBusiness.Get(buyId);
if (buy == null || buy.UserId != user.Id || buy.ExpirationDate.HasValue)
{
throw new ArgumentException("Invalid purchase.");
}
if (buy.LastTransaction.TransactionStatus == TransactionStatus.Pending.Value)
{
if (string.IsNullOrEmpty(buy.LastTransaction.TransactionHash))
{
TransactionBusiness.Process(buy.LastTransaction, TransactionStatus.Cancel);
}
else
{
try
{
var transaction = Web3.Web3Business.CheckTransaction(buy.LastTransaction.TransactionHash);
throw new ArgumentException(transaction.BlockNumber.HasValue ? "The transaction is already minted." : "Pending transaction cannot be canceled.");
}
catch (DomainObjects.Web3.Web3Exception ex)
{
if (ex.Code == 404)
{
TransactionBusiness.Process(buy.LastTransaction, TransactionStatus.Cancel);
}
else
{
throw;
}
}
}
}
else if (buy.LastTransaction.TransactionStatus == TransactionStatus.Error.Value)
{
using (var transaction = new TransactionalDapperCommand())
{
var trans = TransactionBusiness.SetCanceled(user.Id);
transaction.Insert(trans);
var buyTrans = BuyTransactionBusiness.SetNew(buyId, trans.Id);
transaction.Insert(buyTrans);
transaction.Commit();
}
}
else
{
throw new ArgumentException("Invalid transaction status.");
}
}
public void SetTransaction()
{
try
{
TranscBusiness = new TransactionBusiness();
TranscBusiness.SetTransaction();
Assert.AreEqual(true, true);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private void HandleLostTransaction(Transaction transaction, int userId, int escrowResultId)
{
using (var trans = new TransactionalDapperCommand())
{
transaction.TransactionStatus = TransactionStatus.Lost.Value;
transaction.ProcessedDate = DateTime.UtcNow;
trans.Update(transaction);
var newTransaction = TransactionBusiness.SetNew(userId);
trans.Insert(newTransaction);
var escrowResultTrans = SetNew(escrowResultId, newTransaction.Id);
trans.Insert(escrowResultTrans);
trans.Commit();
}
}
public IHttpActionResult GetTransactions(Guid id)
{
if (ModelState.IsValid)
{
TransactionBusiness transactionsmod = new TransactionBusiness();
var transactions = transactionsmod.GetTransactions(id);
return(Ok(transactions));
}
else
{
return(BadRequest("Could not insert the transaction"));
}
}
public void GetTotalTransaction()
{
try
{
TranscBusiness = new TransactionBusiness();
TotalTransaction[] list = TranscBusiness.GetTotalTransaction();
Assert.IsNotNull(list);
Assert.IsTrue(list.Length > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void GetTransaction()
{
try
{
TranscBusiness = new TransactionBusiness();
List <ProductTransaction> list = TranscBusiness.GetTransaction();
Assert.IsNotNull(list);
Assert.IsTrue(list.Count > 0);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public IHttpActionResult UpdateTransaction(Guid id, Transaction transaction)
{
TransactionBusiness transactionsmod = new TransactionBusiness();
var result = transactionsmod.UpdateTransaction(id, transaction);
if (result == true)
{
return(Ok());
}
else
{
return(BadRequest("Could not Update the transaction"));
}
}
public async Task ListTransactions_CallsListTransactionsMethodFromServicesLayer_WichThrowsAnException()
{
Mock <ITransactionData> data = new Mock <ITransactionData>();
data.Setup(m => m.ListTransactions()).Throws(exception);
ITransactionBusiness sut = new TransactionBusiness(data.Object, commonFakes.Mapper);
try
{
await sut.ListTransactions();
Assert.IsTrue(false, "No exception thrown. Exception exception was expected.");
}
catch (Exception result)
{
Assert.AreSame(exception, result);
}
}
public void SetTransactionHash(string email, int buyId, string transactionHash)
{
var user = UserBusiness.GetValidUser(email);
var buy = BuyBusiness.Get(buyId);
if (buy == null || buy.UserId != user.Id || buy.ExpirationDate.HasValue)
{
throw new ArgumentException("Invalid purchase.");
}
if (buy.LastTransaction.TransactionStatus == TransactionStatus.Pending.Value && string.IsNullOrEmpty(buy.LastTransaction.TransactionHash))
{
TransactionBusiness.SetTransactionHash(buy.LastTransaction, transactionHash);
}
else if (buy.LastTransaction.TransactionStatus == TransactionStatus.Error.Value)
{
Create(user.Id, buyId, transactionHash);
}
else if (buy.LastTransaction.TransactionStatus == TransactionStatus.Pending.Value && TransactionBusiness.TransactionCanBeConsideredLost(buy.LastTransaction) &&
buy.LastTransaction.TransactionHash != transactionHash.ToLower().Trim())
{
try
{
var transaction = Web3.Web3Business.CheckTransaction(buy.LastTransaction.TransactionHash);
throw new ArgumentException(transaction.BlockNumber.HasValue ? "Before transaction was processed." : "Before transaction is still pending.");
}
catch (DomainObjects.Web3.Web3Exception ex)
{
if (ex.Code == 404)
{
HandleLostTransaction(buy.LastTransaction, user.Id, buyId, transactionHash);
}
else
{
throw;
}
}
}
else
{
throw new ArgumentException("Invalid transaction status.");
}
}
public async Task CheckTransactionsAsync()
{
var pendingTransactions = Data.ListPendingTransactions();
foreach (var pending in pendingTransactions)
{
try
{
var transaction = Web3.Web3Business.CheckTransaction(pending.Transaction.TransactionHash);
if (transaction.BlockNumber.HasValue)
{
if (transaction.Status.Value == 1)
{
TransactionBusiness.Process(pending.Transaction, TransactionStatus.Success);
}
else
{
TransactionBusiness.Process(pending.Transaction, TransactionStatus.Error);
await Email.SendErrorEmailAsync($"Error on escrow result transaction {pending.TransactionId}, with hash {pending.Transaction.TransactionHash}.");
}
}
}
catch (DomainObjects.Web3.Web3Exception ex)
{
if (ex.Code == 404 && TransactionBusiness.TransactionCanBeConsideredLost(pending.Transaction))
{
HandleLostTransaction(pending.Transaction, pending.Transaction.UserId, pending.EscrowResultId);
}
else
{
throw;
}
}
catch (Exception ex)
{
Logger.LogCritical(ex, $"Exception on check escrow result transaction {pending.TransactionId}");
}
}
}
public void GetSkuValue()
{
try
{
TranscBusiness = new TransactionBusiness();
List <ProductTransaction> transac = TranscBusiness.GetTransaction();
TotalTransaction[] list = TranscBusiness.GetSkuValue(transac[0].Sku);
if (list.Length > 0)
{
Assert.IsTrue(true, "Si existe la transacción");
}
else
{
Assert.Fail("No existe la transacción");
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private TransactionStatus CheckAndProcessTransaction(Transaction buyTransaction, int buyId)
{
TransactionStatus status = TransactionStatus.Pending;
try
{
var transaction = Web3.Web3Business.CheckTransaction(buyTransaction.TransactionHash, "Escrow(address,uint256)");
if (transaction.Status.HasValue)
{
if (transaction.Status.Value == 1)
{
if (transaction.EventData != null && transaction.EventData.Length == 2 &&
!string.IsNullOrEmpty(transaction.EventData[0]) && !string.IsNullOrEmpty(transaction.EventData[1]))
{
var wallet = WalletBusiness.GetByUser(buyTransaction.UserId);
if (transaction.EventData[0].ToLower().Trim() != wallet.Address)
{
status = TransactionStatus.Fraud;
}
else
{
var purchase = BuyBusiness.GetSimple(buyId);
var escrowedValue = Util.Util.ConvertBigNumber(transaction.EventData[1], 18);
if (purchase.Price > escrowedValue)
{
status = TransactionStatus.Fraud;
}
else
{
var transactions = ListByUserAndHash(buyTransaction.UserId, buyTransaction.TransactionHash);
if (transactions.Count > 1 && (transactions.Any(c => c.BuyId != buyId) ||
transactions.Any(c => c.Transaction.TransactionStatus != TransactionStatus.Pending.Value)))
{
status = TransactionStatus.Fraud;
}
else
{
status = TransactionStatus.Success;
using (var trans = new TransactionalDapperCommand())
{
purchase.ExpirationDate = DateTime.UtcNow.Date.AddDays(purchase.Days);
trans.Update(purchase);
buyTransaction.TransactionStatus = status.Value;
buyTransaction.ProcessedDate = DateTime.UtcNow;
trans.Update(buyTransaction);
trans.Commit();
}
}
}
}
}
else
{
status = TransactionStatus.Fraud;
}
}
else
{
status = TransactionStatus.Error;
}
if (status != TransactionStatus.Success)
{
TransactionBusiness.Process(buyTransaction, status);
}
}
}
catch (DomainObjects.Web3.Web3Exception ex)
{
if (ex.Code == 404 && TransactionBusiness.TransactionCanBeConsideredLost(buyTransaction))
{
HandleLostTransaction(buyTransaction, buyTransaction.UserId, buyId, null);
}
else
{
throw;
}
}
return(status);
}
public void Evaluate()
{
var purchases = BuyBusiness.ListPendingEscrowResult();
foreach (var purchase in purchases)
{
try
{
var history = PortfolioHistoryBusiness.ListHistory(purchase.PortfolioId);
if (history.Max(c => c.Date) < purchase.ExpirationDate.Value)
{
continue;
}
var projection = ProjectionBusiness.Get(purchase.ProjectionId);
var dailyEstimatedPercentage = Util.Util.ConvertMonthlyToDailyRate(projection.ProjectionValue);
var estimatedPercentage = Math.Pow(1.0 + dailyEstimatedPercentage, purchase.Days) - 1.0;
var startDate = purchase.ExpirationDate.Value.AddDays(-purchase.Days);
if (startDate < history.Min(c => c.Date))
{
startDate = history.Min(c => c.Date);
}
var historyOfPeriod = history.Where(c => c.Date >= startDate && c.Date <= purchase.ExpirationDate.Value);
var historyResult = PortfolioHistoryBusiness.GetHistoryResult(historyOfPeriod);
var performedPercentage = historyResult.Value / 100.0;
decimal buyerTokenAmount = 0, ownerTokenAmount = 0;
if (estimatedPercentage > performedPercentage)
{
buyerTokenAmount = purchase.Price;
}
else
{
ownerTokenAmount = purchase.Price;
}
using (var transaction = new TransactionalDapperCommand())
{
var escrowResult = new EscrowResult()
{
BuyId = purchase.Id,
CreationDate = DateTime.UtcNow,
BuyerTokenResult = buyerTokenAmount,
OwnerTokenResult = ownerTokenAmount
};
transaction.Insert(escrowResult);
var trans = TransactionBusiness.SetNew(purchase.UserId);
transaction.Insert(trans);
var escrowResultTrans = EscrowResultTransactionBusiness.SetNew(escrowResult.Id, trans.Id);
transaction.Insert(escrowResultTrans);
transaction.Commit();
}
}
catch (Exception ex)
{
Logger.LogCritical(ex, $"Error on evaluate purchase {purchase.Id}");
}
}
}
public Buy Create(string email, string address, int portfolioId, int days, int?goalOptionId = null, int?timeframe = null,
int?risk = null, double?targetAmount = null, double?startingAmount = null, double?monthlyContribution = null)
{
if (string.IsNullOrWhiteSpace(address))
{
throw new ArgumentException("Address must be filled.");
}
if (days <= 0)
{
throw new ArgumentException("Invalid purchase days.");
}
var user = UserBusiness.GetValidUser(email, address);
if (user?.ConfirmationDate == null)
{
throw new ArgumentException("User didn't confirmed e-mail.");
}
var portfolio = PortfolioBusiness.GetWithDetails(portfolioId);
if (portfolio == null || !portfolio.Detail.Enabled || !portfolio.Advisor.Detail.Enabled)
{
throw new ArgumentException("Invalid portfolio.");
}
if (portfolio.Advisor.UserId == user.Id)
{
throw new ArgumentException("User is the advisor owner.");
}
var purchases = ListPurchases(user.Id);
if (purchases.Any(c => c.PortfolioId == portfolio.Id))
{
throw new ArgumentException("Portfolio already bought.");
}
Buy buy;
using (var transaction = new TransactionalDapperCommand())
{
Goal goal = null;
if (portfolio.Advisor.Type == AdvisorType.Robo.Value)
{
if (!goalOptionId.HasValue || !timeframe.HasValue || !risk.HasValue || !startingAmount.HasValue || !monthlyContribution.HasValue)
{
throw new ArgumentException("Invalid goal data.");
}
goal = GoalBusiness.SetNew(user.Id, goalOptionId.Value, timeframe.Value, risk.Value, targetAmount, startingAmount.Value, monthlyContribution.Value);
transaction.Insert(goal);
}
var price = Math.Floor(portfolio.Detail.Price * (decimal)(1000000.0 * days) / (decimal)30.0) / (decimal)1000000.0;
buy = SetNew(days, price, portfolio.Id, portfolio.ProjectionId.Value, portfolio.Detail.Id, user.Id, goal?.Id);
transaction.Insert(buy);
var trans = TransactionBusiness.SetNew(user.Id);
transaction.Insert(trans);
var buyTrans = BuyTransactionBusiness.SetNew(buy.Id, trans.Id);
transaction.Insert(buyTrans);
buy.Goal = goal;
buy.Portfolio = portfolio;
buy.PortfolioDetail = portfolio.Detail;
transaction.Commit();
}
return(buy);
}
public Stanje()
{
this.transactionBusiness = new TransactionBusiness();
this.userBusiness = new UserBusiness();
this.balanceBusiness = new BalanceBusiness();
}
