async Task <Guid> IGameCommands.TieBetAsync([NotNull] GameActionData actionData,
[NotNull] GameActionContext context)
{
var gameProviderId = await ValidateGameProviderAsync(context.GameProviderCode);
ValidateTransactionIsUnique(actionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var round = GetRound(actionData);
var walletTransactionId = await _walletOperations.TieBetAsync(round.Data.PlayerId, round.Data.GameId, round.Data.Id, actionData.Amount);
var tieGameActionId = round.Tie(
actionData.Description,
walletTransactionId,
actionData.ExternalTransactionId,
actionData.ExternalBetId,
actionData.TransactionReferenceId,
actionData.BatchId);
await _repository.SaveChangesAsync();
await _gameEventsProcessor.Process(round.Events, context.PlayerToken, round.Data.BrandCode, actionData, context.GameProviderCode);
scope.Complete();
return(tieGameActionId);
}
}
/// <summary>
/// Registers a Win bet action
/// </summary>
/// <param name="gameActionData"></param>
/// <param name="context"></param>
/// <returns></returns>
async Task <Guid> IGameCommands.WinBetAsync([NotNull] GameActionData gameActionData,
[NotNull] GameActionContext context)
{
var gameProviderId = await ValidateGameProvider(context.GameProviderCode);
ValidateTransactionIsUnique(gameActionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var round = GetRound(gameActionData);
await
_walletOperations.WinBetAsync(round.Data.PlayerId, round.Data.GameId, round.Data.Id,
gameActionData.Amount, gameActionData.ExternalTransactionId);
var winGameActionId = round.Win(gameActionData, context);
await _repository.SaveChangesAsync();
round.Events.ForEach(ev => _eventBus.Publish(ev));
scope.Complete();
return(winGameActionId);
}
}
/// <summary>
/// Places a bet
/// </summary>
async Task <Guid> IGameCommands.PlaceBetAsync([NotNull] GameActionData gameActionData,
[NotNull] GameActionContext context, Guid playerId)
{
var player = await ValidatePlayer(playerId);
await ValidateBrand(player.BrandId);
var gameProviderId = await ValidateGameProvider(context.GameProviderCode);
ValidateTransactionIsUnique(gameActionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var game = GetGameByExternalGameId(gameActionData.ExternalGameId);
var round = _repository.GetOrCreateRound(gameActionData.RoundId, game.Id, player.Id, player.BrandId);
await
_walletOperations.PlaceBetAsync(playerId, game.Id, round.Data.Id, gameActionData.Amount,
gameActionData.ExternalTransactionId);
var placeBetGameActionId = round.Place(gameActionData, context);
_repository.Rounds.AddOrUpdate(x => x.ExternalRoundId, round.Data);
_repository.SaveChanges();
round.Events.ForEach(ev => _eventBus.Publish(ev));
scope.Complete();
return(placeBetGameActionId);
}
}
void ICommonGameActionsProvider.SetGameActionContext(GameActionContextDetails context)
{
Context = new GameActionContext
{
GameProviderId = context.GameProviderId,
OptionalTxRefId = context.OptionalTxRefId
};
}
void ICommonGameActionsProvider.SetGameActionContext(GameActionContextDetails context)
{
Context = new GameActionContext
{
GameProviderCode = context.GameProviderCode,
OptionalTxRefId = context.OptionalTxRefId,
PlayerToken = context.PlayerToken
};
}
public Guid Tie(GameActionData gameActionData, GameActionContext context)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
var gameActionTransactionId = GenerateGameAction <BetTied>(GameActionType.Tied, gameActionData, context);
CloseRound();
return(gameActionTransactionId);
}
public Guid Win(GameActionData gameActionData, GameActionContext context)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
ValidatePositiveAmount(gameActionData.Amount);
var gameActionTransactionId = GenerateGameAction <BetWon>(GameActionType.Won, gameActionData, context);
CloseRound();
return(gameActionTransactionId);
}
public Guid Free(GameActionData gameActionData, GameActionContext context)
{
if (gameActionData.TransactionReferenceId != null)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
}
ValidateNonNegativeAmount(gameActionData.Amount);
var gameActionTransactionId = GenerateGameAction <BetPlacedFree>(GameActionType.Free, gameActionData, context);
CloseRound();
return(gameActionTransactionId);
}
public Guid Place(GameActionData gameActionData, GameActionContext context)
{
if (gameActionData.TransactionReferenceId != null)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
}
ValidatePositiveAmount(gameActionData.Amount);
var gameActionTransactionId = GenerateGameAction <BetPlaced>(GameActionType.Placed, gameActionData, context);
Data.Status = RoundStatus.Open;
return(gameActionTransactionId);
}
/// <summary>
/// Cancels a game action
/// </summary>
/// <param name="gameActionData"></param>
/// <param name="context"></param>
/// <returns></returns>
async Task <Guid> IGameCommands.CancelTransactionAsync([NotNull] GameActionData gameActionData,
[NotNull] GameActionContext context)
{
var gameProviderId = await ValidateGameProvider(context.GameProviderCode);
ValidateTransactionIsUnique(gameActionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var round = GetRound(gameActionData);
var gameActionToCancel = round.GetGameActionByReferenceId(gameActionData.TransactionReferenceId);
if (gameActionToCancel == null)
{
throw new GameActionNotFoundException();
}
var amount = -gameActionToCancel.Amount;
if (gameActionToCancel.Amount != amount)
{
// TODO: raise an administrative event (amounts don't match when cancelling a transaction)
}
await
_walletOperations.CancelBetAsync(round.Data.PlayerId, round.Data.GameId, round.Data.Id,
gameActionData.ExternalTransactionId, gameActionData.TransactionReferenceId);
var cancelGameActionId = CancelRound(round, gameActionData, context);
_repository.SaveChanges();
round.Events.ForEach(ev => _eventBus.Publish(ev));
scope.Complete();
return(cancelGameActionId);
}
}
private Guid CancelRound(Round round, GameActionData gameActionData, GameActionContext context)
{
return(round.Cancel(gameActionData, context));
}
private Guid AdjustRound(Round round, GameActionData gameActionData, GameActionContext context)
{
return(round.Adjust(gameActionData, context));
}
/// <summary>
/// Adjusts a game action made previously
/// </summary>
/// <param name="gameActionData"></param>
/// <param name="context"></param>
/// <returns></returns>
Guid IGameCommands.AdjustTransaction([NotNull] GameActionData gameActionData, [NotNull] GameActionContext context)
{
var gameProviderId = ValidateGameProvider(context.GameProviderCode).GetAwaiter().GetResult();
ValidateTransactionIsUnique(gameActionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var round = GetRound(gameActionData);
var adjustmentGameActionId = AdjustRound(round, gameActionData, context);
_repository.SaveChanges();
round.Events.ForEach(ev => _eventBus.Publish(ev));
scope.Complete();
return(adjustmentGameActionId);
}
}
/// <summary>
/// Places a bet
/// </summary>
async Task <Guid> IGameCommands.PlaceBetAsync([NotNull] GameActionData actionData, [NotNull] GameActionContext context, Guid playerId)
{
var player = await _repository.Players.SingleAsync(x => x.Id == playerId);
await ValidateBrand(player.BrandId);
var gameProviderId = await ValidateGameProviderAsync(context.GameProviderCode);
ValidateTransactionIsUnique(actionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
{
var game = GetGameByExternalGameId(actionData.ExternalGameId);
var round = _repository.GetOrCreateRound(actionData.RoundId, game.Id, player.Id, player.BrandId);
var walletTransactionId = await _walletOperations.PlaceBetAsync(player.Id, round.Data.GameId, round.Data.Id, actionData.Amount);
var placeBetGameActionId = round.Place(
actionData.Amount,
actionData.Description,
walletTransactionId,
actionData.ExternalTransactionId,
actionData.ExternalBetId,
actionData.TransactionReferenceId);
_repository.Rounds.AddOrUpdate(x => x.ExternalRoundId, round.Data);
_repository.SaveChanges();
await _gameEventsProcessor.Process(round.Events, context.PlayerToken, round.Data.BrandCode, actionData, context.GameProviderCode);
scope.Complete();
return(placeBetGameActionId);
}
}
async Task <Guid> IGameCommands.AdjustTransaction([NotNull] GameActionData actionData, [NotNull] GameActionContext context)
{
var gameProviderId = await ValidateGameProviderAsync(context.GameProviderCode);
ValidateTransactionIsUnique(actionData.ExternalTransactionId, gameProviderId);
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var round = GetRound(actionData);
var gameActionToAdjust = round.GetGameActionByReferenceId(actionData.TransactionReferenceId);
if (gameActionToAdjust == null)
{
throw new GameActionNotFoundException();
}
var walletTransactionId = _walletOperations.AdjustBetTransaction(round.Data.PlayerId, round.Data.GameId,
gameActionToAdjust.Id, actionData.Amount);
var adjustmentGameActionId = AdjustRound(round, actionData, walletTransactionId);
_repository.SaveChanges();
await _gameEventsProcessor.Process(round.Events, context.PlayerToken, round.Data.BrandCode, actionData, context.GameProviderCode);
scope.Complete();
return(adjustmentGameActionId);
}
}
public Guid Adjust(GameActionData gameActionData, GameActionContext context)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
return(GenerateGameAction <BetAdjusted>(GameActionType.Adjustment, gameActionData, context));
}
private Guid GenerateGameAction <TEvent>(GameActionType gameActionType, GameActionData gameActionData, GameActionContext context)
where
TEvent : GameActionEventBase, new()
{
if (gameActionData.ExternalTransactionId == null)
{
throw new ArgumentNullException("externalTransactionId");
}
var gameActionId = Guid.NewGuid();
var amount = gameActionData.Amount;
if (gameActionType == GameActionType.Placed)
{
amount = -amount;
}
Data.GameActions.Add(new GameAction
{
Id = gameActionId,
ExternalTransactionId = gameActionData.ExternalTransactionId,
ExternalBetId = gameActionData.ExternalBetId,
ExternalTransactionReferenceId = gameActionData.TransactionReferenceId,
Round = Data,
GameActionType = gameActionType,
Amount = amount,
Description = gameActionData.Description,
WalletTransactionId = gameActionData.WalletTransactionId,
Timestamp = DateTimeOffset.UtcNow.ToBrandOffset(Data.Brand.TimezoneId),
Context = context
});
var relatedGameAction = GetGameActionByReferenceId(gameActionData.TransactionReferenceId);
Events.Add(new TEvent
{
Amount = gameActionData.Amount,
GameActionId = gameActionId,
BrandId = Data.BrandId,
GameId = Data.GameId,
PlayerId = Data.PlayerId,
RoundId = Data.Id,
Turnover = context.TurnoverContribution,
Ggr = context.GgrContribution,
UnsettledBets = context.UnsettledBetsContribution,
RelatedGameActionId = relatedGameAction == null? (Guid?)null : relatedGameAction.Id,
CreatedOn = DateTimeOffset.UtcNow.ToBrandOffset(Data.Brand.TimezoneId)
});
return(gameActionId);
}
public Guid Cancel(GameActionData gameActionData, GameActionContext context)
{
ValidateAsSecondaryAction(gameActionData.TransactionReferenceId);
return(GenerateGameAction <BetCancelled>(GameActionType.Cancel, gameActionData, context));
}
