public AVCStatusValidator(IFraudRepository fraudRepository, AutoVerificationCheckStatus status)
{
switch (status)
{
//Here we verify that we have such avc in the DB and its status is Inactive
case AutoVerificationCheckStatus.Inactive:
RuleFor(command => command.Id)
.Must(commmand => fraudRepository
.AutoVerificationCheckConfigurations
.Where(avc => avc.Status == AutoVerificationCheckStatus.Inactive)
.Select(avc => avc.Id).Contains(commmand))
.WithMessage(AVCConfigurationValidationMessagesEnum.AvcMissingInTheDbOrItsStatusIsAlreadyActive.ToString());
break;
//Here we verify that we have such avc in the DB and its status is Active
case AutoVerificationCheckStatus.Active:
RuleFor(command => command.Id)
.Must(commmand => fraudRepository
.AutoVerificationCheckConfigurations
.Where(avc => avc.Status == AutoVerificationCheckStatus.Active)
.Select(avc => avc.Id).Contains(commmand))
.WithMessage(AVCConfigurationValidationMessagesEnum.AvcMissingInTheDbOrItsStatusIsAlreadyInactive.ToString());
break;
}
}
public DuplicateScoreService(
IFraudRepository fraudRepository,
DuplicateMechanismQueries duplicateMechanismQueries)
{
_fraudRepository = fraudRepository;
_duplicateMechanismQueries = duplicateMechanismQueries;
}
public RebateWageringValidationService(
IPaymentRepository paymentRepository,
IFraudRepository fraudRepository)
{
_paymentRepository = paymentRepository;
_fraudRepository = fraudRepository;
}
public AVCConfigurationDTOValidator(IFraudRepository fraudRepository, AvcConfigurationDtoQueriesEnum queryType)
{
switch (queryType)
{
case AvcConfigurationDtoQueriesEnum.Create:
Custom(config =>
{
return(fraudRepository.AutoVerificationCheckConfigurations.Any(
record =>
record.BrandId == config.Brand &&
record.Currency == config.Currency &&
record.VipLevels.Select(o => o.Id).Intersect(config.VipLevels).Any())
? new ValidationFailure("", AVCConfigurationValidationMessagesEnum.RecordWithTheSameCompositeKeyAlreadyExists.ToString())
: null);
}); break;
case AvcConfigurationDtoQueriesEnum.Update:
Custom(config =>
{
return(fraudRepository.AutoVerificationCheckConfigurations
.Where(record => record.Id != config.Id)
.Any(
record =>
record.BrandId == config.Brand &&
record.Currency == config.Currency &&
record.VipLevels.Select(o => o.Id).Intersect(config.VipLevels).Any()) ? new ValidationFailure("", AVCConfigurationValidationMessagesEnum.RecordWithTheSameCompositeKeyAlreadyExists.ToString()) : null);
});
break;
}
}
public AWCValidationService(
IPaymentRepository paymentRepository,
IFraudRepository fraudRepository)
{
_paymentRepository = paymentRepository;
_fraudRepository = fraudRepository;
}
public ManualAdjustmentWageringValidationService(
IPaymentRepository paymentRepository,
IFraudRepository fraudRepository)
{
_paymentRepository = paymentRepository;
_fraudRepository = fraudRepository;
}
public RiskProfileCheckCommands(IFraudRepository fraudRepository,
IActorInfoProvider actorInfoProvider
, IEventBus eventBus)
{
_fraudRepository = fraudRepository;
_actorInfoProvider = actorInfoProvider;
_eventBus = eventBus;
}
public DuplicateMechanismCommands(IFraudRepository repository,
IActorInfoProvider actorInfoProvider,
IEventBus eventBus)
{
_repository = repository;
_actorInfoProvider = actorInfoProvider;
_eventBus = eventBus;
}
public override void BeforeEach()
{
base.BeforeEach();
Balance = new BonusBalance();
var bonusApiMock = new Mock <IBonusApiProxy>();
bonusApiMock.Setup(proxy => proxy.GetPlayerBalanceAsync(It.IsAny <Guid>(), It.IsAny <Guid?>())).ReturnsAsync(Balance);
Container.RegisterInstance(bonusApiMock.Object);
_withdrawalService = Container.Resolve <IWithdrawalService>();
_paymentRepository = Container.Resolve <FakePaymentRepository>();
_gameRepository = Container.Resolve <FakeGameRepository>();
_gameRepository.SavedChanges += (s, e) =>
{
var allGameActions = _gameRepository.Rounds
.SelectMany(o => o.GameActions);
foreach (var gameAction in allGameActions)
{
if (Enumerable.Any(_gameRepository.GameActions, o => o.Id == gameAction.Id))
{
continue;
}
gameAction.Round.Game = _gameRepository.Games
.Single(o => o.Id == gameAction.Round.GameId);
_gameRepository.GameActions.Add(gameAction);
}
};
_actorInfoProvider = Container.Resolve <IActorInfoProvider>();
_paymentTestHelper = Container.Resolve <PaymentTestHelper>();
_gamesTestHelper = Container.Resolve <GamesTestHelper>();
_avcConfigurationCommands = Container.Resolve <IAVCConfigurationCommands>();
_brandQueries = Container.Resolve <BrandQueries>();
_fraudRepository = Container.Resolve <IFraudRepository>();
var securityTestHelper = Container.Resolve <SecurityTestHelper>();
securityTestHelper.PopulatePermissions();
securityTestHelper.CreateAndSignInSuperAdmin();
Container.Resolve <RiskLevelWorker>().Start();
Container.Resolve <PaymentWorker>().Start();
var brandHelper = Container.Resolve <BrandTestHelper>();
var brand = brandHelper.CreateActiveBrandWithProducts();
player = Container.Resolve <PlayerTestHelper>().CreatePlayer();
var bankAccount = _paymentTestHelper.CreatePlayerBankAccount(player.Id, brand.Id, true);
bankAccount.Player.DateRegistered = DateTimeOffset.Now.AddMonths(-1);
}
public UpdateWageringConfigurationValidator(IFraudRepository repository)
{
RuleFor(x => x)
.Must(x => x.IsDepositWageringCheck || x.IsManualAdjustmentWageringCheck || x.IsRebateWageringCheck)
.WithMessage("Please select the criteria")
.WithName("BrandId");
RuleFor(x => x.Currency)
.NotNull()
.NotEmpty()
.WithMessage("Please select the currency");
}
public CreateRiskLevelValidator(IFraudRepository repository)
: base(repository)
{
RuleFor(x => x)
.Must(rl => !repository.RiskLevels.Any(y => rl.BrandId == y.BrandId && rl.Name == y.Name))
.WithMessage("Fraud Risk Level name should be unique per brand.")
.WithName("Name");
RuleFor(x => x)
.Must(rl => !repository.RiskLevels.Any(y => rl.BrandId == y.BrandId && rl.Level == y.Level))
.WithMessage("Fraud Risk Level should be unique per brand.")
.WithName("Level");
}
public BrandCheckAspect(
IActorInfoProvider actorInfoProvider,
ISecurityRepository securityRepository,
IPaymentRepository paymentRepository,
IFraudRepository fraudRepository,
IPlayerRepository playerRepository)
{
_actorInfoProvider = actorInfoProvider;
_securityRepository = securityRepository;
_paymentRepository = paymentRepository;
_fraudRepository = fraudRepository;
_playerRepository = playerRepository;
}
public RiskProfileCheckController(
IRiskProfileCheckCommands riskProfileCheckCommands,
IRiskProfileCheckQueries riskProfileCheckQueries,
ISecurityRepository securityRepository,
IRiskLevelQueries riskLevelQueries,
IFraudRepository repository,
IGameRepository gameRepository)
{
_riskProfileCheckCommands = riskProfileCheckCommands;
_riskProfileCheckQueries = riskProfileCheckQueries;
_securityRepository = securityRepository;
_riskLevelQueries = riskLevelQueries;
_repository = repository;
_gameRepository = gameRepository;
}
public UpdateRiskLevelValidator(IFraudRepository repository)
: base(repository)
{
RuleFor(x => x)
.Must(rl => !repository.RiskLevels.Any(y => rl.BrandId == y.BrandId && rl.Name == y.Name && y.Id != rl.Id))
.WithMessage("Fraud Risk Level name should be unique per brand.")
.WithName("Name");
RuleFor(x => x)
.Must(rl => !repository.RiskLevels.Any(y => rl.BrandId == y.BrandId && rl.Level == y.Level && y.Id != rl.Id))
.WithMessage("Fraud Risk Level should be unique per brand.")
.WithName("Level");
RuleFor(x => x.Id)
.Must(id => repository.RiskLevels.Any(y => id == y.Id)).WithMessage("{\"text\": \"app:common.idDoesNotExist\"}");
}
public RiskLevelValidatorBase(IFraudRepository repository)
{
RuleFor(x => x.BrandId)
.Must(id => repository.Brands.Any(y => id == y.Id))
.WithMessage("{\"text\": \"app:fraud.manager.message.brandDoesNotExist\"}")
.NotEmpty().WithMessage("{\"text\": \"app:common.requiredField\"}");
RuleFor(x => x.Name)
.NotEmpty().WithMessage("{\"text\": \"app:common.requiredField\"}")
.Length(1, 50).WithMessage("{{\"text\": \"app:common.exceedMaxLength\", \"variables\": {{\"length\": \"{0}\"}}}}", 50)
.Matches(@"^[a-zA-Z0-9-_\s]*$").WithMessage("{\"text\": \"app:common.validationMessages.alphanumericSpacesDashesUnderscores\"}");
RuleFor(x => x.Level.ToString())
.Length(0, 20).WithMessage("{{\"text\": \"app:common.exceedMaxLength\", \"variables\": {{\"length\": \"{0}\"}}}}", 20);
RuleFor(x => x.Description)
.Length(0, 200).WithMessage("{{\"text\": \"app:common.exceedMaxLength\", \"variables\": {{\"length\": \"{0}\"}}}}", 200);
}
public CreateWageringConfigurationValidator(IFraudRepository repository)
{
RuleFor(x => x)
.Must(x => x.IsDepositWageringCheck || x.IsManualAdjustmentWageringCheck || x.IsRebateWageringCheck)
.WithMessage("Please select the criteria")
.WithName("BrandId");
RuleFor(x => x)
.Must(x =>
{
return
(!repository.WagerConfigurations.Any(y => y.BrandId == x.BrandId && y.CurrencyCode == x.Currency));
})
.WithName("Currency")
.WithMessage("The brand already has wagering configuration for this currency");
RuleFor(x => x.Currency)
.NotNull()
.NotEmpty()
.WithMessage("Please select the currency");
}
public SignUpFraudTypeValidator(IFraudRepository repository)
{
_repository = repository;
Custom((dto, context) =>
{
var instance = context.InstanceToValidate;
var fraudTypes = _repository.SignUpFraudTypes.AsQueryable();
if (instance.Id != Guid.Empty)
{
fraudTypes = fraudTypes.Where(o => o.Id != instance.Id);
}
var isPresent = fraudTypes
.Any(o => o.Name == instance.FraudTypeName);
return(isPresent
? new ValidationFailure("Name", "uniqueName")
: null);
});
}
public AVCConfigurationQueries(IFraudRepository fraudRepository)
{
_fraudRepository = fraudRepository;
}
public SignUpFraudTypeCommands(IFraudRepository fraudRepository, IEventBus eventBus)
{
_fraudRepository = fraudRepository;
_eventBus = eventBus;
}
public RiskLevelCommands(IEventBus serviceBus, IFraudRepository repository, IActorInfoProvider actorInfoProvider)
{
_eventBus = serviceBus;
_repository = repository;
_actorInfoProvider = actorInfoProvider;
}
public FraudChecker(IDummyOrderObject order, IFraudRepository repository, string channelKey)
: this(order, channelKey)
{
this.repository = repository;
this.IsRepositoryLoaded = true;
}
public FraudChecker(IDummyOrderObject order, IFraudRepository repository)
: this(order)
{
this.repository = repository;
this.IsRepositoryLoaded = true;
}
public WithdrawalVerificationLogsQueues(IFraudRepository repository)
{
_repository = repository;
}
public AVCConfigurationCommands(IFraudRepository fraudRepository, IActorInfoProvider actorInfoProvider, IEventBus eventBus)
{
_fraudRepository = fraudRepository;
_actorInfoProvider = actorInfoProvider;
_eventBus = eventBus;
}
public WagerConfigurationQueries(IFraudRepository fraudRepository, ISecurityRepository securityRepository)
{
_fraudRepository = fraudRepository;
_securityRepository = securityRepository;
}
public FraudPlayerQueries(IFraudRepository repository)
{
_repository = repository;
}
private void LoadRepository()
{
this.repository = new FraudRepository();
this.IsRepositoryLoaded = true;
}
public FraudCheckerBulkProcessor()
{
this.repository = new FraudRepository();
}
public RiskLevelSubscriber(IFraudRepository repository)
{
_repository = repository;
}
public SignUpFraudTypeQueries(IFraudRepository fraudRepository)
{
_fraudRepository = fraudRepository;
}
public FraudCheckerBulkProcessor(IFraudRepository specificRepository)
{
this.repository = specificRepository;
}
public BonusSubscriber(IFraudRepository repository)
{
_repository = repository;
}
public RiskLevelQueries(IFraudRepository repository)
{
this._repository = repository;
}
public DuplicateMechanismQueries(IFraudRepository repository)
{
_repository = repository;
}
public RiskProfileCheckQueries(IFraudRepository fraudRepository)
{
_fraudRepository = fraudRepository;
}
