protected async Task <IActionResult> RegisterAsync(RegisterAdvisorRequest beAdvisorRequest)
{
if (beAdvisorRequest == null)
{
return(BadRequest());
}
if (GetUser() == null && !IsValidRecaptcha(beAdvisorRequest.Captcha))
{
return(BadRequest(new { error = "Invalid Captcha." }));
}
LoginResponse response;
if (beAdvisorRequest.ChangedPicture && RequestHasFile())
{
var fileExtension = GetValidPictureExtension();
using (var stream = Request.Form.Files[0].OpenReadStream())
response = await AdvisorBusiness.CreateAsync(beAdvisorRequest.Email, beAdvisorRequest.Password, beAdvisorRequest.Name, beAdvisorRequest.Description,
beAdvisorRequest.ReferralCode, beAdvisorRequest.ChangedPicture, stream, fileExtension);
}
else
{
response = await AdvisorBusiness.CreateAsync(beAdvisorRequest.Email, beAdvisorRequest.Password, beAdvisorRequest.Name, beAdvisorRequest.Description,
beAdvisorRequest.ReferralCode, beAdvisorRequest.ChangedPicture, null, null);
}
return(Ok(new { logged = !response.PendingConfirmation, jwt = GenerateToken(response.Email.ToLower().Trim()), data = response }));
}
protected async Task <IActionResult> EditAdvisorAsync(int id, AdvisorRequest advisorRequest)
{
if (advisorRequest.ChangedPicture && RequestHasFile())
{
var fileExtension = GetValidPictureExtension();
using (var stream = Request.Form.Files[0].OpenReadStream())
return(Ok(await AdvisorBusiness.EditAdvisorAsync(id, advisorRequest.Name, advisorRequest.Description, true, stream, fileExtension)));
}
else
{
return(Ok(await AdvisorBusiness.EditAdvisorAsync(id, advisorRequest.Name, advisorRequest.Description, advisorRequest.ChangedPicture, null, null)));
}
}
public SearchResponse Search(string searchTerm)
{
if (string.IsNullOrWhiteSpace(searchTerm) || searchTerm.Trim().Length < 2)
{
return(new SearchResponse());
}
IEnumerable <DomainObjects.Advisor.Advisor> advisors = null;
IEnumerable <DomainObjects.Asset.Asset> assets = null;
Parallel.Invoke(() => advisors = AdvisorBusiness.ListByName(searchTerm), () => assets = AssetBusiness.ListByNameOrCode(searchTerm));
if (!assets.Any() && !advisors.Any())
{
return(new SearchResponse());
}
var response = new SearchResponse();
foreach (DomainObjects.Advisor.Advisor advisor in advisors)
{
response.Advisors.Add(new SearchResponse.AdvisorResult()
{
Id = advisor.Id,
Description = advisor.Description,
Name = advisor.Name,
UrlGuid = advisor.UrlGuid.ToString()
});
}
foreach (DomainObjects.Asset.Asset asset in assets)
{
response.Assets.Add(new SearchResponse.AssetResult()
{
Id = asset.Id,
Code = asset.Code,
Name = asset.Name,
MarketCap = asset.MarketCap,
CirculatingSupply = asset.CirculatingSupply
});
}
response.Advisors = response.Advisors.OrderBy(c => c.Name).ToList();
response.Assets = response.Assets.OrderByDescending(c => c.MarketCap).ThenBy(c => c.Name).ToList();
return(response);
}
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);
}
public Login Login(string address, string emailOrUsername, string password)
{
BaseEmailOrUsernameValidation(emailOrUsername);
BasePasswordValidation(password);
address = WalletBusiness.GetAddressFormatted(address);
var user = Data.GetByEmailOrUsername(emailOrUsername);
if (user == null)
{
throw new ArgumentException("Email or username is invalid.");
}
else if (user.Wallet.Address?.ToUpper() != address?.ToUpper())
{
throw new ArgumentException("Wallet is invalid.");
}
else if (user.Password != Security.Hash(password))
{
throw new ArgumentException("Password is invalid.");
}
var result = new Model.Login()
{
Address = user.Wallet.Address,
Email = user.Email,
Username = user.Username,
PendingConfirmation = !user.ConfirmationDate.HasValue
};
if (!result.PendingConfirmation)
{
MemoryCache.Set <User>(user.Email, user);
var purchases = Task.Factory.StartNew(() => BuyBusiness.ListPurchases(user.Id));
var advisor = Task.Factory.StartNew(() => AdvisorBusiness.SimpleGetByOwner(user.Id));
Task.WaitAll(purchases, advisor);
result.HumanAdvisorId = advisor.Result?.Id;
result.HasInvestment = purchases.Result.Count > 0;
}
return(result);
}
public KeyValuePair <int, IEnumerable <Model.Portfolio> > ListRoboAdvisors(string email, int goalOptionId, int risk)
{
return(AdvisorBusiness.ListRoboAdvisors(email, goalOptionId, risk));
}
public Model.Advisor ListAdvisorDetails(string email, int advisorId)
{
return(AdvisorBusiness.ListDetails(email, advisorId));
}
public DomainObjects.Advisor.Advisor CreateAdvisor(string email, string name, string description)
{
return(AdvisorBusiness.Create(email, name, description));
}
protected virtual IActionResult ListAdvisorsFollowedByUser(int id)
{
return(Ok(AdvisorBusiness.ListAdvisorsFollowedByUser(id)));
}
public DashboardResponse GetDashboardData()
{
var cutDayForActivity = Data.GetDateTimeNow().AddDays(-7);
var advisors = AdvisorBusiness.ListAllAdvisors();
var users = Task.Factory.StartNew(() => UserBusiness.ListAllUsersData());
var advisorFollowers = Task.Factory.StartNew(() => FollowAdvisorBusiness.ListFollowers(advisors.Select(c => c.Id).Distinct(), false));
var assetFollowers = Task.Factory.StartNew(() => FollowAssetBusiness.ListFollowers());
var activities = Task.Factory.StartNew(() => Data.FilterActivity(cutDayForActivity, ActionType.NewAucVerification, ActionType.NewLogin));
Task.WaitAll(users, advisorFollowers, assetFollowers, activities);
var adminsId = users.Result.Where(c => Admins?.Any(a => a == c.Email) == true).Select(c => c.Id).ToHashSet();
var consideredUsers = users.Result.Where(c => !adminsId.Contains(c.Id) && (!c.ReferredId.HasValue || !adminsId.Contains(c.ReferredId.Value))).ToList();
var consideredAdvisors = advisors.Where(c => !adminsId.Contains(c.Id) && (!c.ReferredId.HasValue || !adminsId.Contains(c.ReferredId.Value))).ToList();
var consideredAdvisorFollowers = advisorFollowers.Result.Where(c => consideredUsers.Any(u => u.Id == c.UserId)).ToList();
var consideredAssetFollowers = assetFollowers.Result.Where(c => consideredUsers.Any(u => u.Id == c.UserId)).ToList();
var consideredActivities = activities.Result.Where(c => consideredUsers.Any(u => u.Id == c.UserId)).ToList();
var result = new DashboardResponse();
result.TotalUsersConfirmed = consideredUsers.Count(c => c.Wallets.Any());
result.TotalUsersConfirmedFromReferral = consideredUsers.Count(c => c.ReferredId.HasValue && c.Wallets.Any());
result.TotalUsersStartedRegistration = consideredUsers.Count(c => !consideredAdvisors.Any(a => a.Id == c.Id) && !c.Wallets.Any());
result.TotalUsersStartedRegistrationFromReferral = consideredUsers.Count(c => c.ReferredId.HasValue && !consideredAdvisors.Any(a => a.Id == c.Id) && !c.Wallets.Any());
result.TotalAdvisors = consideredAdvisors.Count;
result.TotalActiveUsers = consideredActivities.Any() ? consideredActivities.Select(c => c.UserId).Distinct().Count(c => !consideredAdvisors.Any(a => a.Id == c) && consideredUsers.Any(u => u.Id == c && u.Wallets.Any())) : 0;
result.TotalWalletsInProgress = consideredUsers.Count(c => c.ReferralStatusType == ReferralStatusType.InProgress);
result.TotalFollowing = consideredAdvisorFollowers.Count + consideredAssetFollowers.Count;
result.TotalAdvisorsFollowed = consideredAdvisorFollowers.Any() ? consideredAdvisorFollowers.Select(c => c.AdvisorId).Distinct().Count() : 0;
result.TotalUsersFollowing = consideredAdvisorFollowers.Any() || consideredAssetFollowers.Any() ?
consideredAdvisorFollowers.Select(c => c.UserId).Concat(consideredAssetFollowers.Select(c => c.UserId)).Distinct().Count() : 0;
var confirmedUsers = new Dictionary <int, DateTime>();
foreach (var user in consideredUsers.Where(c => c.Wallets.Any()))
{
if (!consideredAdvisors.Any(c => c.Id == user.Id))
{
confirmedUsers[user.Id] = user.Wallets.OrderBy(c => c.CreationDate).First().CreationDate;
}
var currentWallet = user.Wallets.OrderByDescending(c => c.CreationDate).First();
result.TotalWalletsWithAuc += currentWallet.AUCBalance > 0 ? 1 : 0;
result.AucHolded += Convert.ToDouble(currentWallet.AUCBalance ?? 0);
result.AucHoldedInProgress += user.ReferralStatusType == ReferralStatusType.InProgress ? Convert.ToDouble(currentWallet.AUCBalance ?? 0) : 0;
}
result.AucRatioPerConfirmedUser = result.TotalUsersConfirmed > 0 ? result.AucHolded / result.TotalUsersConfirmed : 0;
result.AucRatioPerUserInProgress = result.TotalWalletsInProgress > 0 ? result.AucHoldedInProgress / result.TotalWalletsInProgress : 0;
var usersConfirmedData = !confirmedUsers.Any() ? null : confirmedUsers.GroupBy(c => c.Value.ToString("yyyy-MM-dd"))
.Select(g => new DashboardResponse.RegistrationData()
{
Date = DateTime.Parse(g.Key), Value = g.Count()
}).OrderBy(c => c.Date);
var advisorsData = !consideredAdvisors.Any() ? null : consideredAdvisors.GroupBy(c => c.BecameAdvisorDate.ToString("yyyy-MM-dd"))
.Select(g => new DashboardResponse.RegistrationData()
{
Date = DateTime.Parse(g.Key), Value = g.Count()
}).OrderBy(c => c.Date);
var usersStartedRegistrationData = !consideredUsers.Any(c => !consideredAdvisors.Any(a => a.Id == c.Id) && !c.Wallets.Any()) ? null :
consideredUsers.Where(c => !consideredAdvisors.Any(a => a.Id == c.Id) && !c.Wallets.Any()).GroupBy(c => c.CreationDate.ToString("yyyy-MM-dd"))
.Select(g => new DashboardResponse.RegistrationData()
{
Date = DateTime.Parse(g.Key), Value = g.Count()
}).OrderBy(c => c.Date);
var minDate = GetMinDate(usersConfirmedData, advisorsData, usersStartedRegistrationData);
result.UsersConfirmed = GetRegistrationData(usersConfirmedData, minDate);
result.Advisors = GetRegistrationData(advisorsData, minDate);
result.UsersStartedRegistration = GetRegistrationData(usersStartedRegistrationData, minDate);
result.UsersConfirmedLastSitutation = GetFlagData(result.UsersConfirmed);
result.AdvisorsLastSitutation = GetFlagData(result.Advisors);
result.UsersStartedRegistrationLastSitutation = GetFlagData(result.UsersStartedRegistration);
result.UsersConfirmed.Add(new DashboardResponse.RegistrationData()
{
Date = Data.GetDateTimeNow().Date.AddDays(1), Value = result.UsersConfirmed.LastOrDefault()?.Value ?? 0
});
result.Advisors.Add(new DashboardResponse.RegistrationData()
{
Date = Data.GetDateTimeNow().Date.AddDays(1), Value = result.Advisors.LastOrDefault()?.Value ?? 0
});
result.UsersStartedRegistration.Add(new DashboardResponse.RegistrationData()
{
Date = Data.GetDateTimeNow().Date.AddDays(1), Value = result.UsersStartedRegistration.LastOrDefault()?.Value ?? 0
});
result.Following.Add(new DashboardResponse.DistributionData()
{
Name = "Asset", Amount = consideredAssetFollowers.Count()
});
result.Following.Add(new DashboardResponse.DistributionData()
{
Name = "Expert", Amount = consideredAdvisorFollowers.Count()
});
var usersWithReferral = consideredUsers.Where(c => c.ReferralStatus.HasValue);
result.ReferralStatus = !usersWithReferral.Any() ? new List <DashboardResponse.DistributionData>() : usersWithReferral.GroupBy(c => c.ReferralStatus.Value)
.Select(g => new DashboardResponse.DistributionData()
{
Name = ReferralStatusType.Get(g.Key).GetDescription(), Amount = g.Count()
}).ToList();
var groupedFollowers = !consideredAdvisorFollowers.Any() ? null : consideredAdvisorFollowers.GroupBy(c => c.AdvisorId).Select(g => new { Id = g.Key, Value = g.Count() }).OrderByDescending(c => c.Value);
if (groupedFollowers?.Any() == true)
{
groupedFollowers = groupedFollowers.Take(groupedFollowers.Count() > 10 ? 10 : groupedFollowers.Count()).OrderByDescending(c => c.Value);
var consideredFollowers = consideredAdvisorFollowers.Where(c => groupedFollowers.Any(a => a.Id == c.AdvisorId));
result.AdvisorFollowers = groupedFollowers.Select(c => new DashboardResponse.AdvisorData()
{
Id = c.Id,
Name = consideredAdvisors.First(a => a.Id == c.Id).Name,
UrlGuid = consideredAdvisors.First(a => a.Id == c.Id).UrlGuid.ToString(),
Total = c.Value,
SubValue1 = consideredFollowers.Count(a => a.CreationDate >= cutDayForActivity && a.AdvisorId == c.Id)
}).ToList();
}
var groupedReferred = !usersWithReferral.Any() ? null : usersWithReferral.GroupBy(c => c.ReferredId.Value).Select(g => new { Id = g.Key, Value = g.Count() }).OrderByDescending(c => c.Value);
if (groupedReferred?.Any() == true)
{
groupedReferred = groupedReferred.Take(groupedReferred.Count() > 10 ? 10 : groupedReferred.Count()).OrderByDescending(c => c.Value);
var consideredReferred = consideredUsers.Where(c => c.ReferralStatus.HasValue).Where(c => groupedReferred.Any(a => a.Id == c.ReferredId));
result.AdvisorReferral = groupedReferred.Select(c => new DashboardResponse.AdvisorData()
{
Id = c.Id,
Name = consideredAdvisors.Any(a => a.Id == c.Id) ? consideredAdvisors.First(a => a.Id == c.Id).Name :
consideredUsers.Any(u => u.Id == c.Id) ? consideredUsers.First(u => u.Id == c.Id).Email : "(ADMIN) " + users.Result.First(u => u.Id == c.Id).Email,
UrlGuid = consideredAdvisors.Any(a => a.Id == c.Id) ? consideredAdvisors.First(a => a.Id == c.Id).UrlGuid.ToString() : null,
Total = c.Value,
SubValue1 = consideredReferred.Count(a => a.ReferredId == c.Id && a.ReferralStatusType == ReferralStatusType.InProgress),
SubValue2 = consideredReferred.Count(a => a.ReferredId == c.Id && a.ReferralStatusType == ReferralStatusType.Interrupted),
SubValue3 = consideredReferred.Count(a => a.ReferredId == c.Id && (a.ReferralStatusType == ReferralStatusType.Finished || a.ReferralStatusType == ReferralStatusType.Paid))
}).ToList();
}
return(result);
}
protected IActionResult ListAdvisors()
{
return(Ok(AdvisorBusiness.ListAdvisorsData()));
}
protected IActionResult ListAdvisorsRanking(int?year, int?month)
{
return(Ok(AdvisorBusiness.ListAdvisorsMonthlyRanking(year, month)));
}
protected IActionResult GetLoggedAdvisor()
{
return(Ok(AdvisorBusiness.GetLoggedAdvisor()));
}
protected IActionResult GetAdvisorPeformance(int id)
{
return(Ok(AdvisorBusiness.GetAdvisorPeformance(id)));
}
protected IActionResult GetAdvisorDetails(int id)
{
return(Ok(AdvisorBusiness.GetAdvisorData(id)));
}
