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 <Credential> > LinkCredentialAsync(UserId userId, Game game)
        {
            var result = new DomainValidationResult <Credential>();

            if (await _gameCredentialRepository.CredentialExistsAsync(userId, game))
            {
                return(result.AddFailedPreconditionError($"{game} credential are already linked."));
            }

            if (!await _gameAuthenticationService.AuthenticationExistsAsync(userId, game))
            {
                return(result.AddFailedPreconditionError($"{game} authentication process not started."));
            }

            var authFactor = await _gameAuthenticationService.FindAuthenticationAsync(userId, game);

            var authResult = await _gameAuthenticationService.ValidateAuthenticationAsync(userId, game, authFactor);

            if (!authResult.IsValid)
            {
                foreach (var error in authResult.Errors)
                {
                    result.AddFailedPreconditionError(error.ErrorMessage);
                }
            }

            if (result.IsValid)
            {
                var credential = new Credential(
                    userId,
                    game,
                    authFactor.PlayerId,
                    new UtcNowDateTimeProvider());

                _gameCredentialRepository.CreateCredential(credential);

                await _gameCredentialRepository.UnitOfWork.CommitAsync();

                return(credential);
            }

            return(result);
        }