private async Task <UserMultiAccount> GetSponsor()
{
var userAccount = await _userAccountDataRepository.GetAsync(_command.UserAccountId);
var userMultiAccountIds = userAccount.UserMultiAccounts.Select(x => x.Id).ToList();
// TODO: How to verify the reflink user's matrix level? Is it 0, 1...9?
var sponsor = await _userMultiAccountRepository.GetByReflinkAsync(_command.SponsorReflink);
var sponsorsMatrix = await _matrixPositionHelper.GetMatrixForGivenMultiAccountAsync(sponsor.Id);
if (_matrixPositionHelper.CheckIfAnyAccountExistInMatrix(sponsorsMatrix, userMultiAccountIds) ||
!_matrixPositionHelper.CheckIfMatrixHasEmptySpace(sponsorsMatrix))
{
// Nie ma miejsca w matrycy sponsora lub w matrycy sponsora jest któreś z kont użytkownika
// Wtedy szukamy nowego sponsora
var emptyMatrixPositionUnderAvailableSponsor = await _matrixPositionHelper
.FindTheNearestEmptyPositionFromGivenAccountWhereInParentsMatrixThereIsNoAnyMultiAccountAsync(sponsor.Id, userMultiAccountIds, 0);
if (emptyMatrixPositionUnderAvailableSponsor == null)
{
throw new ValidationException("There is no space in this matrix level to put this account.");
}
var parentPosition = await _matrixPositionRepository.GetAsync(emptyMatrixPositionUnderAvailableSponsor.ParentId.Value);
sponsor = await _userMultiAccountRepository.GetAsync(parentPosition.UserMultiAccountId.Value);
}
return(sponsor);
}
public async Task <GetUsersViewModel> Handle(GetUsersRequest request, CancellationToken cancellationToken)
{
var users = await _userAccountDataRepository.GetAllAsync();
var userModels = _mapper.Map <List <UserAccountDataModel> >(users);
// TODO: UGLY - TO REFACTOR
foreach (var userAccount in users)
{
var mainMultiAccount = userAccount.UserMultiAccounts.First(x => x.IsMainAccount);
if (!mainMultiAccount.SponsorId.HasValue)
{
continue;
}
var mainAccountSponsor = await _userMultiAccountRepository.GetAsync(mainMultiAccount.SponsorId.Value);
var userToSetSponsor = userModels.Single(x => x.Id == userAccount.Id);
userToSetSponsor.MainAccountSponsorLogin = mainAccountSponsor.MultiAccountName;
userToSetSponsor.MainAccountSponsorReflink = mainAccountSponsor.RefLink;
}
return(new GetUsersViewModel
{
UserAccountsTotalCount = userModels.Count,
UserAccounts = userModels
});
}
public async Task Handle(UserBoughtMatrixPositionEvent notification, CancellationToken cancellationToken = default(CancellationToken))
{
var multiAccount = await _userMultiAccountRepository.GetAsync(notification.MultiAccountId);
multiAccount.SetReflink(_reflinkHelper.GenerateReflink());
await _userMultiAccountRepository.UpdateAsync(multiAccount);
}
public async Task <Guid> Handle(BuyPositionInMatrixCommand command, CancellationToken cancellationToken = default(CancellationToken))
{
var userMultiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId);
await ValidateUserMultiAccount(userMultiAccount, command.MatrixLevel);
var sponsorAccountId = userMultiAccount.SponsorId.Value;
var invitingUserMatrix = await _matrixPositionHelper.GetMatrixForGivenMultiAccountAsync(sponsorAccountId, command.MatrixLevel);
if (invitingUserMatrix is null)
{
throw new ValidationException($"The inviting user from reflink does not have structure on level: {command.MatrixLevel}");
}
MatrixPosition matrixPosition;
if (_matrixPositionHelper.CheckIfMatrixHasEmptySpace(invitingUserMatrix))
{
matrixPosition = invitingUserMatrix
.OrderBy(x => x.DepthLevel)
.First(x => x.UserMultiAccountId == null);
}
else
{
var userAccount = await _userAccountDataRepository.GetAsync(userMultiAccount.UserAccountDataId);
var userMultiAccountIds = userAccount.UserMultiAccounts.Select(x => x.Id).ToList();
matrixPosition = await _matrixPositionHelper.FindTheNearestEmptyPositionFromGivenAccountWhereInParentsMatrixThereIsNoAnyMultiAccountAsync(
sponsorAccountId, userMultiAccountIds, command.MatrixLevel);
if (matrixPosition is null)
{
throw new ValidationException("There is no empty space in the structure where account can be assigned");
}
await ChangeUserSponsor(userMultiAccount, matrixPosition);
}
matrixPosition.AssignMultiAccount(command.UserMultiAccountId);
await _matrixPositionRepository.UpdateAsync(matrixPosition);
_backgroundJobClient.Enqueue <MatrixPositionHasBeenBoughtJob>(
job => job.Execute(matrixPosition.Id, null));
_backgroundJobClient.Enqueue <UserBoughtMatrixPositionJob>(
job => job.Execute(userMultiAccount.Id, null));
_backgroundJobClient.Enqueue <InitWithdrawalJob>(
job => job.Execute(new InitWithdrawalModel
{
MatrixPositionId = matrixPosition.Id,
WithdrawalFor = WithdrawalForHelper.AssignmentInMatrix
}, null));
return(matrixPosition.Id);
}
private async Task ValidateCommand(PayMatrixLevelCommand command)
{
var user = await _userAccountDataRepository.GetAsync(command.UserMultiAccountId);
if (user is null)
{
throw new ValidationException("User multi account with given ID was not found");
}
}
private async Task ValidateCommand(DonateViaAffiliateProgramCommand command)
{
var multiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId);
if (multiAccount is null)
{
throw new AccountNotFoundException("Multi account with given ID was not found");
}
}
public async Task Execute(Guid multiAccountId, PerformContext context)
{
context.WriteLine($"UserBoughtMatrixPositionJob started with multiAccountId - {multiAccountId}");
var multiAccount = await _userMultiAccountRepository.GetAsync(multiAccountId);
multiAccount.SetReflink(_reflinkHelper.GenerateReflink());
await _userMultiAccountRepository.UpdateAsync(multiAccount);
context.WriteLine("UserBoughtMatrixPositionJob completed.");
}
private async Task ValidateCommand(DonateCommand command)
{
if (!command.UserMultiAccountId.HasValue)
{
return;
}
var multiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId.Value);
if (multiAccount is null)
{
throw new AccountNotFoundException("Multi account with given ID was not found");
}
}
public async Task <GetInitiativeDescriptionViewModel> Handle(GetInitiativeDescriptionRequest request, CancellationToken cancellationToken)
{
var multiAccount = await _userMultiAccountRepository.GetAsync(request.MultiAccountId);
if (multiAccount is null)
{
throw new ValidationException($"Multi Account does not exist with given ID: {request.MultiAccountId}");
}
return(new GetInitiativeDescriptionViewModel
{
Initiative = multiAccount.UserAccountData.InitiativeDescription,
ProjectId = multiAccount.MultiAccountName,
ProjectCode = multiAccount.RefLink,
Avatar = multiAccount.UserAccountData.Avatar
});
}
public async Task <UpgradeMatrixResult> Handle(UpgradeMatrixWithoutPaymentValidation_TMPCommand command, CancellationToken cancellationToken)
{
_command = command;
_lowerLevelMatrix = command.MatrixLevel - 1;
_multiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId);
var _userMatrixPositionOnLowerMatrix = await _matrixPositionHelper.GetPositionForAccountAtLevelAsync(_multiAccount.Id, _lowerLevelMatrix);
if (_multiAccount.UserAccountData.Role == UserRolesHelper.Admin && _userMatrixPositionOnLowerMatrix.DepthLevel == 2)
{
var upgradedPositionId = await UpgradeMatrixForAdmin();
return(new UpgradeMatrixResult(upgradedPositionId));
}
return(new UpgradeMatrixResult(Guid.Empty, "Cannot upgrade UpgradeMatrixWithoutPaymentValidation_TMPCommandHandler."));
}
public async Task <MatrixViewModel> Handle(GetMatrixRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var matrixPosition = await _matrixPositionRepository.GetAsync(request.MatrixPositionId);
var matrix = await _matrixPositionRepository.GetMatrixAsync(matrixPosition, matrixPosition.MatrixLevel);
var matrixModel = _mapper.Map <IEnumerable <MatrixPositionModel> >(matrix);
// TODO: Refactor in the future
var matrixModelsList = matrixModel.ToList();
foreach (var matrixPositionModel in matrixModelsList)
{
var tmpPosition = matrix.Single(x => x.Id == matrixPositionModel.Id);
if (tmpPosition.UserMultiAccountId.HasValue)
{
var userMultiAccount = await _multiAccountRepository.GetAsync(tmpPosition.UserMultiAccountId.Value);
matrixPositionModel.MultiAccountName = userMultiAccount.MultiAccountName;
}
else
{
matrixPositionModel.MultiAccountName = null;
}
if (tmpPosition.Id == request.MatrixPositionId)
{
// It's the owner matrix position, so for frontend I set ParentId value to null
matrixPositionModel.ParentId = null;
}
}
return(new MatrixViewModel
{
Matrix = matrixModelsList
});
}
public async Task <UpgradeMatrixResult> Handle(UpgradeMatrixCommand command, CancellationToken cancellationToken = default(CancellationToken))
{
_command = command;
_lowerLevelMatrix = command.MatrixLevel - 1;
_multiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId);
await PreValidation();
if (_multiAccount.UserAccountData.Role == UserRolesHelper.Admin && _userMatrixPositionOnLowerMatrix.DepthLevel == 2)
{
var upgradedPositionId = await UpgradeMatrixForAdmin();
return(new UpgradeMatrixResult(upgradedPositionId));
}
var adminPositionOnLowerMatrix = await _matrixPositionHelper.FindHighestAdminPositionAsync(_multiAccount.Id, _lowerLevelMatrix);
if (adminPositionOnLowerMatrix?.UserMultiAccountId is null)
{
throw new ValidationException($"FATAL! Admin does not exist in the structure in level: {_lowerLevelMatrix}");
}
var adminAccountId = adminPositionOnLowerMatrix.UserMultiAccountId.Value;
var adminPositionOnUpgradingLevel = await _matrixPositionHelper.GetPositionForAccountAtLevelAsync(adminAccountId, command.MatrixLevel);
if (adminPositionOnUpgradingLevel is null)
{
//TODO: Event to notify admin that someone wants to upgrade his matrix
//TODO: Use hangfire for this
return(new UpgradeMatrixResult(Guid.Empty, "Cannot upgrade because admin didn't upgrade his structure yet. E-mail notification has been sent to admin"));
}
var adminSide = await _matrixPositionHelper.GetAdminStructureSide(_multiAccount.Id, _lowerLevelMatrix, adminPositionOnLowerMatrix);
var upgradedMatrixPositionId = await UpgradeMatrixForUser(adminPositionOnUpgradingLevel, adminSide);
return(new UpgradeMatrixResult(upgradedMatrixPositionId));
}
public async Task <Guid> Handle(BuyPositionInMatrixWithoutPaymentValidation_TMPCommand command, CancellationToken cancellationToken)
{
var userMultiAccount = await _userMultiAccountRepository.GetAsync(command.UserMultiAccountId);
var sponsorAccountId = userMultiAccount.SponsorId.Value;
var invitingUserMatrix = await _matrixPositionHelper.GetMatrixForGivenMultiAccountAsync(sponsorAccountId, command.MatrixLevel);
if (invitingUserMatrix is null)
{
throw new ValidationException($"The inviting user from reflink does not have matrix on level: {command.MatrixLevel}");
}
MatrixPosition matrixPosition;
var matrixPositions = invitingUserMatrix as MatrixPosition[] ?? invitingUserMatrix.ToArray();
if (_matrixPositionHelper.CheckIfMatrixHasEmptySpace(matrixPositions))
{
matrixPosition = matrixPositions
.OrderBy(x => x.DepthLevel)
.First(x => x.UserMultiAccountId == null);
}
else
{
throw new ValidationException("There is no empty space in matrix");
}
matrixPosition.AssignMultiAccount(command.UserMultiAccountId);
await _matrixPositionRepository.UpdateAsync(matrixPosition);
_backgroundJobClient.Enqueue <MatrixPositionHasBeenBoughtJob>(
job => job.Execute(matrixPosition.Id, null));
_backgroundJobClient.Enqueue <UserBoughtMatrixPositionJob>(
job => job.Execute(userMultiAccount.Id, null));
return(matrixPosition.Id);
}
/// <summary>
/// Uses Graphviz library to draw a tree
/// </summary>
/// <param name="matrixLevel"></param>
/// <returns></returns>
public async Task <string> GenerateMatrixStructureTreeFileDefinition(int matrixLevel)
{
// TODO: Do it prettier
var results = await _context.Set <MatrixPosition>().FromSql($@"WITH cteEEs AS (
SELECT MatrixPositions.Id, MatrixPositions.ParentId, MatrixPositions.UserMultiAccountId, MatrixPositions.[Left], MatrixPositions.[Right], MatrixPositions.DepthLevel, MatrixPositions.MatrixLevel, MatrixPositions.CreatedAt FROM MatrixPositions WHERE MatrixPositions.ParentId IS NULL AND MatrixPositions.MatrixLevel = {matrixLevel}
UNION ALL
SELECT MatrixPositions.Id, MatrixPositions.ParentId, MatrixPositions.UserMultiAccountId, MatrixPositions.[Left], MatrixPositions.[Right], MatrixPositions.DepthLevel, MatrixPositions.MatrixLevel, MatrixPositions.CreatedAt FROM MatrixPositions JOIN cteEEs ON(MatrixPositions.ParentId = cteEEs.Id) WHERE MatrixPositions.MatrixLevel = {matrixLevel}
)
SELECT* FROM cteEEs")
.ToListAsync();
var nodeRelationships = new StringBuilder();
var nodeDetails = new StringBuilder();
foreach (var node in results)
{
if (node.ParentId.HasValue)
{
nodeRelationships.AppendLine($"\t\"{node.ParentId}\" -> \"{node.Id}\"");
}
var multiAccountName = "";
if (node.UserMultiAccountId.HasValue)
{
var multiAccount = await _userMultiAccountRepository.GetAsync(node.UserMultiAccountId.Value);
multiAccountName = multiAccount.MultiAccountName;
}
nodeDetails.AppendLine($"\t\"{node.Id}\" [label=\"{multiAccountName}\"]");
}
nodeRelationships.AppendLine(nodeDetails.ToString());
return(nodeRelationships.ToString());
}