public IActionResult GetBrokerInitData(Guid brokerTradeServerId)
{
var errors = brokerValidator.ValidateGetBrokerInitData(CurrentUser, brokerTradeServerId);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
var requests = managerService.GetCreateAccountRequests(brokerTradeServerId);
if (!requests.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(requests.Errors)));
}
var investments = trustManagementService.GetBrokerInvestmentsInitData(brokerTradeServerId);
if (!investments.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(investments.Errors)));
}
var data = new BrokerInitData
{
NewManagerRequest = requests.Data,
Investments = investments.Data
};
return(Ok(data));
}
public async Task <IActionResult> Authorize([FromBody] LoginViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var user = await userManager.FindByNameAsync(model.Email);
if (user == null)
{
return(BadRequest(ErrorResult.GetResult($"Wrong email/password")));
}
if (await userManager.CheckPasswordAsync(user, model.Password))
{
if (!await userManager.IsEmailConfirmedAsync(user))
{
return(BadRequest(ErrorResult.GetResult("Email does not confirmed")));
}
if (!user.IsEnabled)
{
return(BadRequest(ErrorResult.GetResult("User is disabled")));
}
var token = JwtManager.GenerateToken(user);
return(Ok(token.Value));
}
return(BadRequest(ErrorResult.GetResult("Wrong email/password")));
}
public IActionResult GetInvestmentProgramRequests([FromBody] InvestmentProgramRequestsFilter filter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var errors = investorValidator.ValidateInvestor(CurrentUser);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
var requests = trustManagementService.GetInvestmentProgramRequests(filter, CurrentUser.Id);
if (!requests.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(requests)));
}
return(Ok(new InvestmentProgramRequests
{
Requests = requests.Data.Item1,
Total = requests.Data.Item2
}));
}
public IActionResult RegisterParticipant([FromBody] NewParticipant model)
{
logger.LogInformation($"#RegisterParticipant. {model?.Email}, {model?.Name}, {model?.EthAddress}, {model?.Avatar}");
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var state = tournamentService.CheckNewParticipant(model);
if (!state.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(state)));
}
var res = tournamentService.RegisterParticipant(model);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
logger.LogInformation($"#RegisterParticipant. {model?.Email}: OK");
return(Ok());
}
public IActionResult NewInvestmentRequest([FromBody] NewInvestmentRequest request)
{
request.UserId = CurrentUser.Id;
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var errors = managerValidator.ValidateNewInvestmentRequest(CurrentUser, request);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
var result = managerService.CreateNewInvestmentRequest(request);
if (!result.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(result)));
}
return(Ok(result.Data));
}
public async Task <IActionResult> RegisterInvestor([FromBody] RegisterInvestorViewModel model)
{
logger.LogInformation($"Register investor: {model?.Email}");
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var address = ethService.GenerateAddress();
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
IsEnabled = true,
Type = UserType.Investor,
Profile = new Profiles(),
Wallets = new List <Wallets> {
new Wallets {
Currency = Currency.GVT
}
},
InvestorAccount = new InvestorAccounts(),
BlockchainAddresses = new List <BlockchainAddresses>
{
new BlockchainAddresses
{
Address = address.PublicAddress,
Currency = Currency.GVT,
IsDefault = true
}
}
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(ErrorResult.GetResult(result)));
}
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
if (Constants.IsDevelopment)
{
await userManager.ConfirmEmailAsync(user, code);
return(Ok());
}
else
{
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, HttpContext.Request.Scheme);
var text = $"Confirmation url: {callbackUrl}";
emailSender.SendEmailAsync(model.Email, "Registration", text, text);
return(Ok());
}
}
public IActionResult UpdateAuthToken()
{
if (CurrentUser.IsEnabled && CurrentUser.EmailConfirmed)
{
var token = JwtManager.GenerateToken(CurrentUser);
return(Ok(token.Value));
}
return(BadRequest(ErrorResult.GetResult(ValidationMessages.AccessDenied)));
}
public IActionResult UpdateProfile([FromBody] UpdateProfileViewModel model)
{
var res = userService.UpdateUserProfile(CurrentUser.Id, model);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok());
}
public IActionResult ProfileFull()
{
var user = userService.GetUserProfileFull(CurrentUser.Id);
if (!user.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(user)));
}
return(Ok(user.Data));
}
public IActionResult ProfileShort(Guid userId)
{
var user = userService.GetUserPublicProfile(userId);
if (!user.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(user)));
}
return(Ok(user.Data));
}
public IActionResult GetParticipantsSummary()
{
var res = tournamentService.GetParticipantsSummary();
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok(res.Data));
}
public IActionResult GetUserWallets()
{
var wallets = walletService.GetUserWallets(CurrentUser.Id);
if (!wallets.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(wallets)));
}
return(Ok(wallets.Data));
}
public IActionResult UploadFile(IFormFile uploadedFile)
{
var result = fileService.Upload(uploadedFile, CurrentUser?.Id);
if (!result.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(result)));
}
return(Ok(result.Data));
}
public IActionResult InvestorDashboard()
{
var data = trustManagementService.GetInvestorDashboard(CurrentUser.Id, CurrentUser?.Id, CurrentUser?.Type);
if (!data.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(data)));
}
return(Ok(data.Data));
}
public IActionResult GetInvestmentProgramsWithTx(string mask)
{
var data = walletService.GetInvestmentProgramsWithTx(mask, CurrentUser.Id);
if (!data.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(data)));
}
return(Ok(data.Data));
}
public IActionResult GetWalletAddress()
{
var address = walletService.GetUserDefaultBlockchainAddress(CurrentUser.Id);
if (!address.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(address)));
}
return(Ok(address.Data));
}
public IActionResult GetWalletTransactions([FromBody] TransactionsFilter filter)
{
var data = walletService.GetTransactionHistory(CurrentUser.Id, filter ?? new TransactionsFilter());
if (!data.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(data)));
}
return(Ok(new WalletTransactionsViewModel
{
Transactions = data.Data.Item1,
Total = data.Data.Item2
}));
}
public IActionResult GetBrokers([FromBody] BrokersFilter filter)
{
var data = trustManagementService.GetBrokerTradeServers(filter ?? new BrokersFilter());
if (!data.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(data.Errors)));
}
return(Ok(new BrokersViewModel
{
Brokers = data.Data.Item1,
Total = data.Data.Item2
}));
}
public IActionResult GetInvestmentPrograms([FromHeader(Name = "Authorization")] string token, [FromBody] InvestmentProgramsFilter filter)
{
var data = trustManagementService.GetInvestmentPrograms(filter ?? new InvestmentProgramsFilter(), CurrentUser?.Id, CurrentUser?.Type);
if (!data.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(data)));
}
return(Ok(new InvestmentProgramsViewModel
{
InvestmentPrograms = data.Data.Item1,
Total = data.Data.Item2
}));
}
public IActionResult Participants([FromBody] ParticipantsFilter filter)
{
var res = tournamentService.GetParticipants(filter);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok(new ParticipantsViewModel
{
Participants = res.Data.Item1,
Total = res.Data.Item2
}));
}
public IActionResult GetManagerOpenTrades([FromBody] TradesFilter filter)
{
var trades = tradesService.GetManagerOpenTrades(filter);
if (!trades.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(trades)));
}
return(Ok(new OpenTradesViewModel
{
Trades = trades.Data.Item1,
Total = trades.Data.Item2
}));
}
public IActionResult NewTrade([FromBody] NewTrade trade)
{
if (!HttpContext.IsLocalRequest())
{
return(BadRequest());
}
var res = tradeServerService.NewTrade(trade);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok());
}
public IActionResult TradeAccountCreated([FromBody] List <AccountCreated> accounts)
{
if (!HttpContext.IsLocalRequest())
{
return(BadRequest());
}
var res = tradeServerService.TradeAccountsCreated(accounts);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok());
}
public IActionResult GetInitData(Guid tradeServerId)
{
if (!HttpContext.IsLocalRequest())
{
return(BadRequest());
}
var res = tradeServerService.GetInitData(tradeServerId);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res)));
}
return(Ok(res.Data));
}
public async Task <IActionResult> ConfirmEmail(string userId, string code)
{
if (userId == null || code == null)
{
return(BadRequest(ErrorResult.GetResult("Empty userId/code")));
}
var user = await userManager.FindByIdAsync(userId);
var result = await userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
return(BadRequest(ErrorResult.GetResult(result)));
}
return(Ok());
}
public IActionResult NewOpenTrades([FromBody] NewOpenTradesEvent trades)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var errors = brokerValidator.ValidateNewOpenTrades(CurrentUser, trades);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
tradesService.SaveNewOpenTrade(trades);
return(Ok());
}
public IActionResult ProcessClosingProgram(Guid investmentProgramId, decimal managerBalance)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var errors = brokerValidator.ValidateProcessClosingProgram(CurrentUser, investmentProgramId);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
trustManagementService.ProcessClosingProgram(investmentProgramId, managerBalance);
return(Ok());
}
public IActionResult ReevaluateManagerToken(Guid investmentProgramId, decimal investorLossShare)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResult.GetResult(ModelState)));
}
var errors = brokerValidator.ValidateReevaluateManagerToken(CurrentUser, investmentProgramId);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
trustManagementService.ReevaluateManagerToken(investmentProgramId, investorLossShare);
return(Ok());
}
public IActionResult CreateManagerAccount([FromBody] NewManager request)
{
var errors = brokerValidator.ValidateCreateManagerAccount(CurrentUser, request);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
var result = trustManagementService.CreateInvestmentProgram(request);
if (!result.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(result)));
}
return(Ok(result.Data));
}
public IActionResult CancelInvestmentRequest(Guid requestId)
{
var errors = investorValidator.ValidateCancelInvestmentRequest(CurrentUser, requestId);
if (errors.Any())
{
return(BadRequest(ErrorResult.GetResult(errors, ErrorCodes.ValidationError)));
}
var res = trustManagementService.CancelInvestmentRequest(requestId);
if (!res.IsSuccess)
{
return(BadRequest(ErrorResult.GetResult(res.Errors)));
}
return(Ok());
}
