public ActionResult GetPortfolio(string username)
{
Dictionary <int, List <Symbol> > portfolios = new Dictionary <int, List <Symbol> >();
try
{
int userid = new UserBusiness().FindUserId(username);
portfolios = new PortfolioBusiness().GetPortfolio(userid);
var jsonObject = new
{
code = 1,
data = portfolios
};
return(Json(jsonObject));
}
catch (Exception e)
{
var jsonObject = new
{
code = 0,
data = portfolios
};
return(Json(jsonObject));
}
}
public ActionResult SavePortfolio(string username, string symbolId)
{
int userid = new UserBusiness().FindUserId(username);
int res = new PortfolioBusiness().SavePortfolio(userid, symbolId);
if (userid > 0)
{
var jsonObject = new
{
code = res
};
//return Json(historics, JsonRequestBehavior.AllowGet);
return(Json(jsonObject));
}
else
{
var jsonObject = new
{
code = 0
};
//return Json(historics, JsonRequestBehavior.AllowGet);
return(Json(jsonObject));
}
}
public CheckTransaction CheckTransactionHash(string email, int buyId)
{
var user = UserBusiness.GetValidUser(email);
var buy = BuyBusiness.Get(buyId);
if (buy == null || buy.UserId != user.Id || buy.LastTransaction == null)
{
throw new ArgumentException("Invalid purchase.");
}
var status = buy.LastTransaction.TransactionStatus;
if (status == TransactionStatus.Success.Value || status == TransactionStatus.Pending.Value)
{
if (status == TransactionStatus.Pending.Value)
{
status = CheckAndProcessTransaction(buy.LastTransaction, buy.Id).Value;
}
if (status == TransactionStatus.Success.Value)
{
var portfolio = PortfolioBusiness.GetSimple(buy.PortfolioId);
return(new CheckTransaction()
{
Status = status,
Distribution = DistributionBusiness.ListByProjection(portfolio.ProjectionId.Value)
});
}
}
return(new CheckTransaction()
{
Status = status
});
}
public Model.Advisor ListDetails(string email, int advisorId)
{
User user = null;
if (!string.IsNullOrEmpty(email))
{
user = UserBusiness.GetValidUser(email);
}
var advisor = GetWithDetail(advisorId);
var owned = (user != null && user.Id == advisor.UserId);
if (advisor.Type == AdvisorType.Robo.Value || (!advisor.Detail.Enabled && !owned))
{
throw new ArgumentException("Invalid advisor.");
}
Task <List <Buy> > purchases = null;
if (user != null)
{
purchases = Task.Factory.StartNew(() => BuyBusiness.ListUserAdvisorPurchases(user.Id, advisorId));
}
var advisorQty = Task.Factory.StartNew(() => BuyBusiness.ListAdvisorsPurchases(new int[] { advisorId }));
var portfolios = PortfolioBusiness.ListWithHistory(advisorId, !owned);
var portfolioQty = Task.Factory.StartNew(() => BuyBusiness.ListPortfoliosPurchases(portfolios.Select(x => x.Id)));
if (user != null)
{
Task.WaitAll(purchases, advisorQty, portfolioQty);
}
else
{
Task.WaitAll(advisorQty, portfolioQty);
}
return(new Model.Advisor()
{
Id = advisor.Id,
Name = advisor.Detail.Name,
Description = advisor.Detail.Description,
Owned = owned,
Enabled = advisor.Detail.Enabled,
PurchaseQuantity = advisorQty.Result.ContainsKey(advisor.Id) ? advisorQty.Result[advisor.Id] : 0,
Portfolios = portfolios.Select(c => PortfolioBusiness.FillPortfolioModel(c, advisor, user, purchases?.Result, portfolioQty.Result)).
OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent).ToList()
});
}
public KeyValuePair <int, IEnumerable <Model.Portfolio> > ListRoboAdvisors(string email, int goalOptionId, int risk)
{
var user = UserBusiness.GetValidUser(email);
var purchases = Task.Factory.StartNew(() => BuyBusiness.ListPurchases(user.Id));
var goalOption = GoalOptionsBusiness.Get(goalOptionId);
var riskType = RiskType.Get(risk, goalOption.Risk);
var riskPriority = RiskType.GetRiskPriority(riskType);
var advisors = Data.ListRobosAvailable();
var portfolios = Task.Factory.StartNew(() => PortfolioBusiness.List(advisors.Select(c => c.Id)));
Task.WaitAll(portfolios);
var portfolioQty = Task.Factory.StartNew(() => BuyBusiness.ListPortfoliosPurchases(portfolios.Result.SelectMany(c => c.Value.Select(x => x.Id))));
List <Task <List <PortfolioHistory> > > histories = new List <Task <List <PortfolioHistory> > >();
foreach (DomainObjects.Portfolio.Portfolio portfolio in portfolios.Result.SelectMany(c => c.Value))
{
histories.Add(Task.Factory.StartNew(() => PortfolioHistoryBusiness.ListHistory(portfolio.Id)));
}
Task.WaitAll(purchases, portfolioQty);
Task.WaitAll(histories.ToArray());
List <Model.Portfolio> portfolioWithSameRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithLittleLowerRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithLittleHigherRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithLowerRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithHigherRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithVeryLowerRisk = new List <Model.Portfolio>();
List <Model.Portfolio> portfolioWithVeryHigherRisk = new List <Model.Portfolio>();
foreach (KeyValuePair <int, List <DomainObjects.Portfolio.Portfolio> > advisorPortfolios in portfolios.Result)
{
var advisor = advisors.Single(c => c.Id == advisorPortfolios.Key);
advisorPortfolios.Value.ForEach(c => c.PortfolioHistory = histories.SelectMany(x => x.Result.Where(g => g.PortfolioId == c.Id)).ToList());
foreach (var r in riskPriority)
{
var riskFound = advisorPortfolios.Value.SingleOrDefault(c => c.Projection.RiskType == r);
if (riskFound != null)
{
var port = PortfolioBusiness.FillPortfolioModel(riskFound, advisor, user, purchases.Result, portfolioQty.Result);
var difference = riskFound.Projection.RiskType.Value - riskType.Value;
if (difference == 0)
{
portfolioWithSameRisk.Add(port);
}
else if (difference == 1)
{
portfolioWithLittleHigherRisk.Add(port);
}
else if (difference == -1)
{
portfolioWithLittleLowerRisk.Add(port);
}
else if (difference == 2)
{
portfolioWithHigherRisk.Add(port);
}
else if (difference == -2)
{
portfolioWithLowerRisk.Add(port);
}
else if (difference > 2)
{
portfolioWithVeryHigherRisk.Add(port);
}
else
{
portfolioWithVeryLowerRisk.Add(port);
}
break;
}
}
}
var result = portfolioWithSameRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent).ToList();
result.AddRange(portfolioWithLittleLowerRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
result.AddRange(portfolioWithLittleHigherRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
result.AddRange(portfolioWithLowerRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
result.AddRange(portfolioWithHigherRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
result.AddRange(portfolioWithVeryLowerRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
result.AddRange(portfolioWithVeryHigherRisk.OrderByDescending(c => c.PurchaseQuantity).ThenByDescending(c => c.ProjectionPercent));
return(new KeyValuePair <int, IEnumerable <Model.Portfolio> >(riskType.Value, result));
}
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 Model.Portfolio GetPortfolio(string email, int portfolioId)
{
return(PortfolioBusiness.Get(email, portfolioId));
}
public void DisablePortfolio(string email, int portfolioId)
{
PortfolioBusiness.Disable(email, portfolioId);
}
public List <Model.Portfolio> ListPurchasedPortfolios(string email)
{
return(PortfolioBusiness.ListPurchased(email));
}
public Portfolio UpdatePortfolioAndDistribution(string email, int portfolioId, decimal price, string name, string description, Dictionary <int, double> distribution)
{
return(PortfolioBusiness.UpdateWithDistribution(email, portfolioId, price, name, description, distribution));
}
public Portfolio UpdatePortfolio(string email, int portfolioId, decimal price, string name, string description)
{
return(PortfolioBusiness.Update(email, portfolioId, price, name, description));
}
public Portfolio CreatePortfolio(string email, int advisorId, decimal price, string name, string description, double projection,
double?optimisticProjection, double?pessimisticProjection, Dictionary <int, double> distribution)
{
return(PortfolioBusiness.Create(email, advisorId, price, name, description, projection, optimisticProjection, pessimisticProjection, distribution));
}
public void UpdatePortfoliosHistory()
{
PortfolioBusiness.UpdateAllPortfoliosHistory();
}
