public void Bonus_issued_by_Cs_ignores_bonus_claim_duration_qualification()
{
MakeDeposit(PlayerId);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).First();
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
bonus.DaysToClaim = 1;
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
var bonusRedemption = BonusRedemptions.Single();
//expiring the bonus
bonus.ActiveTo = bonus.ActiveTo.AddDays(-2);
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public IssueBonusController(
BonusCommands bonusCommands,
BonusQueries bonusQueries)
{
_bonusCommands = bonusCommands;
_bonusQueries = bonusQueries;
}
public void Fundin_ManualByPlayer_bonus_rollover_is_calculated()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
var brandWalletId = bonus.Template.Info.Brand.WalletTemplates.First().Id;
bonus.Template.Info.TemplateType = BonusType.FundIn;
bonus.Template.Rules.FundInWallets = new List <BonusFundInWallet>
{
new BonusFundInWallet {
WalletId = brandWalletId
}
};
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Method = WageringMethod.TransferAmount;
bonus.Template.Wagering.Multiplier = 2;
//depositing funds to use them for fund in
MakeDeposit(PlayerId);
MakeFundIn(PlayerId, brandWalletId, 100, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.Rollover.Should().Be(200);
}
public void Can_issue_fundin_bonus()
{
var brandWalletId = BonusRepository.Brands.First().WalletTemplates.First().Id;
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByCs);
bonus.Template.Info.TemplateType = BonusType.FundIn;
bonus.Template.Rules.FundInWallets = new List <BonusFundInWallet>
{
new BonusFundInWallet {
WalletId = brandWalletId
}
};
MakeDeposit(PlayerId);
MakeFundIn(PlayerId, brandWalletId, 100);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).Single(t => t.Type == TransactionType.FundIn);
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
var bonusRedemption = BonusRedemptions.Single();
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public void RedemptionCanceled_is_saved_in_event_store()
{
_bonus.Template.Rules.RewardTiers.Single().BonusTiers.Single().Reward = 100;
_bonus.Template.Wagering.HasWagering = true;
_bonus.Template.Wagering.Multiplier = 3m;
MakeDeposit(PlayerId, 100);
var bonusRedemption = BonusRedemptions.Single();
PlaceAndWinBet(20, 40, PlayerId);
PlaceAndLoseBet(50, PlayerId);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
var theEvent = _eventRepository.Events.Single(e => e.DataType == typeof(RedemptionCanceled).Name);
var data = JsonConvert.DeserializeObject <RedemptionCanceled>(theEvent.Data);
data.AggregateId.Should().Be(bonusRedemption.Id);
data.MainBalanceAdjustment.Should().Be(40);
data.BonusBalanceAdjustment.Should().Be(-40);
data.NonTransferableAdjustment.Should().Be(-100);
data.UnlockedAmount.Should().Be(bonusRedemption.LockedAmount);
}
public Guid SubmitDeposit(Guid playerId, decimal depositAmount = 200, string bonusCode = null, Guid?bonusId = null)
{
var depositId = Guid.NewGuid();
ServiceBus.PublishMessage(new DepositSubmitted
{
DepositId = depositId,
PlayerId = playerId,
Amount = depositAmount
});
if (bonusId.HasValue || string.IsNullOrWhiteSpace(bonusCode) == false)
{
BonusCommands.ApplyForBonus(new DepositBonusApplication
{
PlayerId = playerId,
BonusId = bonusId,
BonusCode = bonusCode,
Amount = depositAmount,
DepositId = depositId
});
}
return(depositId);
}
public void MakeFundIn(Guid playerId, Guid destinationWalletStructureId, decimal amount, string bonusCode = null, Guid?bonusId = null)
{
if (bonusId.HasValue || string.IsNullOrWhiteSpace(bonusCode) == false)
{
BonusCommands.ApplyForBonus(new FundInBonusApplication
{
PlayerId = playerId,
BonusId = bonusId,
BonusCode = bonusCode,
Amount = amount,
DestinationWalletTemplateId = destinationWalletStructureId
});
}
ServiceBus.PublishMessage(new TransferFundCreated
{
PlayerId = playerId,
DestinationWalletStructureId = destinationWalletStructureId,
Amount = amount,
BonusCode = bonusCode,
Type = TransferFundType.FundIn,
Status = TransferFundStatus.Approved
});
// Here we need somehow create an event to mimic a wallet fund-in
}
public void Qualification_runs_before_rollover_is_issued_for_AfterWager_bonus()
{
MakeDeposit(PlayerId);
var excludedReloadedDeposit = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
excludedReloadedDeposit.Template.Info.TemplateType = BonusType.ReloadDeposit;
var reloadDepositWithExclude = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
reloadDepositWithExclude.Template.Info.TemplateType = BonusType.ReloadDeposit;
reloadDepositWithExclude.Template.Wagering.HasWagering = true;
reloadDepositWithExclude.Template.Wagering.IsAfterWager = true;
reloadDepositWithExclude.Template.Wagering.Multiplier = 1;
reloadDepositWithExclude.Template.Availability.ExcludeBonuses.Add(new BonusExclude {
ExcludedBonusId = excludedReloadedDeposit.Id
});
reloadDepositWithExclude.Template.Availability.ExcludeOperation = Operation.Any;
var depositId = Guid.NewGuid();
BonusCommands.ApplyForBonus(new DepositBonusApplication
{
PlayerId = PlayerId,
Amount = 200,
DepositId = depositId,
BonusCode = reloadDepositWithExclude.Code
});
MakeDeposit(PlayerId, 200, excludedReloadedDeposit.Code);
ApproveDeposit(depositId, PlayerId, 200);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Referer_can_claim_2_different_bonus_redemptions()
{
var bonus = CreateBonusWithReferFriendTiers();
bonus.Template.Info.Mode = IssuanceMode.ManualByPlayer;
CompleteReferAFriendRequirments(PlayerId);
bonus.IsActive = false;
var bonus2 = CreateBonusWithReferFriendTiers();
bonus2.Template.Info.Mode = IssuanceMode.ManualByPlayer;
CompleteReferAFriendRequirments(PlayerId);
bonus.IsActive = true;
var bonusPlayer = BonusRepository.GetLockedPlayer(PlayerId);
bonusPlayer.BonusesRedeemed.Count.Should().Be(2);
bonusPlayer.BonusesRedeemed.All(br => br.Amount == 10).Should().BeTrue();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusPlayer.BonusesRedeemed.ElementAt(0).Id
});
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusPlayer.BonusesRedeemed.ElementAt(1).Id
});
}
public BonusHistoryController(
BonusCommands bonusCommands,
BonusQueries bonusQueries,
IEventRepository eventRepository)
{
_bonusCommands = bonusCommands;
_bonusQueries = bonusQueries;
_eventRepository = eventRepository;
}
public void Bonus_cancellation_sets_rollover_status_to_None()
{
MakeDeposit(PlayerId);
var bonusRedemption = BonusRedemptions.First();
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
Assert.AreEqual(RolloverStatus.None, bonusRedemption.RolloverState);
}
public void Bonus_cancellation_sets_activation_status_to_Cancelled()
{
MakeDeposit(PlayerId);
var bonusRedemption = BonusRedemptions.First();
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
Assert.AreEqual(ActivationStatus.Canceled, bonusRedemption.ActivationState);
}
public void Bonus_cancellation_releases_bonus_lock()
{
MakeDeposit(PlayerId, 300);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
_wallet.Locks.Count(tr => tr.UnlockedOn.HasValue)
.Should()
.Be(2, "Unlock of deposit, bonus amount");
}
public void Player_should_activate_ManualByPlayer_mode_bonus_redemption()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
MakeDeposit(PlayerId, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public void Qualification_ignores_fraudulent_status_for_Manual_by_CS_issuance()
{
MakeDeposit(PlayerId);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).First();
var bonus = CreateFirstDepositBonus();
DisableBonusesForPlayer(PlayerId);
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
BonusRedemptions.Single().ActivationState.Should().Be(ActivationStatus.Activated);
}
public void Can_issue_first_deposit_bonus()
{
MakeDeposit(PlayerId);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).First();
var bonus = CreateFirstDepositBonus();
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
var bonusRedemption = BonusRedemptions.Single();
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public void Bonus_claim_by_fraudulent_player_negates_it()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
MakeDeposit(PlayerId, bonusId: bonus.Id);
DisableBonusesForPlayer(PlayerId);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Bonus_cancellation_creates_Cancellation_wagering_contribution_record()
{
MakeDeposit(PlayerId, 300);
var bonusRedemption = BonusRedemptions.First();
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
bonusRedemption.Contributions.SingleOrDefault(c => c.Type == ContributionType.Cancellation)
.Should()
.NotBeNull();
}
public void System_does_not_claim_ManualByPlayer_bonus_issued_by_CS()
{
MakeDeposit(PlayerId);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).First();
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
var bonusRedemption = BonusRedemptions.Single();
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Claimable);
}
public void Bonus_cancellation_discards_applied_bonus_statistics_changes()
{
MakeDeposit(PlayerId);
Assert.AreEqual(100, _bonus.Statistic.TotalRedeemedAmount);
Assert.AreEqual(1, _bonus.Statistic.TotalRedemptionCount);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
Assert.AreEqual(0, _bonus.Statistic.TotalRedeemedAmount);
Assert.AreEqual(0, _bonus.Statistic.TotalRedemptionCount);
}
public void Disqualification_is_processed_during_activation()
{
var depositId = Guid.NewGuid();
BonusCommands.ApplyForBonus(new DepositBonusApplication
{
PlayerId = PlayerId,
Amount = 200,
BonusCode = _bonus.Code,
DepositId = depositId
});
var bonusRedemption = BonusRedemptions.First();
MakeDeposit(PlayerId, bonusCode: _excludedBonus1.Code);
ApproveDeposit(depositId, PlayerId, 100);
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Can_claim_percentage_reward_type_bonus()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
bonus.Template.Rules.RewardType = BonusRewardType.Percentage;
bonus.Template.Rules.RewardTiers.Single().Tiers.Single().Reward = 0.5m;
MakeDeposit(PlayerId, 1000, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.Single();
Assert.DoesNotThrow(() => BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
}));
bonusRedemption.Amount.Should().Be(500);
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public void Deposit_ManualByPlayer_bonus_rollover_is_calculated()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Method = WageringMethod.TransferAmount;
bonus.Template.Wagering.Multiplier = 2;
MakeDeposit(PlayerId, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.Rollover.Should().Be(400);
}
public void Can_cancel_a_bonus_that_has_no_wagering_contributions()
{
MakeDeposit(PlayerId, 300);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
_wallet.Main.Should().Be(300);
_wallet.Bonus.Should().Be(0);
_wallet.NonTransferableBonus.Should().Be(0);
var transaction = _wallet.Transactions.SingleOrDefault(tr => tr.Type == TransactionType.BonusCancelled);
transaction.Should().NotBeNull();
transaction.MainBalanceAmount.Should().Be(0);
transaction.BonusBalanceAmount.Should().Be(0);
transaction.NonTransferableAmount.Should().Be(-100);
}
public void NotWithrawable_bonus_cancellation_decreases_NonTransferableBonus()
{
_bonus.Template.Rules.RewardTiers.Single().BonusTiers.Single().Reward = 100;
_bonus.Template.Info.IsWithdrawable = false;
_bonus.Template.Wagering.HasWagering = true;
_bonus.Template.Wagering.Multiplier = 3m;
MakeDeposit(PlayerId, 100);
PlaceAndWinBet(20, 40, PlayerId);
PlaceAndLoseBet(50, PlayerId);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
_bonusWallet.NonTransferableBonus.Should().Be(0);
}
public void Lock_is_released_from_correct_wallets_when_bonus_is_canceled()
{
var player = BonusRepository.Players.Single(p => p.Id == PlayerId);
var productWallet = player.Wallets.Single(a => a.Template.IsMain == false);
var bonus = CreateFirstDepositBonus();
bonus.Template.Info.TemplateType = BonusType.FundIn;
bonus.Template.Rules.FundInWallets = new List <BonusFundInWallet>
{
new BonusFundInWallet {
WalletId = productWallet.Template.Id
}
};
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Multiplier = 0.1m;
bonus.Template.Info.WalletTemplateId = _mainWallet.Template.Id;
MakeDeposit(PlayerId, 100);
MakeFundIn(PlayerId, productWallet.Template.Id, 100);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.Single().Id
};
BonusCommands.CancelBonusRedemption(model);
_mainWallet.BonusLock.Should().Be(0);
_mainWallet.Locks
.Single(tr => tr.Amount == 27)
.UnlockedOn
.Should()
.HaveValue();
productWallet.BonusLock.Should().Be(0);
productWallet.Locks
.Single(tr => tr.Amount == 100)
.UnlockedOn
.Should()
.HaveValue();
}
public void Claiming_bonus_outside_claim_duration_negates_it()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
bonus.DaysToClaim = 1;
MakeDeposit(PlayerId, bonusId: bonus.Id);
//expiring the bonus
bonus.ActiveTo = bonus.ActiveTo.AddDays(-3);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption
.ActivationState.Should()
.Be(ActivationStatus.Negated);
}
public void Before_wager_bonus_isnot_issued_before_wagering_requirement_is_fulfilled()
{
MakeDeposit(PlayerId);
var transaction = BonusRepository.Players.Single(p => p.Id == PlayerId).Wallets.SelectMany(t => t.Transactions).First();
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByCs);
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Multiplier = 2;
bonus.Template.Wagering.IsAfterWager = true;
BonusCommands.IssueBonusByCs(new IssueBonusByCs
{
BonusId = bonus.Id,
PlayerId = PlayerId,
TransactionId = transaction.Id
});
var bonusRedemption = BonusRedemptions.Single();
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Pending);
bonusRedemption.RolloverState.Should().Be(RolloverStatus.Active);
}
public void Rest_of_qualification_is_not_processed_during_claim()
{
MakeDeposit(PlayerId);
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
bonus.Template.Info.TemplateType = BonusType.ReloadDeposit;
MakeDeposit(PlayerId, bonusId: bonus.Id);
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
});
MakeDeposit(PlayerId, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.Last();
bonus.DurationType = DurationType.Custom;
bonus.DurationStart = SystemTime.Now.AddMinutes(5);
bonus.DurationEnd = SystemTime.Now.AddMinutes(10);
bonus.Template.Availability.ParentBonusId = Guid.NewGuid();
bonus.Template.Availability.VipLevels = new List <BonusVip> {
new BonusVip {
Code = "Bronze"
}
};
bonus.Template.Availability.PlayerRedemptionsLimit = 1;
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption
.ActivationState.Should()
.Be(ActivationStatus.Activated);
}
public void Bonus_cancellation_after_net_win()
{
MakeDeposit(PlayerId, 300);
PlaceAndWinBet(200, 300, PlayerId);
PlaceAndLoseBet(50, PlayerId);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
_wallet.Main.Should().Be(300);
_wallet.Bonus.Should().Be(0);
_wallet.NonTransferableBonus.Should().Be(0);
var transaction = _wallet.Transactions.SingleOrDefault(tr => tr.Type == TransactionType.BonusCancelled);
transaction.Should().NotBeNull();
transaction.MainBalanceAmount.Should().Be(250);
transaction.BonusBalanceAmount.Should().Be(-300);
transaction.NonTransferableAmount.Should().Be(-100);
}
