public void Handle(DepositSubmitted @event)
{
var bonusCommands = _container.Resolve <BonusCommands>();
var bonusQueries = _container.Resolve <BonusQueries>();
var bus = _container.Resolve <IEventBus>();
var bonusRepository = _container.Resolve <IBonusRepository>();
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var player = bonusRepository.GetLockedPlayer(@event.PlayerId);
var redemptionParams = new RedemptionParams
{
TransferAmount = @event.Amount,
TransferExternalId = @event.DepositId,
TransferWalletTemplateId = player.Data.Brand.WalletTemplates.Single(wt => wt.IsMain).Id
};
bonusQueries
.GetQualifiedAutomaticBonusIds(@event.PlayerId, player.DepositQuailifiedBonusType, redemptionParams)
.ForEach(bonusId =>
{
var redemption = bonusCommands.RedeemBonus(@event.PlayerId, bonusId, redemptionParams);
redemption.Events.ForEach(bus.Publish);
});
scope.Complete();
}
}
public Guid ApplyForBonus(DepositBonusApplication model)
{
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var validationResult = _bonusQueries.GetValidationResult(model);
if (validationResult.IsValid == false)
{
throw new RegoException(validationResult.Errors.First().ErrorMessage);
}
var player = _repository.GetLockedPlayer(model.PlayerId);
var redemptionParams = new RedemptionParams
{
TransferAmount = model.Amount,
TransferExternalId = model.DepositId,
TransferWalletTemplateId = player.Data.Brand.WalletTemplates.Single(wt => wt.IsMain).Id
};
var bonusId = model.BonusId ?? _repository.GetLockedBonus(model.BonusCode).Data.Id;
var redemption = RedeemBonus(model.PlayerId, bonusId, redemptionParams);
redemption.Events.ForEach(_eventBus.Publish);
scope.Complete();
return(redemption.Data.Id);
}
}
private decimal CalculateBonusAmount(Player player, RedemptionParams redemptionParams)
{
if (Data.Template.Info.TemplateType == BonusType.HighDeposit)
{
return(CalculateHighDepositBonusReward(player));
}
var affectedValue = GetTierAffectedAmount(player, redemptionParams);
var reward = 0m;
var matchingRewardTier = Data.Template.Rules.RewardTiers.Single(t => t.CurrencyCode == player.Data.CurrencyCode);
var matchingTier = GetMatchingBonusTierOrNull(matchingRewardTier, affectedValue) as BonusTier;
if (matchingTier != null)
{
if (Data.Template.Rules.RewardType == BonusRewardType.TieredAmount || Data.Template.Rules.RewardType == BonusRewardType.Amount)
{
reward = matchingTier.Reward;
}
else
{
reward = affectedValue * matchingTier.Reward;
reward = LimitRewardByTransactionLimit(reward, matchingTier.MaxAmount);
}
}
return(reward);
}
public void IssueBonusByCs(IssueBonusByCs model)
{
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var validationResult = _bonusQueries.GetValidationResult(model);
if (validationResult.IsValid == false)
{
throw new RegoException(validationResult.Errors.First().ErrorMessage);
}
var transaction =
_repository.Players.Single(p => p.Id == model.PlayerId)
.Wallets.SelectMany(w => w.Transactions)
.Single(t => t.Id == model.TransactionId);
var redemptionParams = new RedemptionParams
{
IsIssuedByCs = true,
TransferAmount = transaction.TotalAmount
};
var redemption = RedeemBonus(model.PlayerId, model.BonusId, redemptionParams);
ProcessBonusRedemptionLifecycle(redemption);
_repository.SaveChanges();
redemption.Events.ForEach(_eventBus.Publish);
scope.Complete();
}
}
public decimal CalculateReward(Player player, RedemptionParams redemptionParams)
{
var reward = CalculateBonusAmount(player, redemptionParams);
var cappedBonus = LimitRewardByBonusRewardAmountLimit(reward, player);
return(cappedBonus);
}
internal void ActivateFundInBonus(Guid playerId, Guid bonusId, RedemptionParams redemptionParams)
{
var redemption = RedeemBonus(playerId, bonusId, redemptionParams);
ProcessBonusRedemptionLifecycle(redemption);
_repository.SaveChanges();
redemption.Events.ForEach(_eventBus.Publish);
}
internal Data.Bonus[] GetQualifiedBonuses(Player player, BonusType type, RedemptionParams redemptionParams = null)
{
redemptionParams = redemptionParams ?? new RedemptionParams();
return(GetCurrentVersionBonuses(player.Data.Brand.Id)
.Where(x => x.Template.Info.TemplateType == type)
.ToList()
.Select(x => new Entities.Bonus(x))
.Where(bonus => bonus.QualifiesFor(player, QualificationPhase.Redemption, redemptionParams))
.Select(x => x.Data)
.ToArray());
}
internal Entities.BonusRedemption RedeemBonus(Guid playerId, Guid bonusId, RedemptionParams redemptionParams = null)
{
var bonus = _repository.GetLockedBonus(bonusId);
var player = _repository.GetLockedPlayer(playerId);
var redemption = player.Redeem(bonus, redemptionParams);
_repository.SaveChanges();
return(redemption);
}
public BonusRedemption Redeem(Bonus bonus, RedemptionParams redemptionParams)
{
var redemption = new BonusRedemption(this, bonus, redemptionParams);
Data
.Wallets
.Single(w => w.Template.Id == bonus.Data.Template.Info.WalletTemplateId)
.BonusesRedeemed
.Add(redemption.Data);
return(redemption);
}
private decimal GetTierAffectedAmount(Player player, RedemptionParams redemptionParams)
{
if (Data.Template.Info.TemplateType == BonusType.ReferFriend)
{
var referralCount = player.BonusesRedeemed.Count(r =>
r.Bonus.Id == Data.Id &&
r.Bonus.Template.Info.TemplateType == BonusType.ReferFriend &&
r.ActivationState == ActivationStatus.Activated);
return(referralCount + 1);
}
return(redemptionParams.TransferAmount);
}
public void ApplyForBonus(FundInBonusApplication model)
{
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var validationResult = _bonusQueries.GetValidationResult(model);
if (validationResult.IsValid == false)
{
throw new RegoException(validationResult.Errors.First().ErrorMessage);
}
var redemptionParams = new RedemptionParams {
TransferAmount = model.Amount, TransferWalletTemplateId = model.DestinationWalletTemplateId
};
var bonusId = model.BonusId ?? _repository.GetLockedBonus(model.BonusCode).Data.Id;
ActivateFundInBonus(model.PlayerId, bonusId, redemptionParams);
scope.Complete();
}
}
public BonusRedemption(Player player, Bonus bonus, RedemptionParams redemptionParams)
{
var bonusReward = bonus.CalculateReward(player, redemptionParams);
Data = new Data.BonusRedemption
{
Amount = bonusReward,
Player = player.Data,
Bonus = bonus.Data,
CreatedOn = SystemTime.Now.ToBrandOffset(bonus.Data.Template.Info.Brand.TimezoneId)
};
if (redemptionParams != null)
{
Data.Parameters = redemptionParams;
}
bonus.Data.Statistic.TotalRedeemedAmount += bonusReward;
bonus.Data.Statistic.TotalRedemptionCount++;
Events = new List <IDomainEvent>();
var redeemedEvent = new BonusRedeemed
{
AggregateId = Data.Id,
BonusId = bonus.Data.Id,
PlayerId = player.Data.Id,
BonusName = bonus.Data.Name,
PlayerName = player.Data.Name,
Amount = bonusReward,
CurrencyCode = player.Data.CurrencyCode,
IssuedByCs = Data.Parameters.IsIssuedByCs
};
if (Data.Parameters.IsIssuedByCs == false)
{
redeemedEvent.EventCreatedBy = Data.Player.Name;
}
Events.Add(redeemedEvent);
}
public void Handle(TransferFundCreated @event)
{
if (@event.Type == TransferFundType.FundOut || @event.Status == TransferFundStatus.Rejected)
{
return;
}
var bonusCommands = _container.Resolve <BonusCommands>();
var bonusQueries = _container.Resolve <BonusQueries>();
var redemptionParams = new RedemptionParams {
TransferAmount = @event.Amount, TransferWalletTemplateId = @event.DestinationWalletStructureId
};
var repository = _container.Resolve <IBonusRepository>();
using (var scope = CustomTransactionScope.GetTransactionScope())
{
bonusQueries
.GetQualifiedAutomaticBonusIds(@event.PlayerId, BonusType.FundIn, redemptionParams)
.ForEach(bonusId => bonusCommands.ActivateFundInBonus(@event.PlayerId, bonusId, redemptionParams));
var wallet = repository.GetLockedWallet(@event.PlayerId);
if (@event.Amount > 0)
{
wallet.TransferFundCredit(@event.Amount);
}
else
{
wallet.TransferFundDebit(@event.Amount);
}
repository.SaveChanges();
scope.Complete();
}
}
public bool QualifiesFor(Player player, QualificationPhase phase, RedemptionParams redemptionParams)
{
return(QualifyFor(player, phase, redemptionParams).Any() == false);
}
public IEnumerable <string> QualifyFor(Player player, QualificationPhase phase, RedemptionParams redemptionParams)
{
var bonusType = Data.Template.Info.TemplateType;
if (bonusType == BonusType.FirstDeposit || bonusType == BonusType.ReloadDeposit ||
bonusType == BonusType.HighDeposit)
{
return(new DepositQualificationCriteria(this, redemptionParams.IsIssuedByCs).CheckForQualificationFailures(player, phase, redemptionParams.TransferAmount));
}
if (bonusType == BonusType.FundIn)
{
return(new FundInQualificationCriteria(this, redemptionParams.IsIssuedByCs).CheckForQualificationFailures(player, phase, redemptionParams));
}
if (bonusType == BonusType.MobilePlusEmailVerification)
{
return
(new MobileEmailVerificationQualificationCriteria(this, redemptionParams.IsIssuedByCs)
.CheckForQualificationFailures(player, phase));
}
return(new BaseQualificationCriteria(this, redemptionParams.IsIssuedByCs).CheckForQualificationFailures(player, phase));
}
internal Data.Bonus[] GetQualifiedBonuses(Guid playerId, BonusType type, RedemptionParams redemptionParams = null)
{
var player = _repository.GetLockedPlayer(playerId);
return(GetQualifiedBonuses(player, type, redemptionParams));
}
internal List <Guid> GetQualifiedAutomaticBonusIds(Guid playerId, BonusType type, RedemptionParams redemptionParams)
{
var bonuses = GetQualifiedBonuses(playerId, type, redemptionParams)
.Where(b => b.Template.Info.Mode == IssuanceMode.Automatic);
return(bonuses
.Select(b => b.Id)
.ToList());
}
public IEnumerable <string> CheckForQualificationFailures(Player player, QualificationPhase phase, RedemptionParams redemptionParams)
{
foreach (var qualificationFailure in base.CheckForQualificationFailures(player, phase))
{
yield return(qualificationFailure);
}
if ((phase == QualificationPhase.PreRedemption && IsIssuedByCs == false) || phase == QualificationPhase.Redemption)
{
if (FundInWalletIsNotQualified(redemptionParams.TransferWalletTemplateId.Value))
{
yield return(QualificationReasons.FundInWalletIsNotQualifiedForThisBonus);
}
}
if (phase == QualificationPhase.Redemption || phase == QualificationPhase.Activation)
{
if (BonusTiersDoNotSatisfy(player.Data.CurrencyCode, redemptionParams.TransferAmount))
{
yield return(QualificationReasons.FundInAmountIsNotQualifiedForThisBonus);
}
}
}
