private void ValidateInfo(IBonusRepository repository)
{
RuleFor(template => template.Info.Name)
.NotEmpty()
.WithMessage(ValidatorMessages.NameIsNotSpecified)
.Matches(@"^[a-zA-Z0-9_\-\s]*$")
.WithMessage(ValidatorMessages.TemplateNameIsInvalid)
.Length(1, 50)
.WithMessage(ValidatorMessages.NameLengthIsInvalid, 1, 50)
.Must((template, name) =>
{
var templates = repository.Templates.Where(t => t.Info.Name == name && t.Status != TemplateStatus.Deleted);
if (template.Info.BrandId.HasValue)
{
var brand = repository.Brands.SingleOrDefault(p => p.Id == template.Info.BrandId.Value);
if (brand != null)
{
templates = templates.Where(t => t.Info.Brand.Id == brand.Id);
}
}
if (template.Id != Guid.Empty)
{
templates = templates.Where(t => t.Id != template.Id);
}
return(templates.Any() == false);
})
.WithMessage(ValidatorMessages.NameIsNotUnique);
RuleFor(template => template.Info.Description)
.Length(1, 200)
.WithMessage(ValidatorMessages.DescriptionLengthIsInvalid, 1, 200)
.When(template => string.IsNullOrWhiteSpace(template.Info.Description) == false);
RuleFor(template => template.Info.BrandId)
.Must((template, guid) => _brandGetter(template) != null)
.WithMessage(ValidatorMessages.TemplateBrandDoesNotExist);
RuleFor(template => template.Info.WalletTemplateId)
.NotEmpty()
.WithMessage(ValidatorMessages.TemplateReceivingWalletIsNotSpecified)
.Must((template, walletId) => _brandGetter(template).WalletTemplates.Select(c => c.Id).Contains(walletId))
.WithMessage(ValidatorMessages.TemplateReceivingWalletIsInvalid)
.When(template => _brandGetter(template) != null, ApplyConditionTo.CurrentValidator);
RuleFor(template => template.Info.Mode)
.Must((template, mode) =>
{
if (new[]
{
BonusType.FirstDeposit, BonusType.ReloadDeposit, BonusType.FundIn
}.Contains(template.Info.TemplateType))
{
return(true);
}
return(mode != IssuanceMode.AutomaticWithCode);
})
.WithMessage(ValidatorMessages.TemplateModeIsIncorrect);
}
public TemplateValidator(IBonusRepository repository, BonusQueries queries)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
_infoGetter = template => repository.Templates.Single(t => t.Id == template.Id && t.Version == template.Version).Info;
_brandGetter = template => template.Info == null?_infoGetter(template).Brand : repository.Brands.SingleOrDefault(b => b.Id == template.Info.BrandId);
When(template => template.Id != Guid.Empty, () =>
{
Func <CreateUpdateTemplate, Template> templateGetter =
vm => queries.GetCurrentVersionTemplates().SingleOrDefault(t => t.Id == vm.Id);
RuleFor(template => template)
.Must(template => templateGetter(template) != null)
.WithMessage(ValidatorMessages.TemplateDoesNotExist)
.Must(template => templateGetter(template).Version == template.Version)
.WithMessage(ValidatorMessages.TemplateVersionIsNotCurrent)
.Must(template => queries.GetBonusesUsingTemplate(templateGetter(template)).Any(bonus => bonus.IsActive) == false)
.WithMessage(ValidatorMessages.AllBonusesShouldBeInactive)
.When(template => templateGetter(template).Status == TemplateStatus.Complete, ApplyConditionTo.CurrentValidator)
.WithName("Template")
.DependentRules(rules =>
{
When(template => template.Availability != null, () => ValidateAvailability(repository));
When(template => template.Rules != null, ValidateRules);
When(template => template.Wagering != null, () => ValidateWagering(repository));
});
});
When(template => template.Info != null, () => ValidateInfo(repository));
}
public CompaniesController(ICompanyRepository compRepo, IEmployeeRepository empRepo, IBonusRepository bonRepo, IDapperSprocRepo dapperRepo)
{
_compRepo = compRepo;
_dapperRepo = dapperRepo;
_empRepo = empRepo;
_bonRepo = bonRepo;
}
public BonusesController(IEmployeeInfoRepository e, IBonusTypeRepository a, IBonusRepository s, IHttpContextAccessor f)
{
this.bonusTypeRepository = a;
this.employeeInfoRepository = e;
this.bonusRepository = s;
this.httpContextAccessor = f;
}
public CompanyDetailsViewModel(IRenavigator navigateBackToCompanyView, IBonusRepository bonusRepo)
{
_employees = new ObservableCollection <Employee>();
_bonusRepo = bonusRepo;
BackToListCommand = new BackToCompanyListCommand(this, navigateBackToCompanyView);
}
public BonusService(IBonusRepository bonusRepository, IMapper mapper, IVendorService vendorService, IHistoryRepository historyRepository)
{
_bonusRepository = bonusRepository;
_mapper = mapper;
_vendorService = vendorService;
_historyRepository = historyRepository;
}
public HomeViewModel(IBonusRepository bonusRepo)
{
_bonusRepo = bonusRepo;
_companies = new ObservableCollection <Company>();
GetCompanies();
}
public MainWindow()
{
InitializeComponent();
_bonusRepository = new BonusRepository(App.BonusFactory);
_setRepository = new SetRepository(App.SetFactory);
_musicPath = _setRepository.GetOne().Music;
_mediaPlayer = new MediaPlayer();
}
public RemunerationController(IBonusRepository bonusRepository)
{
if (bonusRepository == null)
{
throw new ArgumentNullException("bonusRepository");
}
_bonusRepository = bonusRepository;
}
public EmployeesController(
ICompanyRepository compRepo,
IEmployeeRepository empRepo,
IBonusRepository bonRepo)
{
this._compRepo = compRepo;
this._empRepo = empRepo;
this._bonRepo = bonRepo;
}
public HistoryService(IHistoryRepository historyRepository,
IBonusRepository bonusRepository,
IEmailService emailService,
IMapper mapper)
{
_historyRepository = historyRepository;
_bonusRepository = bonusRepository;
_emailService = emailService;
_mapper = mapper;
}
public FirstDepositApplicationValidator(IBonusRepository repository)
{
RuleFor(m => m)
.Must(m => repository.Players.Any(p => p.Id == m.PlayerId))
.WithMessage(ValidatorMessages.PlayerDoesNotExist)
.DependentRules(rules =>
{
rules.RuleFor(m => m)
.Must(m =>
{
var bonus = repository.GetLockedBonusOrNull(m.BonusCode);
if (bonus != null)
{
if (bonus.Data.Template.Info.TemplateType != BonusType.FirstDeposit &&
bonus.Data.Template.Info.Mode != IssuanceMode.AutomaticWithCode &&
bonus.Data.Template.Info.Mode != IssuanceMode.ManualByPlayer)
{
return(false);
}
return(true);
}
return(false);
})
.WithMessage(ValidatorMessages.BonusDoesNotExist)
.WithName("BonusCode")
.DependentRules(dependentRules =>
{
string error = null;
dependentRules.RuleFor(m => m)
.Must(m =>
{
var bonus = repository.GetLockedBonusOrNull(m.BonusCode);
var player = repository.GetLockedPlayer(m.PlayerId);
var errors = bonus.QualifyFor(player, QualificationPhase.Redemption,
new RedemptionParams {
TransferAmount = m.DepositAmount
}).ToArray();
if (errors.Any())
{
error = errors.First();
return(false);
}
return(true);
})
.WithMessage("{0}", application => error)
.WithName("BonusCode");
});
});
}
public BonusCommands(
IBonusRepository repository,
BonusQueries bonusQueries,
IEventBus eventBus,
IBrandOperations brandOperations,
IServiceBus serviceBus)
{
_repository = repository;
_bonusQueries = bonusQueries;
_eventBus = eventBus;
_brandOperations = brandOperations;
_serviceBus = serviceBus;
}
public BonusManagementCommands(
IBonusRepository repository,
BonusQueries bonusQueries,
IActorInfoProvider actorInfoProvider,
IEventBus eventBus,
BonusMapper bonusMapper)
{
_repository = repository;
_bonusQueries = bonusQueries;
_actorInfoProvider = actorInfoProvider;
_eventBus = eventBus;
_bonusMapper = bonusMapper;
}
private void HandleNegativeTurnover(GameActionEventBase @event, IBonusRepository repository, Transaction transaction)
{
var eventBus = _container.Resolve <IEventBus>();
var player = repository.GetLockedPlayer(@event.PlayerId);
var bonusRedemptions = player.GetRedemptionsWithActiveRollover()
.Where(br => br.Data.Contributions.Select(c => c.Transaction.Id).Contains(transaction.RelatedTransactionId.Value));
foreach (var bonusRedemption in bonusRedemptions)
{
bonusRedemption.FulfillRollover(@event.Turnover, transaction);
bonusRedemption.Events.ForEach(eventBus.Publish);
}
}
private void ValidateAvailability(IBonusRepository repository)
{
RuleFor(template => template.Availability.RedemptionsLimit)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.TemplatePlayerRedemptionLimitIsNegative);
RuleFor(template => template.Availability.ParentBonusId)
.Must(id => repository.Bonuses.Any(a => a.Id == id))
.WithMessage(ValidatorMessages.TemplateParentBonusDoesNotExist)
.When(bonus => bonus.Availability.ParentBonusId.HasValue);
RuleFor(template => template.Availability.PlayerRegistrationDateTo)
.Must((template, registrationDateTo) => registrationDateTo >= template.Availability.PlayerRegistrationDateFrom)
.WithMessage(ValidatorMessages.TemplatePlayerRegistrationDateRangeIsInvalid)
.When(template => template.Availability.PlayerRegistrationDateFrom.HasValue &&
template.Availability.PlayerRegistrationDateTo.HasValue);
RuleFor(template => template.Availability.WithinRegistrationDays)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.TemplateWithinRegistrationDaysIsNegative);
RuleFor(template => template.Availability.ExcludeBonuses)
.Must((template, excludes) => excludes.Contains(template.Availability.ParentBonusId.Value) == false)
.WithMessage(ValidatorMessages.TemplateBonusExcludesContainsParentBonus)
.When(template => template.Availability.ParentBonusId.HasValue);
RuleFor(template => template.Availability.PlayerRedemptionsLimit)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.TemplatePlayerRedemptionsIsNegative);
RuleFor(template => template.Availability.VipLevels)
.Must((template, vips) =>
{
var brandVips = _brandGetter(template).Vips.Select(v => v.Code);
return(vips.All(brandVips.Contains));
})
.WithMessage(ValidatorMessages.TemplateVipsAreInvalid);
RuleFor(template => template.Availability.ExcludeRiskLevels)
.Must((template, riskLevels) =>
{
var rls = _brandGetter(template).RiskLevels.Select(x => x.Id);
return(riskLevels.All(rls.Contains));
})
.WithMessage(ValidatorMessages.TemplateRiskLevelsAreInvalid);
}
private void HandlePositiveTurnover(GameActionEventBase @event, IBonusRepository repository, Wallet wallet, Transaction transaction)
{
var eventBus = _container.Resolve <IEventBus>();
var bonusCommands = _container.Resolve <BonusCommands>();
var player = repository.GetLockedPlayer(@event.PlayerId);
var redemptionsWithActiveRollover = player.GetRedemptionsWithActiveRollover(wallet.Data.Template.Id);
var turnoverLeftToDistribute = @event.Turnover;
foreach (var redemption in redemptionsWithActiveRollover)
{
var handledAmount = redemption.FulfillRollover(turnoverLeftToDistribute, transaction);
turnoverLeftToDistribute -= handledAmount;
if (redemption.RolloverLeft == 0m)
{
redemption.CompleteRollover();
bonusCommands.WageringFulfilled(redemption);
}
if (turnoverLeftToDistribute == 0m)
{
if (redemption.WageringThresholdIsMet(wallet.TotalBalance) &&
// Check if rollover is still Active, 'cos it can become Completed several lines before
redemption.Data.RolloverState == RolloverStatus.Active)
{
redemption.ZeroOutRollover(transaction);
bonusCommands.WageringFulfilled(redemption);
}
redemption.Events.ForEach(eventBus.Publish);
break;
}
redemption.Events.ForEach(eventBus.Publish);
}
player.Data.AccumulatedWageringAmount += @event.Turnover;
if (player.CompletedReferralRequirements())
{
var referrer = repository.GetLockedPlayer(player.Data.ReferredBy.Value);
bonusCommands.ProcessFirstBonusRedemptionOfType(referrer, BonusType.ReferFriend);
player.CompleteReferralRequirements();
}
}
public ClaimBonusValidator(IBonusRepository repository)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
Func <Guid, Player> playerGetter = playerId => repository.Players.SingleOrDefault(b => b.Id == playerId);
Func <Guid, Guid, BonusRedemption> redemptionGetter = (playerId, bonusRedemptionId) =>
repository.Players.Single(b => b.Id == playerId).Wallets.SelectMany(w => w.BonusesRedeemed)
.SingleOrDefault(br => br.Id == bonusRedemptionId);
RuleFor(model => model)
.Must(model => playerGetter(model.PlayerId) != null)
.WithMessage(ValidatorMessages.PlayerDoesNotExist)
.Must(model => redemptionGetter(model.PlayerId, model.RedemptionId) != null)
.WithMessage(ValidatorMessages.BonusRedemptionDoesNotExist)
.Must(model => redemptionGetter(model.PlayerId, model.RedemptionId).ActivationState == ActivationStatus.Claimable)
.WithMessage(ValidatorMessages.BonusRedemptionStatusIsIncorrectForClaim)
.WithName("Model");
}
private void ValidateWagering(IBonusRepository repository)
{
RuleFor(template => template.Wagering.Multiplier)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.TemplateWageringConditionIsNegative)
.GreaterThan(0)
.WithMessage(ValidatorMessages.TemplateWageringConditionIsZeroOrLess)
.When(template => template.Wagering.HasWagering, ApplyConditionTo.CurrentValidator);
RuleFor(template => template.Wagering.Threshold)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.TemplateWageringThresholdIsNegative);
RuleFor(template => template.Wagering.GameContributions)
.Must(contributions => contributions.All(c => c.Contribution >= 0))
.WithMessage(ValidatorMessages.TemplateOneOfGameContributionsIsNegative);
RuleFor(template => template.Wagering.GameContributions)
.Must(contributions =>
{
var gameIds = contributions.Select(c => c.GameId);
var dbGameIds = repository.Games.Select(g => g.Id);
return(gameIds.All(dbGameIds.Contains));
})
.WithMessage(ValidatorMessages.TemplateOneOfGameContributionsPointsToInvalidGame)
.When(template => template.Wagering.GameContributions.Any());
RuleFor(template => template.Wagering.Method)
.Must(method => method == WageringMethod.Bonus)
.WithMessage(ValidatorMessages.TemplateWageringMethodIsNotSupportedByBonusTrigger)
.When(template =>
{
var info = _infoGetter(template);
return(info.TemplateType == BonusType.ReferFriend ||
info.TemplateType == BonusType.MobilePlusEmailVerification ||
info.TemplateType == BonusType.HighDeposit);
});
RuleFor(template => template.Wagering.IsAfterWager)
.Must(isAfterWager => isAfterWager == false)
.WithMessage(ValidatorMessages.TemplateWageringIsAfterWagerIsNotApplicable)
.When(template => template.Wagering.HasWagering == false);
}
public EmployeesViewModel(
UpsertEmployeeViewModel upsertEmployeeViewModel,
IEmployeeRepository empRepo,
IBonusRepository bonusRepo,
INavigator navigator,
IDialogService dialogService)
{
_empRepo = empRepo;
_bonusRepo = bonusRepo;
_employees = new ObservableCollection <Employee>();
_dialogService = dialogService;
DeleteEmployeeCommand = new ActionCommand(this, p => DeleteCompany(), o => IsItemSelected);
GetCompanies();
NavigateToAddEmployeeCommand = new NavigateToAddEmployeeCommand(this, upsertEmployeeViewModel, navigator);
NavigateToUpsertEmployeeCommand = new NavigateToUpsertEmployeeCommand(this, upsertEmployeeViewModel, navigator);
}
private void ValidateName(IBonusRepository repository)
{
RuleFor(bonus => bonus.Name)
.NotEmpty()
.WithMessage(ValidatorMessages.NameIsNotSpecified);
When(bonus => string.IsNullOrWhiteSpace(bonus.Name) == false, () => RuleFor(bonus => bonus.Name)
.Matches(@"^[a-zA-Z0-9_\-\s]*$")
.WithMessage(ValidatorMessages.BonusNameIsInvalid)
.Length(1, 50)
.WithMessage(ValidatorMessages.NameLengthIsInvalid, 1, 50)
.Must((bonus, name) =>
{
if (bonus.Id == Guid.Empty)
{
return(repository.Bonuses.Any(b => b.Name == name) == false);
}
return(repository.Bonuses.Any(b => b.Name == name && b.Id != bonus.Id) == false);
})
.WithMessage(ValidatorMessages.NameIsNotUnique));
}
public BonusesController(IBonusRepository bonusRepository, LinkGenerator linkGenerator)
{
_bonusRepository = bonusRepository;
_linkGenerator = linkGenerator;
}
public HomeController(ILogger <HomeController> logger, IBonusRepository bonRepo)
{
_logger = logger;
_bonRepo = bonRepo;
}
public BonusMapper(BonusQueries bonusQueries, IBonusRepository bonusRepository)
{
_bonusQueries = bonusQueries;
_bonusRepository = bonusRepository;
}
public EmployeesController(IEmployeeRepository employeeRepository, ICompanyRepository companyRepository, IBonusRepository bonusRepository)
{
_employeeRepository = employeeRepository;
_companyRepository = companyRepository;
_bonusRepository = bonusRepository;
}
public BonusValidator(IBonusRepository repository, BonusQueries bonusQueries)
{
Func <Guid, Template> templateGetter = templateId => bonusQueries.GetCurrentVersionTemplates().SingleOrDefault(a => a.Id == templateId);
When(bonus => bonus.Id != Guid.Empty, () =>
{
Func <CreateUpdateBonus, IQueryable <Data.Bonus> > bonuses = bonusVm => repository.Bonuses.Where(b => b.Id == bonusVm.Id);
RuleFor(bonus => bonus)
.Must(bonus => bonuses(bonus).Any())
.WithMessage(ValidatorMessages.BonusDoesNotExist)
.WithName("Bonus");
RuleFor(bonus => bonus)
.Must(bonus => bonus.Version == bonuses(bonus).Max(b => b.Version))
.WithMessage(ValidatorMessages.BonusVersionIsNotCurrent)
.WithName("Bonus")
.When(bonus => bonuses(bonus).Any());
});
ValidateName(repository);
RuleFor(bonus => bonus.Description)
.NotNull()
.WithMessage(ValidatorMessages.DescriptionIsRequired)
.Length(1, 200)
.WithMessage(ValidatorMessages.DescriptionLengthIsInvalid, 1, 200);
RuleFor(bonus => bonus.DaysToClaim)
.GreaterThanOrEqualTo(0)
.WithMessage(ValidatorMessages.BonusDaysToClaimIsNegative);
RuleFor(bonus => bonus.TemplateId)
.Must(templateId => templateGetter(templateId) != null)
.WithMessage(ValidatorMessages.BonusTemplateIsNotAssigned);
When(b => templateGetter(b.TemplateId) != null, () =>
{
RuleFor(bonus => bonus.Code)
.NotEmpty()
.When(bonus => templateGetter(bonus.TemplateId).Info.Mode == IssuanceMode.AutomaticWithCode)
.WithMessage(ValidatorMessages.BonusCodeIsNotSpecified);
When(bonus => string.IsNullOrWhiteSpace(bonus.Code) == false, () => RuleFor(bonus => bonus.Code)
.Matches(@"^[a-zA-Z0-9]*$")
.WithMessage(ValidatorMessages.BonusCodeIsInvalid)
.Length(1, 20)
.WithMessage(ValidatorMessages.BonusCodeLengthIsInvalid, 1, 20)
.Must((bonus, code) =>
{
if (bonus.Id == Guid.Empty)
{
return(bonusQueries.GetCurrentVersionBonuses().Any(b => b.Code == code) == false);
}
return(bonusQueries.GetCurrentVersionBonuses().Any(b => b.Code == code && b.Id != bonus.Id) == false);
})
.WithMessage(ValidatorMessages.BonusCodeIsNotUnique));
RuleFor(bonus => bonus.ActiveTo)
.Must((bonus, activeTo) => activeTo > bonus.ActiveFrom)
.WithMessage(ValidatorMessages.BonusActivityRangeIsInvalid)
.Must((bonus, activeTo) =>
{
var template = templateGetter(bonus.TemplateId);
var timezoneId = template.Info.Brand.TimezoneId;
return(activeTo.ToBrandDateTimeOffset(timezoneId) >
DateTimeOffset.Now.ToBrandOffset(timezoneId));
})
.WithMessage(ValidatorMessages.BonusActiveToIsInvalid);
ValidateDuration();
});
}
public IssueByCsValidator(BonusQueries queries, IBonusRepository repository, IBrandOperations brandOperations)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
Func <Guid, Data.Bonus> bonusGetter = bonusId => queries.GetCurrentVersionBonuses().SingleOrDefault(b => b.Id == bonusId);
Func <Guid, Player> playerGetter = playerId => repository.Players.SingleOrDefault(b => b.Id == playerId);
Func <Guid, Guid, Transaction> transactionGetter = (playerId, transactionId) =>
playerGetter(playerId).Wallets.SelectMany(w => w.Transactions).SingleOrDefault(t => t.Id == transactionId);
RuleFor(model => model.BonusId)
.Must(id => bonusGetter(id) != null)
.WithMessage(ValidatorMessages.BonusDoesNotExist);
RuleFor(model => model.PlayerId)
.Must(id => playerGetter(id) != null)
.WithMessage(ValidatorMessages.PlayerDoesNotExist);
When(model => playerGetter(model.PlayerId) != null && bonusGetter(model.BonusId) != null, () =>
{
RuleFor(model => model.TransactionId)
.Must((model, transactionId) => transactionGetter(model.PlayerId, transactionId) != null)
.WithMessage(ValidatorMessages.TransactionDoesNotExist);
When(model => transactionGetter(model.PlayerId, model.TransactionId) != null, () => RuleFor(model => model.TransactionId)
.Must((model, transactionId) =>
{
var transaction = transactionGetter(model.PlayerId, transactionId);
var bonus = bonusGetter(model.BonusId);
if (bonus.Template.Info.TemplateType == BonusType.FundIn)
{
return(transaction.Type == TransactionType.FundIn);
}
if (bonus.Template.Info.TemplateType == BonusType.FirstDeposit || bonus.Template.Info.TemplateType == BonusType.ReloadDeposit)
{
return(transaction.Type == TransactionType.Deposit);
}
return(true);
})
.WithMessage(ValidatorMessages.TransactionTypeDoesNotMatchBonusType)
.Must((model, transactionId) =>
{
var qualifiedBonuses = queries.GetManualByCsQualifiedBonuses(model.PlayerId);
var theQualifedBonus = qualifiedBonuses.SingleOrDefault(b => b.Id == model.BonusId);
if (theQualifedBonus == null)
{
return(false);
}
var qualifiedTransactions = queries.GetManualByCsQualifiedTransactions(model.PlayerId, model.BonusId);
if (qualifiedTransactions.Select(tr => tr.Id).Contains(model.TransactionId) == false)
{
return(false);
}
return(true);
})
.WithMessage(ValidatorMessages.PlayerIsNotQualifiedForBonus)
.Must((model, transactionId) =>
{
var bonus = bonusGetter(model.BonusId);
if (bonus.Template.Wagering.HasWagering == false)
{
return(true);
}
var bonusWallet = playerGetter(model.PlayerId).Wallets.Single(w => w.Transactions.Select(t => t.Id).Contains(transactionId));
var transaction = transactionGetter(model.PlayerId, transactionId);
return(bonusWallet.Main >= transaction.TotalAmount);
})
.WithMessage(ValidatorMessages.PlayerHasNoFundsToLockLeft)
.Must((model, transactionId) =>
{
var bonus = bonusGetter(model.BonusId);
if (bonus.Template.Wagering.HasWagering == false)
{
return(true);
}
var player = playerGetter(model.PlayerId);
var balance = brandOperations.GetPlayerBalance(model.PlayerId, player.CurrencyCode);
return(balance >= bonus.Template.Wagering.Threshold);
})
.WithMessage(ValidatorMessages.PlayerBalanceIsLessThanWageringThreshold));
});
}
public BonusService(IBonusRepository bonusRepository, IMapper mapper, IVendorService vendorService)
{
_bonusRepository = bonusRepository;
_mapper = mapper;
_vendorService = vendorService;
}
public BonusService(IMapper mapper, IBonusRepository bonusRepository) : base(mapper)
{
_bonusRepository = bonusRepository;
}
public BonusesController(IEmployeeInfoRepository e, IBonusTypeRepository a, IBonusRepository s)
{
this.bonusTypeRepository = a;
this.employeeInfoRepository = e;
this.bonusRepository = s;
}
