public ProductOperations(
IProductApiClientFactory productApiClientFactory,
IBrandOperations brandOperations,
IGameRepository gameRepository)
{
_productApiClientFactory = productApiClientFactory;
_brandOperations = brandOperations;
_gameRepository = gameRepository;
}
public WalletQueries(IPaymentQueries paymentQueries,
IBrandOperations brandOperations,
IBonusApiProxy bonusApiProxy
)
{
_paymentQueries = paymentQueries;
_brandOperations = brandOperations;
_bonusApiProxy = bonusApiProxy;
}
public BonusCommands(
IBonusRepository repository,
BonusQueries bonusQueries,
IEventBus eventBus,
IBrandOperations brandOperations,
IServiceBus serviceBus)
{
_repository = repository;
_bonusQueries = bonusQueries;
_eventBus = eventBus;
_brandOperations = brandOperations;
_serviceBus = serviceBus;
}
public override void BeforeEach()
{
base.BeforeEach();
_brandOperations = Container.Resolve <IBrandOperations>();
_gameRepository = Container.Resolve <IGameRepository>();
_onlineDepositCommands = Container.Resolve <IOnlineDepositCommands>();
_onlineDepositQueries = Container.Resolve <IOnlineDepositQueries>();
_playerQueries = Container.Resolve <PlayerQueries>();
_reportQueries = Container.Resolve <ReportQueries>();
_testPlayer = Container.Resolve <PlayerTestHelper>().CreatePlayer();
WaitForPlayerRegistered(_testPlayer.Id);
}
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 ApplicationSeeder(
IRepositoryBase repositoryBase,
IBrandRepository brandRepository,
ILicenseeCommands licenseeCommands,
ICurrencyCommands currencyCommands,
IBrandCommands brandCommands,
ICultureCommands cultureCommands,
IPlayerRepository playerRepository,
IBrandOperations walletCommands,
PlayerCommands playerCommands,
IAuthCommands authCommands,
IAuthRepository authRepository,
RoleService roleService,
ISecurityRepository securityRepository,
IBankCommands bankCommands,
IBankAccountCommands bankAccountCommands,
IPaymentLevelCommands paymentLevelCommands,
RiskLevelCommands riskLevelCommands,
IPaymentRepository paymentRepository,
IGameRepository gameRepository,
IGameManagement gameManagement,
ICurrencyExchangeCommands currencyExchangeCommands,
ContentTranslationCommands contentTranslationCommands,
BackendIpRegulationService backendIpRegulationService,
BrandIpRegulationService brandIpRegulationService,
IPaymentGatewaySettingsCommands paymentGatewaySettingsCommands,
ISettingsCommands settingsCommands,
ISettingsRepository settingsRepository,
ICommonSettingsProvider settingsProvider,
IMassMessageCommands massMessageCommands,
IMessagingRepository messagingRepository,
IEventRepository eventRepository,
IEventBus eventBus)
{
_repositoryBase = repositoryBase;
_brandRepository = brandRepository;
_licenseeCommands = licenseeCommands;
_currencyCommands = currencyCommands;
_brandCommands = brandCommands;
_cultureCommands = cultureCommands;
_playerCommands = playerCommands;
_authCommands = authCommands;
_authRepository = authRepository;
_roleService = roleService;
_securityRepository = securityRepository;
_playerRepository = playerRepository;
_walletCommands = walletCommands;
_bankCommands = bankCommands;
_bankAccountCommands = bankAccountCommands;
_paymentLevelCommands = paymentLevelCommands;
_riskLevelCommands = riskLevelCommands;
_paymentRepository = paymentRepository;
_gameRepository = gameRepository;
_gameManagement = gameManagement;
_currencyExchangeCommands = currencyExchangeCommands;
_contentTranslationCommands = contentTranslationCommands;
_backendIpRegulationService = backendIpRegulationService;
_brandIpRegulationService = brandIpRegulationService;
_paymentGatewaySettingsCommands = paymentGatewaySettingsCommands;
_settingsCommands = settingsCommands;
_settingsRepository = settingsRepository;
_settingsProvider = settingsProvider;
_massMessageCommands = massMessageCommands;
_messagingRepository = messagingRepository;
_eventRepository = eventRepository;
_eventBus = eventBus;
}
public BonusQueries(IBonusRepository repository, IBrandOperations brandOperations)
{
_repository = repository;
_brandOperations = brandOperations;
}