public override async Task <CreatePaypalPayoutResponse> CreatePaypalPayout(CreatePaypalPayoutRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var email = httpContext.GetEmail();
try
{
var payoutBatch = await _paypalPayoutService.CreateAsync(
request.Transaction.Id.ParseEntityId <TransactionId>(),
request.Email,
-request.Transaction.Currency.Amount.ToDecimal(),
request.Transaction.Description);
await _serviceBusPublisher.PublishUserWithdrawSucceededIntegrationEventAsync(userId, request.Transaction);
var response = new CreatePaypalPayoutResponse();
var message = $"A PayPal payout batch '{payoutBatch.batch_header.payout_batch_id}' was created for the user '{email}'. (userId=\"{userId}\")";
return(context.Ok(response, message));
}
catch (Exception exception)
{
await _serviceBusPublisher.PublishUserWithdrawFailedIntegrationEventAsync(userId, request.Transaction);
var message = $"Failed to process withdraw for the user '{email}'. (userId=\"{userId}\")";
throw this.RpcExceptionWithInternalStatus(exception, message);
}
}
public override async Task <DeleteRoleResponse> DeleteRole(DeleteRoleRequest request, ServerCallContext context)
{
if (!await _roleService.RoleExistsAsync(request.RoleName))
{
throw context.NotFoundRpcException($"The role '{request.RoleName}' wasn't found.");
}
var role = await _roleService.FindByNameAsync(request.RoleName);
var result = await _roleService.DeleteAsync(role);
if (result.Succeeded)
{
var detail = $"The role '{role.Name}' as been deleted. (roleId=${role.Id})";
var response = new DeleteRoleResponse
{
Role = new RoleDto
{
Id = role.Id.ToString(),
Name = role.Name
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(result, $"Failed to delete the role '{role.Name}'. (roleId=${role.Id})");
}
public override async Task <SynchronizeChallengeResponse> SynchronizeChallenge(SynchronizeChallengeRequest request, ServerCallContext context)
{
var challengeId = request.ChallengeId.ParseEntityId <ChallengeId>();
if (!await _challengeService.ChallengeExistsAsync(challengeId))
{
throw context.NotFoundRpcException("Challenge not found.");
}
var challenge = await _challengeService.FindChallengeAsync(challengeId);
var result = await _challengeService.SynchronizeChallengeAsync(challenge, new UtcNowDateTimeProvider());
if (result.IsValid)
{
var response = new SynchronizeChallengeResponse
{
Challenge = ChallengeProfile.Map(result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
public override async Task <CreateStripePaymentIntentResponse> CreateStripePaymentIntent(
CreateStripePaymentIntentRequest request,
ServerCallContext context
)
{
var httpContext = context.GetHttpContext();
var paymentIntentService = new PaymentIntentService();
var options = new PaymentIntentCreateOptions
{
PaymentMethod = request.PaymentMethodId,
Customer = httpContext.GetStripeCustomerId(),
ReceiptEmail = httpContext.GetEmail(),
Amount = request.Transaction.Currency.ToCents(),
Currency = Options.Invoice.Currency,
Metadata = new Dictionary <string, string>
{
["UserId"] = httpContext.GetUserId(),
["TransactionId"] = request.Transaction.Id
}
};
var paymentIntent = await paymentIntentService.CreateAsync(options);
var response = new CreateStripePaymentIntentResponse
{
ClientSecret = paymentIntent.ClientSecret
};
var message = $"A new payment {paymentIntent.Id} for {paymentIntent.Amount} {paymentIntent.Currency} was created";
return(context.Ok(response, message));
}
public override async Task <CreateChallengeResponse> CreateChallenge(CreateChallengeRequest request, ServerCallContext context)
{
// TODO: Validation...
var result = await _challengeService.CreateChallengeAsync(
new ChallengeName(request.Name),
request.Game.ToEnumeration <Game>(),
new BestOf(request.BestOf),
new Entries(request.Entries),
new ChallengeDuration(TimeSpan.FromDays(request.Duration)),
new UtcNowDateTimeProvider(),
new Scoring(request.Scoring.Items.OrderBy(item => item.Order).ToDictionary(item => item.StatName, item => item.StatWeighting)));
if (result.IsValid)
{
var response = new CreateChallengeResponse
{
Challenge = ChallengeProfile.Map(result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
public override async Task <CreateTransactionResponse> CreateTransaction(CreateTransactionRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var account = await _accountService.FindAccountOrNullAsync(userId);
if (account == null)
{
throw context.NotFoundRpcException("User account not found.");
}
var result = await CreateTransactionByOneofCaseAsync();
if (result.IsValid)
{
var response = new CreateTransactionResponse
{
Transaction = _mapper.Map <TransactionDto>(result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
async Task <DomainValidationResult <ITransaction> > CreateTransactionByOneofCaseAsync()
{
switch (request.TransactionCase)
{
case CreateTransactionRequest.TransactionOneofCase.Bundle:
{
return(await _accountService.CreateTransactionAsync(account !, request.Bundle, new TransactionMetadata(request.Metadata)));
}
case CreateTransactionRequest.TransactionOneofCase.Custom:
{
return(await _accountService.CreateTransactionAsync(
account !,
request.Custom.Currency.Amount,
request.Custom.Currency.Type.ToEnumeration <CurrencyType>(),
request.Custom.Type.ToEnumeration <TransactionType>(),
new TransactionMetadata(request.Metadata)));
}
default:
{
throw context.RpcException(
new Status(
StatusCode.InvalidArgument,
$"The case ({request.TransactionCase}) is not supported for {nameof(this.CreateTransaction)}."));
}
}
}
}
public override async Task <AddRoleClaimResponse> AddRoleClaim(AddRoleClaimRequest request, ServerCallContext context)
{
if (!await _roleService.RoleExistsAsync(request.RoleName))
{
throw context.NotFoundRpcException($"The role '{request.RoleName}' wasn't found.");
}
var role = await _roleService.FindByNameAsync(request.RoleName);
var claims = await _roleService.GetClaimsAsync(role);
var claim = new Claim(request.Claim.Type, request.Claim.Value);
if (claims.Any(x => x.Type == claim.Type && x.Value == claim.Value))
{
var detail = $"The claim type '{claim.Type}' (value=\"{claim.Value}\") already exists in role '{role.Name}'. (roleId=${role.Id})";
var response = new AddRoleClaimResponse
{
Claim = new RoleClaimDto
{
Type = claim.Type,
Value = claim.Value
}
};
return(context.AlreadyExists(response, detail));
}
var result = await _roleService.AddClaimAsync(role, claim);
if (result.Succeeded)
{
var detail = $"The claim type '{claim.Type}' (value=\"{claim.Value}\") as been added to the role '{role.Name}'. (roleId=${role.Id})";
var response = new AddRoleClaimResponse
{
Claim = new RoleClaimDto
{
Type = claim.Type,
Value = claim.Value
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(
result,
$"Failed to add the claim type '{claim.Type}' (value=\"{claim.Value}\") to the role '{role.Name}'. (roleId=${role.Id})");
}
public override async Task <AddUserClaimResponse> AddUserClaim(AddUserClaimRequest request, ServerCallContext context)
{
var user = await _userService.FindByIdAsync(request.UserId);
if (user == null)
{
throw context.NotFoundRpcException($"The user '{request.UserId}' wasn't found.");
}
var claims = await _userService.GetClaimsAsync(user);
var claim = new Claim(request.Claim.Type, request.Claim.Value);
if (claims.Any(x => x.Type == claim.Type && x.Value == claim.Value))
{
var detail = $"The claim type '{claim.Type}' (value=\"{claim.Value}\") already exists in user '{user.Email}'. (userId=${user.Id})";
var response = new AddUserClaimResponse
{
Claim = new UserClaimDto
{
Type = claim.Type,
Value = claim.Value
}
};
return(context.AlreadyExists(response, detail));
}
var result = await _userService.AddClaimAsync(user, claim);
if (result.Succeeded)
{
var detail = $"The claim type '{claim.Type}' (value=\"{claim.Value}\") as been added to the user '{user.Email}'. (userId=${user.Id})";
var response = new AddUserClaimResponse
{
Claim = new UserClaimDto
{
Type = claim.Type,
Value = claim.Value
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(
result,
$"Failed to add the claim type '{claim.Type}' (value=\"{claim.Value}\") to the user '{user.Email}'. (userId=${user.Id})");
}
public override async Task <FetchChallengePayoutsResponse> FetchChallengePayouts(FetchChallengePayoutsRequest request, ServerCallContext context)
{
var challenges = await _challengeQuery.FetchChallengesAsync();
var response = new FetchChallengePayoutsResponse
{
Payouts =
{
_mapper.Map <IEnumerable <ChallengePayoutDto> >(challenges)
}
};
return(context.Ok(response));
}
public override async Task <FetchDoxatagsResponse> FetchDoxatags(FetchDoxatagsRequest request, ServerCallContext context)
{
var doxatags = await _doxatagService.FetchDoxatagsAsync();
var response = new FetchDoxatagsResponse
{
Doxatags =
{
doxatags.Select(MapDoxatag)
}
};
return(context.Ok(response, string.Empty));
}
public override async Task <AddUserToRoleResponse> AddUserToRole(AddUserToRoleRequest request, ServerCallContext context)
{
var user = await _userService.FindByIdAsync(request.UserId);
if (user == null)
{
throw context.NotFoundRpcException($"The user '{request.UserId}' wasn't found.");
}
if (await _userService.IsInRoleAsync(user, request.RoleName))
{
var existingRole = await _roleService.FindByNameAsync(request.RoleName);
var detail = $"The role '{existingRole.Name}' already exists. (roleId=${existingRole.Id})";
var response = new AddUserToRoleResponse
{
Role = new RoleDto
{
Id = existingRole.Id.ToString(),
Name = existingRole.Name
}
};
return(context.AlreadyExists(response, detail));
}
var result = await _userService.AddToRoleAsync(user, request.RoleName);
if (result.Succeeded)
{
var role = await _roleService.FindByNameAsync(request.RoleName);
var detail = $"The role '{role.Name}' as been created. (roleId=${role.Id})";
var response = new AddUserToRoleResponse
{
Role = new RoleDto
{
Id = role.Id.ToString(),
Name = role.Name
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(result, string.Empty);
}
public override async Task <FindChallengePayoutResponse> FindChallengePayout(FindChallengePayoutRequest request, ServerCallContext context)
{
var challenge = await _challengeQuery.FindChallengeAsync(request.ChallengeId.ParseEntityId <ChallengeId>());
if (challenge == null)
{
throw context.NotFoundRpcException("Challenge not found.");
}
var response = new FindChallengePayoutResponse
{
Payout = _mapper.Map <ChallengePayoutDto>(challenge)
};
return(context.Ok(response));
}
public override async Task <FetchChallengesResponse> FetchChallenges(FetchChallengesRequest request, ServerCallContext context)
{
var challenges = await _challengeQuery.FetchChallengesAsync(
request.Game.ToEnumerationOrNull <Game>(),
request.State.ToEnumerationOrNull <ChallengeState>(),
request.IncludeMatches);
var response = new FetchChallengesResponse
{
Challenges =
{
challenges.Select(ChallengeProfile.Map)
}
};
return(context.Ok(response));
}
public override async Task <CreateRoleResponse> CreateRole(CreateRoleRequest request, ServerCallContext context)
{
if (await _roleService.RoleExistsAsync(request.RoleName))
{
var existingRole = await _roleService.FindByNameAsync(request.RoleName);
var detail = $"The role '{existingRole.Name}' already exists. (roleId=${existingRole.Id})";
var response = new CreateRoleResponse
{
Role = new RoleDto
{
Id = existingRole.Id.ToString(),
Name = existingRole.Name
}
};
return(context.AlreadyExists(response, detail));
}
var role = new Role
{
Id = Guid.NewGuid(),
Name = request.RoleName
};
var result = await _roleService.CreateAsync(role);
if (result.Succeeded)
{
var detail = $"The role '{role.Name}' as been created. (roleId=${role.Id})";
var response = new CreateRoleResponse
{
Role = new RoleDto
{
Id = role.Id.ToString(),
Name = role.Name
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(result, $"Failed to create the role '{role.Name}'. (roleId=${role.Id})");
}
public override async Task <FindChallengeResponse> FindChallenge(FindChallengeRequest request, ServerCallContext context)
{
var challengeId = request.ChallengeId.ParseEntityId <ChallengeId>();
if (!await _challengeService.ChallengeExistsAsync(challengeId))
{
throw context.NotFoundRpcException("Challenge not found.");
}
var challenge = await _challengeQuery.FindChallengeAsync(challengeId);
var response = new FindChallengeResponse
{
Challenge = ChallengeProfile.Map(challenge !)
};
return(context.Ok(response));
}
public override async Task <CreateChallengePayoutResponse> CreateChallengePayout(CreateChallengePayoutRequest request, ServerCallContext context)
{
var result = await _challengeService.CreateChallengeAsync(
request.ChallengeId.ParseEntityId <ChallengeId>(),
new ChallengePayoutEntries(request.PayoutEntries),
new EntryFee(request.EntryFee.Amount, request.EntryFee.Type.ToEnumeration <CurrencyType>()));
if (result.IsValid)
{
var response = new CreateChallengePayoutResponse
{
Payout = _mapper.Map <ChallengePayoutDto>(result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
public override async Task <ReplaceUserClaimResponse> ReplaceUserClaim(ReplaceUserClaimRequest request, ServerCallContext context)
{
var user = await _userService.FindByIdAsync(request.UserId);
if (user == null)
{
throw context.NotFoundRpcException($"The user '{request.UserId}' wasn't found.");
}
var claims = await _userService.GetClaimsAsync(user);
var claim = claims.SingleOrDefault(x => x.Type == request.Claim.Type);
if (claim == null)
{
throw context.NotFoundRpcException(
$"The claim type '{request.Claim.Type}' (value=\"{request.Claim.Value}\") not found in user '{user.Email}'. (userId=${user.Id})");
}
var newClaim = new Claim(request.Claim.Type, request.Claim.Value);
var result = await _userService.ReplaceClaimAsync(user, claim, newClaim);
if (result.Succeeded)
{
var detail = $"The claim type '{newClaim.Type}' (value=\"{newClaim.Value}\") as been replaced for the user '{user.Email}'. (userId=${user.Id})";
var response = new ReplaceUserClaimResponse
{
Claim = new UserClaimDto
{
Type = newClaim.Type,
Value = newClaim.Value
}
};
return(context.Ok(response, detail));
}
throw context.FailedPreconditionRpcException(
result,
$"Failed to replace the claim type '{newClaim.Type}' (value=\"{newClaim.Value}\") from the user '{user.Email}'. (userId=${user.Id})");
}
public override async Task <SnapshotChallengeParticipantResponse> SnapshotChallengeParticipant(
SnapshotChallengeParticipantRequest request,
ServerCallContext context
)
{
var challengeId = request.ChallengeId.ParseEntityId <ChallengeId>();
if (!await _challengeService.ChallengeExistsAsync(challengeId))
{
throw context.NotFoundRpcException("Challenge not found.");
}
var challenge = await _challengeService.FindChallengeAsync(challengeId);
var result = await _challengeService.SnapshotChallengeParticipantAsync(
challenge,
request.GamePlayerId.ParseStringId <PlayerId>(),
new UtcNowDateTimeProvider(),
scoring => request.Matches.Select(
match => new Match(
new GameUuid(match.GameUuid),
new DateTimeProvider(match.GameCreatedAt.ToDateTime()),
match.GameDuration.ToTimeSpan(),
scoring.Map(match.Stats),
new UtcNowDateTimeProvider()))
.ToImmutableHashSet());
if (result.IsValid)
{
var response = new SnapshotChallengeParticipantResponse
{
Participant = ChallengeProfile.Map(challenge, result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
public override async Task <FetchChallengeHistoryResponse> FetchChallengeHistory(FetchChallengeHistoryRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var challenges = await _challengeQuery.FetchUserChallengeHistoryAsync(
userId,
request.Game.ToEnumerationOrNull <Game>(),
request.State.ToEnumerationOrNull <ChallengeState>(),
request.IncludeMatches);
var response = new FetchChallengeHistoryResponse
{
Challenges =
{
challenges.Select(ChallengeProfile.Map)
}
};
return(context.Ok(response));
}
public override async Task <FindPlayerGameCredentialResponse> FindPlayerGameCredential(
FindPlayerGameCredentialRequest request,
ServerCallContext context
)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var credential = await _gameCredentialService.FindCredentialAsync(userId, request.Game.ToEnumeration <Game>());
if (credential == null)
{
throw context.NotFoundRpcException("Game credential not found.");
}
var response = new FindPlayerGameCredentialResponse
{
Credential = _mapper.Map <GameCredentialDto>(credential)
};
return(context.Ok(response));
}
public override async Task <RegisterChallengeParticipantResponse> RegisterChallengeParticipant(
RegisterChallengeParticipantRequest request,
ServerCallContext context
)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var challengeId = request.ChallengeId.ParseEntityId <ChallengeId>();
if (!await _challengeService.ChallengeExistsAsync(challengeId))
{
throw context.NotFoundRpcException("Challenge not found.");
}
var challenge = await _challengeService.FindChallengeAsync(challengeId);
var result = await _challengeService.RegisterChallengeParticipantAsync(
challenge,
userId,
request.ParticipantId.ParseEntityId <ParticipantId>(),
request.GamePlayerId.ParseStringId <PlayerId>(),
new UtcNowDateTimeProvider());
if (result.IsValid)
{
var response = new RegisterChallengeParticipantResponse
{
Participant = ChallengeProfile.Map(challenge, result.Response)
};
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
public override async Task <DeleteTransactionResponse> DeleteTransaction(DeleteTransactionRequest request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
var userId = httpContext.GetUserId();
var account = await _accountService.FindAccountOrNullAsync(userId);
if (account == null)
{
throw context.NotFoundRpcException("User account not found.");
}
var result = await _accountService.DeleteTransactionAsync(account !, request.TransactionId.ParseEntityId <TransactionId>());
if (result.IsValid)
{
var response = new DeleteTransactionResponse();
return(context.Ok(response));
}
throw context.FailedPreconditionRpcException(result);
}
