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);
}
private async Task <Guid> UpgradeMatrixForUser(MatrixPosition adminPosition, AdminStructureSide adminStructure)
{
MatrixPosition upgradedPosition;
if (!_multiAccount.SponsorId.HasValue)
{
throw new ValidationException("FATAL! User does not have sponsor");
}
var userAccount = await _userAccountDataRepository.GetAsync(_multiAccount.UserAccountDataId);
var userMultiAccountIds = userAccount.UserMultiAccounts.Select(x => x.Id).ToList(); // Need for cycles in the future
var sponsorPositionOnUpgradedMatrix = await _matrixPositionHelper.GetPositionForAccountAtLevelAsync(_multiAccount.SponsorId.Value, _command.MatrixLevel);
if (sponsorPositionOnUpgradedMatrix is null)
{
upgradedPosition = await _matrixPositionHelper.FindTheNearestEmptyPositionFromGivenAccountWhereInParentsMatrixThereIsNoAnyMultiAccountAsync(
adminPosition.UserMultiAccountId.Value, userMultiAccountIds, _command.MatrixLevel, adminStructure);
}
else
{
upgradedPosition = await _matrixPositionHelper.FindTheNearestEmptyPositionFromGivenAccountWhereInParentsMatrixThereIsNoAnyMultiAccountAsync(
_multiAccount.SponsorId.Value, userMultiAccountIds, _command.MatrixLevel);
}
if (upgradedPosition is null)
{
throw new ValidationException($"There is no empty space in the structure level - {_command.MatrixLevel} - where account can be assigned");
}
upgradedPosition.AssignMultiAccount(_multiAccount.Id);
await _matrixPositionRepository.UpdateAsync(upgradedPosition);
_backgroundJobClient.Enqueue <MatrixPositionHasBeenUpgradedJob>(
job => job.Execute(upgradedPosition.Id, null));
_backgroundJobClient.Enqueue <InitWithdrawalJob>(
job => job.Execute(new InitWithdrawalModel
{
MatrixPositionId = upgradedPosition.Id,
WithdrawalFor = WithdrawalForHelper.UpgradedMatrix
}, null));
return(upgradedPosition.Id);
}
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);
}
