private void HandleLostTransaction(Transaction transaction, int userId, int buyId, string transactionHash)
{
using (var trans = new TransactionalDapperCommand())
{
transaction.TransactionStatus = TransactionStatus.Lost.Value;
transaction.ProcessedDate = DateTime.UtcNow;
trans.Update(transaction);
InternalCreate(trans, userId, buyId, transactionHash);
trans.Commit();
}
}
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();
}
}
internal Projection Create(DomainObjects.Portfolio.Portfolio portfolio, double projectionValue, RiskType risk,
double? optimisticProjection, double? pessimisticProjection, Dictionary<int, double> distribution)
{
var projection = SetNew(portfolio.Id, projectionValue, risk, optimisticProjection, pessimisticProjection);
using (var transaction = new TransactionalDapperCommand())
{
transaction.Insert(projection);
var distributions = DistributionBusiness.SetNew(projection.Id, distribution);
foreach (Distribution dist in distributions)
transaction.Insert(dist);
portfolio.ProjectionId = projection.Id;
transaction.Update(portfolio);
projection.Distribution = distributions;
transaction.Commit();
}
return projection;
}
public DomainObjects.Portfolio.Portfolio UpdateWithDistribution(string email, int portfolioId, decimal price, string name,
string description, Dictionary <int, double> distribution)
{
var user = UserBusiness.GetValidUser(email);
var portfolio = GetValidByOwner(user.Id, portfolioId);
if (portfolio == null)
{
throw new ArgumentException("Invalid portfolio.");
}
var projection = ProjectionBusiness.Get(portfolio.ProjectionId.Value);
if (projection == null)
{
throw new ArgumentException("Invalid projection.");
}
var risk = PortfolioBusiness.GetRisk(projection.ProjectionValue, distribution);
using (var transaction = new TransactionalDapperCommand())
{
var portfolioDetail = PortfolioDetailBusiness.SetNew(portfolioId, price, name, description, true);
transaction.Insert(portfolioDetail);
var newProjection = ProjectionBusiness.SetNew(portfolio.Id, projection.ProjectionValue, risk, projection.OptimisticProjectionValue, projection.PessimisticProjectionValue);
transaction.Insert(newProjection);
var distributions = DistributionBusiness.SetNew(newProjection.Id, distribution);
foreach (Distribution dist in distributions)
{
transaction.Insert(dist);
}
portfolio.ProjectionId = newProjection.Id;
transaction.Update(portfolio);
newProjection.Distribution = distributions;
portfolio.Detail = portfolioDetail;
portfolio.Projection = newProjection;
transaction.Commit();
}
return(portfolio);
}
public DomainObjects.Portfolio.Portfolio Create(string email, int advisorId, decimal price, string name, string description,
double projectionValue, double?optimisticProjection, double?pessimisticProjection, Dictionary <int, double> distribution)
{
var advisor = AdvisorBusiness.GetWithOwner(advisorId, email);
if (advisor == null)
{
throw new ArgumentException("Invalid advisor.");
}
var risk = GetRisk(projectionValue, distribution);
var advisorDetail = AdvisorDetailBusiness.GetForAutoEnabled(advisorId);
var portfolio = new DomainObjects.Portfolio.Portfolio();
portfolio.AdvisorId = advisorId;
portfolio.CreationDate = DateTime.UtcNow;
using (var transaction = new TransactionalDapperCommand())
{
transaction.Insert(portfolio);
var detail = PortfolioDetailBusiness.SetNew(portfolio.Id, price, name, description, true);
transaction.Insert(detail);
var projection = ProjectionBusiness.SetNew(portfolio.Id, projectionValue, risk, optimisticProjection, pessimisticProjection);
transaction.Insert(projection);
var distributions = DistributionBusiness.SetNew(projection.Id, distribution);
foreach (Distribution dist in distributions)
{
transaction.Insert(dist);
}
portfolio.ProjectionId = projection.Id;
transaction.Update(portfolio);
if (advisorDetail != null)
{
advisorDetail = AdvisorDetailBusiness.SetNew(advisorId, advisorDetail.Name, advisorDetail.Description, true);
transaction.Insert(advisorDetail);
}
projection.Distribution = distributions;
portfolio.Projection = projection;
portfolio.Detail = detail;
transaction.Commit();
}
return(portfolio);
}
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);
}
