public async Task <DomainValidationResult <Clan> > LeaveClanAsync(Clan clan, UserId userId)
{
var result = new DomainValidationResult <Clan>();
if (!clan.HasMember(userId))
{
result.AddFailedPreconditionError($"The user ({userId}) isn't a member of the clan '{clan.Name}'.");
}
if (result.IsValid)
{
var member = clan.FindMember(userId);
clan.Leave(member);
await _clanRepository.UnitOfWork.CommitAsync();
if (clan.Deleted)
{
await this.DeleteClanAsync(clan);
}
return(clan);
}
return(result);
}
public async Task <DomainValidationResult <Division> > CreateDivisionAsync(
Clan clan,
UserId userId,
string name,
string description
)
{
var result = new DomainValidationResult <Division>();
if (!clan.MemberIsOwner(userId))
{
result.AddFailedPreconditionError($"The user ({userId}) isn't the clan owner.");
}
if (result.IsValid)
{
var division = new Division(clan.Id, name, description);
clan.CreateDivision(division);
await _clanRepository.UnitOfWork.CommitAsync();
return(division);
}
return(result);
}
public async Task <DomainValidationResult <UserProfile> > CreateProfileAsync(
User user,
string firstName,
string lastName,
Gender gender
)
{
var result = new DomainValidationResult <UserProfile>();
if (user.Profile != null)
{
result.AddFailedPreconditionError("The user's profile has already been created.");
}
if (result.IsValid)
{
var profile = new UserProfile(firstName, lastName, gender);
user.Create(profile);
//await this.UpdateSecurityStampAsync(user);
await this.UpdateUserAsync(user);
await _publisher.PublishUserProfileChangedIntegrationEventAsync(UserId.FromGuid(user.Id), profile);
return(profile);
}
return(result);
}
public async Task <DomainValidationResult <Member> > KickMemberFromClanAsync(Clan clan, UserId userId, MemberId memberId)
{
var result = new DomainValidationResult <Member>();
if (!clan.MemberIsOwner(userId))
{
result.AddFailedPreconditionError($"The user ({userId}) isn't the clan owner.");
}
if (!clan.HasMember(memberId))
{
result.AddFailedPreconditionError($"The memberId ({memberId}) isn't a member of the clan '{clan.Name}'.");
}
if (result.IsValid)
{
var member = clan.FindMember(memberId);
clan.Kick(member);
await _clanRepository.UnitOfWork.CommitAsync();
return(member);
}
return(result);
}
public async Task <DomainValidationResult <PaymentMethod> > AttachPaymentMethodAsync(
string paymentMethodId,
string customerId,
bool defaultPaymentMethod = false
)
{
var result = new DomainValidationResult <PaymentMethod>();
var paymentMethodCardLimit = Options.PaymentMethod.Card.Limit;
if (await this.PaymentMethodCountAsync(customerId) >= paymentMethodCardLimit)
{
result.AddFailedPreconditionError(
$"You can have a maximum of {paymentMethodCardLimit} card{(paymentMethodCardLimit > 1 ? "s" : string.Empty)} as a payment method");
}
if (result.IsValid)
{
var options = new PaymentMethodAttachOptions
{
Customer = customerId
};
var paymentMethod = await this.AttachAsync(paymentMethodId, options);
if (defaultPaymentMethod || !await _stripeCustomerService.HasDefaultPaymentMethodAsync(customerId))
{
await _stripeCustomerService.SetDefaultPaymentMethodAsync(customerId, paymentMethodId);
}
return(paymentMethod);
}
return(result);
}
public async Task <DomainValidationResult <Invitation> > SendInvitationAsync(ClanId clanId, UserId userId, UserId ownerId)
{
var result = new DomainValidationResult <Invitation>();
if (!await _clanRepository.IsOwnerAsync(clanId, ownerId))
{
result.AddDebugError("Permission required.");
}
if (await _clanRepository.IsMemberAsync(userId))
{
result.AddDebugError("Target already in a clan.");
}
if (await _invitationRepository.ExistsAsync(ownerId, clanId))
{
result.AddFailedPreconditionError("The invitation from this clan to that member already exist.");
}
if (result.IsValid)
{
var invitation = new Invitation(userId, clanId);
_invitationRepository.Create(invitation);
await _invitationRepository.UnitOfWork.CommitAsync();
return(invitation);
}
return(result);
}
public async Task <DomainValidationResult <Doxatag> > ChangeDoxatagAsync(User user, string doxatagName)
{
var result = new DomainValidationResult <Doxatag>();
if (result.IsValid)
{
var codes = await _doxatagRepository.FetchDoxatagCodesByNameAsync(doxatagName);
var code = Doxatag.GenerateUniqueCode(codes);
var doxatag = new Doxatag(
UserId.FromGuid(user.Id),
doxatagName,
code,
new UtcNowDateTimeProvider());
_doxatagRepository.Create(doxatag);
await _doxatagRepository.UnitOfWork.CommitAsync();
return(doxatag);
}
return(result);
}
public async Task <DomainValidationResult <Clan> > CreateClanAsync(UserId userId, string name)
{
var result = new DomainValidationResult <Clan>();
if (await _clanRepository.IsMemberAsync(userId))
{
result.AddFailedPreconditionError("User already in a clan.");
}
if (await _clanRepository.ExistsAsync(name))
{
result.AddFailedPreconditionError("Clan with the same name already exist");
}
if (result.IsValid)
{
var clan = new Clan(name, userId);
_clanRepository.Create(clan);
await _clanRepository.UnitOfWork.CommitAsync();
return(clan);
}
return(result);
}
public async Task DeleteDivisionAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
var userId = new UserId();
var clan = new Clan("testClan", userId);
TestMock.ClanService.Setup(clanService => clanService.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(clan).Verifiable();
TestMock.ClanService.Setup(clanService => clanService.DeleteDivisionAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <DivisionId>()))
.ReturnsAsync(DomainValidationResult <Division> .Failure("Test error"))
.Verifiable();
var clanDivisionsController = new ClanDivisionsController(TestMock.ClanService.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await clanDivisionsController.DeleteDivisionAsync(new ClanId(), new DivisionId());
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.ClanService.Verify(clanService => clanService.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
TestMock.ClanService.Verify(
clanService => clanService.DeleteDivisionAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <DivisionId>()),
Times.Once);
}
public async Task <DomainValidationResult <Promotion> > RedeemPromotionAsync(Promotion promotion, UserId userId, IDateTimeProvider redeemedAt)
{
var result = new DomainValidationResult <Promotion>();
var user = new User(userId);
var recipient = new PromotionRecipient(user, redeemedAt);
if (promotion.IsExpired())
{
result.AddFailedPreconditionError("The promotional code is expired");
}
if (!promotion.IsActive())
{
result.AddFailedPreconditionError("The promotional code is invalid");
}
if (promotion.IsRedeemBy(recipient))
{
result.AddFailedPreconditionError("The promotional code is already redeemed");
}
if (result.IsValid)
{
promotion.Redeem(recipient);
await _promotionRepository.CommitAsync();
return(promotion);
}
return(result);
}
public async Task KickMemberFromClanAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
TestMock.ClanService.Setup(clanService => clanService.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(new Clan("Test", new UserId())).Verifiable();
TestMock.ClanService.Setup(clanService => clanService.KickMemberFromClanAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <MemberId>()))
.ReturnsAsync(DomainValidationResult <Member> .Failure("Error"))
.Verifiable();
var clanMemberController = new ClanMembersController(TestMock.ClanService.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await clanMemberController.KickMemberFromClanAsync(new ClanId(), new MemberId());
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.ClanService.Verify(clanService => clanService.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
TestMock.ClanService.Verify(
clanService => clanService.KickMemberFromClanAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <MemberId>()),
Times.Once);
}
public async Task UpdateProfileAsync_ShouldBeOkObjectResult()
{
// Arrange
var user = new User
{
Profile = new UserProfile("FirstName", "LastName", Gender.Male)
};
TestMock.UserService.Setup(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable();
TestMock.UserService.Setup(userManager => userManager.UpdateProfileAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(DomainValidationResult <UserProfile> .Succeeded(user.Profile))
.Verifiable();
var controller = new ProfileController(TestMock.UserService.Object, TestMapper);
// Act
var result = await controller.UpdateProfileAsync(
new UpdateProfileRequest
{
FirstName = "Bob"
});
// Assert
result.Should().BeOfType <OkObjectResult>();
TestMock.UserService.Verify(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>()), Times.Once);
TestMock.UserService.Verify(userManager => userManager.UpdateProfileAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
}
private async Task <DomainValidationResult <ITransaction> > CreateDepositTransactionAsync(
ITokenAccount account,
Token token,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <ITransaction>();
var transactionBundles = await this.FetchTransactionBundlesAsync(EnumTransactionType.Deposit, EnumCurrencyType.Token);
if (transactionBundles.All(deposit => deposit.Currency.Amount != token.Amount))
{
result.AddFailedPreconditionError(
$"The amount of {nameof(Token)} is invalid. These are valid amounts: [{string.Join(", ", transactionBundles.Select(deposit => deposit.Currency.Amount))}].");
}
if (!account.IsDepositAvailable())
{
result.AddFailedPreconditionError(
$"Buying tokens is unavailable until {account.LastDeposit?.Add(TokenAccountDecorator.DepositInterval)}. For security reason we limit the number of financial transaction that can be done in {TokenAccountDecorator.DepositInterval.TotalHours} hours.");
}
if (result.IsValid)
{
var transaction = account.Deposit(token);
await _accountRepository.CommitAsync(true, cancellationToken);
return(transaction.Cast <Transaction>());
}
return(result);
}
private async Task <DomainValidationResult <ITransaction> > CreateChargeTransactionAsync(
ITokenAccount account,
Token token,
TransactionMetadata?metadata = null,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <ITransaction>();
if (!account.HaveSufficientMoney(token))
{
result.AddFailedPreconditionError("Insufficient funds.");
}
if (result.IsValid)
{
var transaction = account.Charge(token, metadata);
await _accountRepository.CommitAsync(true, cancellationToken);
return(transaction.Cast <Transaction>());
}
return(result);
}
public async Task <DomainValidationResult <ITransaction> > MarkAccountTransactionAsCanceledAsync(
IAccount account,
TransactionMetadata metadata,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <ITransaction>();
if (!account.TransactionExists(metadata))
{
result.AddFailedPreconditionError("Transaction does not exists.");
}
if (result.IsValid)
{
var transaction = account.FindTransaction(metadata);
transaction.MarkAsCanceled();
await _accountRepository.CommitAsync(true, cancellationToken);
return(transaction.Cast <Transaction>());
}
return(result);
}
public async Task SendCandidatureAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
TestMock.CandidatureService.Setup(clanService => clanService.SendCandidatureAsync(It.IsAny <UserId>(), It.IsAny <ClanId>()))
.ReturnsAsync(DomainValidationResult <Candidature> .Failure("Error"))
.Verifiable();
var candidatureController = new CandidaturesController(TestMock.CandidatureService.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await candidatureController.SendCandidatureAsync(
new SendCandidatureRequest
{
ClanId = new ClanId(),
UserId = new UserId()
});
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.CandidatureService.Verify(clanService => clanService.SendCandidatureAsync(It.IsAny <UserId>(), It.IsAny <ClanId>()), Times.Once);
}
public async Task LinkCredentialAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
TestMock.GameCredentialService.Setup(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()))
.ReturnsAsync(DomainValidationResult <Credential> .Failure("test error"))
.Verifiable();
var authFactorController = new GameAuthenticationsController(
TestMock.GameAuthenticationService.Object,
TestMock.GameCredentialService.Object,
TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await authFactorController.LinkCredentialAsync(Game.LeagueOfLegends);
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.GameCredentialService.Verify(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()), Times.Once);
}
public async Task CreateClanAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
TestMock.ClanService.Setup(clanService => clanService.CreateClanAsync(It.IsAny <UserId>(), It.IsAny <string>()))
.ReturnsAsync(DomainValidationResult <Clan> .Failure("Test error"))
.Verifiable();
var clansController = new ClansController(TestMock.ClanService.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
var request = new CreateClanRequest
{
Name = "DONTINVADE",
Summary = "URSSINWINTER"
};
// Act
var result = await clansController.CreateClanAsync(request);
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.ClanService.Verify(clanService => clanService.CreateClanAsync(It.IsAny <UserId>(), It.IsAny <string>()), Times.Once);
}
public async Task AcceptInvitationAsync_ShouldBeOfTypeBadRequestObjectResult()
{
// Arrange
TestMock.InvitationService.Setup(clanService => clanService.FindInvitationAsync(It.IsAny <InvitationId>()))
.ReturnsAsync(new Invitation(new UserId(), new ClanId()))
.Verifiable();
TestMock.InvitationService.Setup(clanService => clanService.AcceptInvitationAsync(It.IsAny <Invitation>(), It.IsAny <UserId>()))
.ReturnsAsync(DomainValidationResult <Invitation> .Failure("Error"))
.Verifiable();
var invitationController = new InvitationsController(TestMock.InvitationService.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await invitationController.AcceptInvitationAsync(new InvitationId());
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
TestMock.InvitationService.Verify(clanService => clanService.FindInvitationAsync(It.IsAny <InvitationId>()), Times.Once);
TestMock.InvitationService.Verify(clanService => clanService.AcceptInvitationAsync(It.IsAny <Invitation>(), It.IsAny <UserId>()), Times.Once);
}
public async Task LinkCredentialAsync_ShouldBeOfTypeOkObjectResult()
{
// Arrange
var userId = new UserId();
var credential = new Credential(
userId,
Game.LeagueOfLegends,
new PlayerId(),
new UtcNowDateTimeProvider());
TestMock.GameCredentialService.Setup(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()))
.ReturnsAsync(DomainValidationResult <Credential> .Succeeded(credential))
.Verifiable();
var authFactorController = new GameAuthenticationsController(
TestMock.GameAuthenticationService.Object,
TestMock.GameCredentialService.Object,
TestMapper)
{
ControllerContext =
{
HttpContext = new MockHttpContextAccessor().Object.HttpContext
}
};
// Act
var result = await authFactorController.LinkCredentialAsync(Game.LeagueOfLegends);
// Assert
result.Should().BeOfType <OkObjectResult>();
TestMock.GameCredentialService.Verify(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()), Times.Once);
}
public async Task <DomainValidationResult <IChallenge> > CreateChallengeAsync(
ChallengeName name,
Game game,
BestOf bestOf,
Entries entries,
ChallengeDuration duration,
IDateTimeProvider createAt,
Scoring scoring,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <IChallenge>();
if (result.IsValid)
{
var challenge = new Challenge(
new ChallengeId(),
name,
game,
bestOf,
entries,
new ChallengeTimeline(createAt, duration),
scoring);
_challengeRepository.Create(challenge);
await _challengeRepository.CommitAsync(true, cancellationToken);
return(challenge);
}
return(result);
}
public async Task <DomainValidationResult <Participant> > SnapshotChallengeParticipantAsync(
IChallenge challenge,
PlayerId gamePlayerId,
IDateTimeProvider synchronizedAt,
Func <IScoring, IImmutableSet <Match> > snapshotMatches,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <Participant>();
if (!challenge.ParticipantExists(gamePlayerId))
{
result.AddFailedPreconditionError("Participant doesn't exists.");
}
if (result.IsValid)
{
var participant = challenge.FindParticipant(gamePlayerId);
var matches = snapshotMatches(challenge.Scoring);
participant.Snapshot(matches, synchronizedAt);
await _challengeRepository.CommitAsync(true, cancellationToken);
return(participant);
}
return(result);
}
public async Task <DomainValidationResult <Address> > UpdateAddressAsync(
Address address,
string line1,
string?line2,
string city,
string?state,
string?postalCode
)
{
var result = new DomainValidationResult <Address>();
if (result.IsValid)
{
address.Update(
line1,
line2,
city,
state,
postalCode);
await _addressRepository.UnitOfWork.CommitAsync();
await _serviceBusPublisher.PublishUserAddressChangedIntegrationEventAsync(UserId.FromGuid(address.UserId), address);
return(address);
}
return(result);
}
public async Task <DomainValidationResult <Candidature> > SendCandidatureAsync(UserId userId, ClanId clanId)
{
var result = new DomainValidationResult <Candidature>();
if (await _clanRepository.IsMemberAsync(userId))
{
result.AddFailedPreconditionError("User already in a clan.");
}
if (await _candidatureRepository.ExistsAsync(userId, clanId))
{
result.AddFailedPreconditionError("The candidature of this member for that clan already exist.");
}
if (result.IsValid)
{
var candidature = new Candidature(userId, clanId);
_candidatureRepository.Create(candidature);
await _candidatureRepository.UnitOfWork.CommitAsync();
return(candidature);
}
return(result);
}
public async Task <DomainValidationResult <ITransaction> > CreateTransactionAsync(
IAccount account,
int bundleId,
TransactionMetadata?metadata = null,
CancellationToken cancellationToken = default
)
{
var result = new DomainValidationResult <ITransaction>();
if (!await this.TransactionBundleExistsAsync(bundleId))
{
result.AddFailedPreconditionError($"Transaction bundle with id of '{bundleId}' wasn't found.");
}
if (result.IsValid)
{
var transactionBundle = await this.FindTransactionBundleAsync(bundleId);
return(await this.CreateTransactionAsync(
account,
transactionBundle.Currency.Amount,
transactionBundle.Currency.Type.ToEnumeration <CurrencyType>(),
transactionBundle.Type.ToEnumeration <TransactionType>(),
metadata,
cancellationToken));
}
return(result);
}
public override async Task <DomainValidationResult <object> > GenerateAuthenticationAsync(UserId userId, LeagueOfLegendsRequest request)
{
try
{
var result = new DomainValidationResult <object>();
var summoner = await _leagueOfLegendsService.Summoner.GetSummonerByNameAsync(Region.Na, request.SummonerName);
if (await _gameCredentialRepository.CredentialExistsAsync(PlayerId.Parse(summoner.AccountId), Game))
{
result.AddFailedPreconditionError("Summoner's name is already linked by another eDoxa account");
}
if (result.IsValid)
{
if (await _gameAuthenticationRepository.AuthenticationExistsAsync(userId, Game))
{
await _gameAuthenticationRepository.RemoveAuthenticationAsync(userId, Game);
}
var gameAuthentication = await this.GenerateAuthFactor(summoner);
await _gameAuthenticationRepository.AddAuthenticationAsync(userId, Game, gameAuthentication);
return(gameAuthentication.Factor);
}
return(result);
}
catch (RiotSharpException)
{
return(DomainValidationResult <object> .Failure("Summoner name is invalid"));
}
}
public async Task <DomainValidationResult <Promotion> > CancelPromotionAsync(Promotion promotion, IDateTimeProvider canceledAt)
{
var result = new DomainValidationResult <Promotion>();
if (promotion.IsCanceled())
{
result.AddFailedPreconditionError("The promotional code is canceled");
}
if (promotion.IsExpired())
{
result.AddFailedPreconditionError("The promotional code is expired");
}
if (result.IsValid)
{
promotion.Cancel(canceledAt);
await _promotionRepository.CommitAsync();
return(promotion);
}
return(result);
}
public async Task <DomainValidationResult <Promotion> > CreatePromotionAsync(
string promotionalCode,
Currency currency,
TimeSpan duration,
DateTime expiredAt
)
{
var result = new DomainValidationResult <Promotion>();
if (!await _promotionRepository.IsPromotionalCodeAvailableAsync(promotionalCode))
{
result.AddFailedPreconditionError("The promotional code isn't available");
}
if (result.IsValid)
{
var promotion = new Promotion(
promotionalCode,
currency,
duration,
new DateTimeProvider(expiredAt));
_promotionRepository.Create(promotion);
await _promotionRepository.CommitAsync();
return(promotion);
}
return(result);
}
public static void AddToModelState <TResponse>(this DomainValidationResult <TResponse> result, ModelStateDictionary modelState)
where TResponse : class
{
foreach (var error in result.Errors)
{
modelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
}
public async Task <DomainValidationResult <Candidature> > DeclineCandidatureAsync(Candidature candidature, UserId userId)
{
if (!await _clanRepository.IsOwnerAsync(candidature.ClanId, userId))
{
return(DomainValidationResult <Candidature> .Failure("Permission required."));
}
_candidatureRepository.Delete(candidature);
await _candidatureRepository.UnitOfWork.CommitAsync();
return(new DomainValidationResult <Candidature>());
}
