public CreateContactViewModel(UpdateContactQueryResult createContact, IValidationService validationService)
{
this.command = createContact.Command;
this.Counties = createContact.Counties;
this.Countries = createContact.Countries;
this.validationService = validationService;
}
public CreditRequestController(
ICreditRequestService creditRequestService,
IValidationService<CreditRequestViewModel> creditRequestValidationService)
{
this.creditRequestService = creditRequestService;
this.creditRequestValidationService = creditRequestValidationService;
}
public CalculationDepositController(ICalculationDepositService iCalculationDepositService, IDepositService depositService, IValidationService validationService)
: base()
{
calculationDepositService = iCalculationDepositService;
this.depositService = depositService;
this.validationService = validationService;
}
public CalculationCreditController(ICalculationCreditService iCalculationCreditService, ICreditService iCreditService, IValidationService iValidationService)
: base()
{
calculationCreditService = iCalculationCreditService;
creditService = iCreditService;
validationService = iValidationService;
}
public CommandController(IRequestResponsePairQueryService pairs,
IUseCaseQueryService useCaseQueryService,
IValidationService validationService)
{
_requestResponseRepo = pairs;
_useCaseRepo = useCaseQueryService;
_validationService = validationService;
}
public ValidationController(IValidationService validationService)
{
if (validationService == null)
{
throw new ArgumentNullException("validationService");
}
_validationService = validationService;
}
public CreditRequestService(IUnitOfWork iUnitOfWork, IImageService iImageService,
ICustomerService iCustomerService, IValidationService iValidationService)
{
_iUnitOfWork = iUnitOfWork;
_iImageService = iImageService;
_iCustomerService = iCustomerService;
_iValidationService = iValidationService;
}
public UserService(IUserRepository repository, ILanguageRepository languageRepository, IValidationService validator, IPluginEngine pluginEngine, IModulesLoaded modules, OxiteContext context)
{
this.repository = repository;
this.languageRepository = languageRepository;
this.validator = validator;
this.pluginEngine = pluginEngine;
this.cache = modules.GetModules <IOxiteCacheModule>().Reverse().First();
this.context = context;
}
public CourseSessionController(lmsContext context, ICourseSessionRepository courseSessionRepository, IValidationService validationService)
{
_context = context;
_courseSessionRepository = courseSessionRepository;
_validationService = validationService;
_NotFound = new GenericResult {
Response = false, Message = "Record not found"
};
}
public ImageService()
{
_imageRepository = new TImageRepository();
_validationService = new ValidationService();
_historyService = new HistoryService();
_statisticService = new StatisticService();
_stateService = new StateService();
_tinyPngConnectorService = new TinyPNGConnectorService();
}
public ValidationController(IValidationService validationService)
{
if (validationService == null)
{
throw new ArgumentNullException("Validation Service was not initialized");
}
_validationService = validationService;
}
public ApplicationServiceServicesContext(IWebHostEnvironment hostingEnvironment, IMapper mapper, IAuthorizationService authorizationService, IUserService userService, IValidationService validationService, IOrderByMapper orderByMapper)
{
HostingEnvironment = hostingEnvironment;
Mapper = mapper;
AuthorizationService = authorizationService;
UserService = userService;
ValidationService = validationService;
OrderByMapper = orderByMapper;
}
public CreateLogCommandHandler(
IValidationService validationService,
IUnitOfWork uow,
ILogRepository logRepository,
IProjectRepository projectRepository) : base(validationService, uow)
{
_logRepository = logRepository;
_projectRepository = projectRepository;
}
public static void Initialize(ILayoutService layoutService, IValidationService validationService)
{
SaveService = new SaveService();
Layout = layoutService;
ValidationService = validationService;
ContentService = new ContentService("Administrator");
DragDropService = new DragDropService();
RibbonService = new RibbonService();
}
public ItemsPageViewModel(
INavigationService navigationService,
IValidationService validationService,
IToastService toastService) : base(navigationService)
{
this.validationService = validationService;
this.toastService = toastService;
SubmitCommand = new DelegateCommand(Submit);
}
public ContentManagementController(IEditorService editorService,
IHttpContextAccessor httpContextAccessor,
IValidationService validationService,
IAdminService adminService)
{
this.editorService = editorService;
this.httpContextAccessor = httpContextAccessor;
this.validationService = validationService;
this.adminService = adminService;
}
public void WhenMediumWordIsPassedTheResultShouldBeMedium()
{
const string word = "MeeD123";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 50);
}
public void WhenStrongWordIsPassedTheResultShouldBeStrong()
{
var word = @"@5Tr0ng#4%";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 100);
}
public void WhenWordHas3CharsOrLessShouldBeWeak()
{
var word = "aaa";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 20);
}
public ManagerMenu(ICustomerBL customerBL, ILocationBL locationBL, IProductBL productBL, IInventoryBL inventoryBL, IOrderBL orderBL, ILineItemBL lineItemBL, IValidationService validate)
{
_customerBL = customerBL;
_locationBL = locationBL;
_productBL = productBL;
_inventoryBL = inventoryBL;
_orderBL = orderBL;
_lineItemBL = lineItemBL;
_validate = validate;
}
public TradingSimulation(ILogger logger, IValidationService validationService, ClientService clientService,
SharesService sharesService, PortfoliosService portfoliosService, TransactionsService transactionsService)
{
this.logger = logger;
this.validationService = validationService;
this.clientService = clientService;
this.sharesService = sharesService;
this.portfoliosService = portfoliosService;
this.transactionsService = transactionsService;
}
public EntityService(
IMapper mapper,
ILogger <EntityService> logger,
IEntityRepository entityRepository,
IMetadataService metadataService,
IValidationService validationService,
ICacheService cacheService) : base(mapper, metadataService, validationService, entityRepository, logger)
{
_cacheService = cacheService;
}
public void WhenWordHas3CharsOrLessShouldBeWeak()
{
var word = "aaa";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 20);
}
public void WhenStrongWordIsPassedTheResultShouldBeStrong()
{
var word = @"@5Tr0ng#4%";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 100);
}
public void WhenMediumWordIsPassedTheResultShouldBeMedium()
{
const string word = "MeeD123";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 50);
}
public void WhenWeakWordIsPassedTheResultShouldBeWeak()
{
const string word = "teeeste";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 20);
}
public void WhenWeakWordIsPassedTheResultShouldBeWeak()
{
const string word = "teeeste";
_validationService = new PasswordValidationService();
var result = _validationService.MeasurePasswordStrength(word);
Assert.AreEqual(result, 20);
}
protected GestionService(IContextService context, MarfilEntities db = null)
{
_context = context;
_empresa = _context.Empresa;
Usuarioid = _context.Id;
_db = db ?? MarfilEntities.ConnectToSqlServer(_context.BaseDatos);
_appService = new ApplicationHelper(context);
_converterModel = FConverterModel.Instance.CreateConverterModelService <TView, TPersistencia>(context, _db, Empresa);
_validationService = FValidationService.Instance.CreateConverterModelService <TPersistencia>(context, _db);
}
public LocationService(AutoRenterContext context,
ICommandFactory <Location> commandFactory,
IVehicleService vehicleService,
IValidationService validationService)
{
this.context = context;
this.commandFactory = commandFactory;
this.vehicleService = vehicleService;
this.validationService = validationService;
}
public AuthorsController(IAuthorService authorService,
IEditorService editorService,
IHttpContextAccessor httpContextAccessor,
IValidationService validationService)
{
this.authorService = authorService;
this.editorService = editorService;
this.httpContextAccessor = httpContextAccessor;
this.validationService = validationService;
}
public CompanyController(ApplicationContext context, ISelectListService selectListService, ICompanyService companyService, IHomePagingService pagingService, IEmployeeService employeeService, IAccountService accountService, IValidationService validationService)
{
this.context = context;
this.selectListService = selectListService;
this.companyService = companyService;
this.pagingService = pagingService;
this.employeeService = employeeService;
this.accountService = accountService;
this.validationService = validationService;
}
public AnswerInjectionService(IApiClient apiClient, IApplicationApiClient applyApiClient, IValidationService validationService,
IAssessorValidationService assessorValidationService, ISpecialCharacterCleanserService cleanser, ILogger <AnswerService> logger)
{
_apiClient = apiClient;
_applyApiClient = applyApiClient;
_validationService = validationService;
_assessorValidationService = assessorValidationService;
_cleanser = cleanser;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateAlertFromIconicsFault"/> class.
/// </summary>
/// <param name="dynamicsEntityService">set dynamicsEntityService via dependency injection.</param>
/// <param name="validationService">set validationService via dependency injection.</param>
/// <param name="errorQueueService">set errorQueueService via dependency injection.</param>
/// <param name="telemetryConfiguration">Set Application Insights telemetry configuration via dependency injection.</param>
/// <param name="instance">set instanceId via dependency injection.</param>
/// <param name="httpclient">set httpClient via dependency injection.</param>
public CreateAlertFromIconicsFault(TelemetryConfiguration telemetryConfiguration, IDynamicsEntityService dynamicsEntityService, IValidationService validationService, IErrorQueueService errorQueueService, InstanceId instance, HttpClient httpclient)
{
// dynamicsEntityService is added via dependency injection
this.dynamicsEntityService = dynamicsEntityService;
this.validationService = validationService;
this.errorQueueService = errorQueueService;
this.instanceId = instance;
this.httpClient = httpclient;
this.telemetryClient = new TelemetryClient(telemetryConfiguration);
}
public NotifyChangeFunction(IFileStorageService fileStorageService,
IQueueService queueService,
IReleaseStatusService releaseStatusService,
IValidationService validationService)
{
_fileStorageService = fileStorageService;
_queueService = queueService;
_releaseStatusService = releaseStatusService;
_validationService = validationService;
}
public static void Initialize(ILayoutService ILayoutService, IProgressService IProgressService, IValidationService IValidationService)
{
SaveService = new SaveService();
Events = new EventAggregator();
ResourceService = new ResourceService();
Layout = ILayoutService;
ProgressService = IProgressService;
ValidationService = IValidationService;
LoginService = new LoginService(ClientType.Administrator, "Администратор. Авторизация");
}
public SalesService(IDataContextFactory factory,
//ZuhlkeSQLDBContext dbContext,
IValidationService <Sales> validationService,
IDatasourceReader <Sales> datasourceReader) :
base(factory)
{
//_dbContext = dbContext;
_validationService = validationService;
_datasourceReader = datasourceReader;
}
public OrderMenu(ICustomerBL customerBL, ILocationBL locationBL, IProductBL productBL, IInventoryBL inventoryBL, IOrderBL orderBL, IValidationService validate)
{
_customerBL = customerBL;
_locationBL = locationBL;
_productBL = productBL;
_inventoryBL = inventoryBL;
_orderBL = orderBL;
_validate = validate;
customer = SearchCustomer();
}
public KeywordService(
IMapper mapper,
ILogger <KeywordService> logger,
IKeywordRepository keywordRepository,
IMetadataService metadataService,
IValidationService validationService,
ICacheService cacheService) : base(mapper, metadataService, validationService, keywordRepository, logger)
{
_cacheService = cacheService;
}
public ProductManager(IProductDal productDal,
ICacheService cacheService,
ILogService logService,
IValidationService <Product> productValidationService)
{
_cacheService = cacheService;
_productDal = productDal;
_logService = logService;
_productValidationService = productValidationService;
}
public PostService(IPostRepository repository, ILocalizationRepository localizationRepository, ITrackbackOutboundRepository trackbackOutboundRepository, IMessageOutboundRepository messageOutboundRepository, AbsolutePathHelper absolutePathHelper, Site site, IValidationService validator)
{
this.repository = repository;
this.localizationRepository = localizationRepository;
this.trackbackOutboundRepository = trackbackOutboundRepository;
this.messageOutboundRepository = messageOutboundRepository;
this.absolutePathHelper = absolutePathHelper;
this.site = site;
this.validator = validator;
}
public UserCommandHandler(
IPersonRepository personRepository,
IPasswordService passwordService,
IValidationService validationService,
IUnitOfWork uow, IDomainNotificationHandler <DomainNotification> notifications) : base(uow, notifications)
{
_personRepository = personRepository;
_passwordService = passwordService;
_validationService = validationService;
}
public ResourceService(ILogger <AccountService> logger, IRepository repo, UserManager <ExtendedIdentityUser> userManager,
IValidationService validationService, IHostingEnvironment hostingEnvironment, IQueryService queryService)
{
_logger = logger;
_repo = repo;
_userManager = userManager;
_validationService = validationService;
_hostingEnvironment = hostingEnvironment;
_queryService = queryService;
}
public FileImportService(
DiBiContext context, Func <FileType, IFileService> importServiceResolver,
IValidationService <TransactionModel> validationService,
ILogger <FileImportService> logger)
{
_context = context;
_importServiceResolver = importServiceResolver;
_validationService = validationService;
_logger = logger;
}
public AccountService(
IValidationService validationService,
IAccountDao accountDao,
IEncryptionService encryptionService,
IValidationMessageProvider validationMessageProvider)
{
this.validationService = validationService;
this.accountDao = accountDao;
this.encryptionService = encryptionService;
this.validationMessageProvider = validationMessageProvider;
}
public PersonListViewModelDepedencies(
ITranslationService translationService,
IPersonDocumentConfiguration document,
ICrudGroupController crudGroupController,
IValidationService<IPersonRowViewModel> validationService,
IPersonResource personResource,
ITrackedCollectionFactory<PersonModel, IPersonRowViewModel> trackedCollectionFactory)
{
TranslationService = translationService;
Document = document;
CrudGroupController = crudGroupController;
ValidationService = validationService;
PersonResource = personResource;
TrackedCollectionFactory = trackedCollectionFactory;
}
public ClientsController(
IIndividualClientsService individualClientsService,
IJuridicalClientsService juridicalClientsService,
ICountryService countryService,
ICurrentUser currentUser,
ISettingsService settingsService,
IValidationService<CreateIndividualClientViewModel> individualClientValidationService,
IValidationService<CreateJuridicalClientViewModel> juridicalClientValidationService)
{
this.individualClientsService = individualClientsService;
this.juridicalClientsService = juridicalClientsService;
this.countryService = countryService;
this.currentUser = currentUser;
this.settingsService = settingsService;
this.individualClientValidationService = individualClientValidationService;
this.juridicalClientValidationService = juridicalClientValidationService;
}
public BusinessProcessController(
IBaseControllerServiceFacade baseServiceFacade,
IWorkflowService workflowService,
ITaskService taskService,
IWorkflowServiceResolver serviceProvider,
IWorkflowCacheService cashService,
IValidationService validationService,
IWorkflowContextService contextService)
: base(baseServiceFacade)
{
_workflowService = workflowService;
_taskService = taskService;
_serviceProvider = serviceProvider;
_cashService = cashService;
_validationService = validationService;
_contextService = contextService;
}
public void BeforeEach()
{
var validationServiceDependenciesMock = new Mock<IValidationServiceDependencies>();
_greaterThanEvaluatorMock = new Mock<IConditionEvaluator<ValidatableStub>>();
_conditionEvaluatorFactoryMock = new Mock<IConditionEvaluatorFactory>();
_conditionEvaluatorFactoryMock.Setup(
f =>
f.CreateGreaterThanEvaluator(It.IsAny<Func<ValidatableStub, int>>(), It.IsAny<Func<ValidatableStub, int>>()))
.Returns(_greaterThanEvaluatorMock.Object)
.Callback<Func<ValidatableStub, int>, Func<ValidatableStub, int>>((func, func1) =>
{
_getter1 = func;
_getter2 = func1;
});
validationServiceDependenciesMock.SetupGet(d => d.ConditionEvaluatorFactory)
.Returns(_conditionEvaluatorFactoryMock.Object);
_validationRuleMock = new Mock<IValidationRule<ValidatableStub>>();
_validationRuleMock.Setup(r => r.Evaluate(It.IsAny<ValidatableStub>())).Returns(true);
_validationRuleMock.SetupGet(r => r.Properties).Returns(new HashSet<string>()).Verifiable();
_validationRuleFactoryMock = new Mock<IValidationRuleFactory>();
_validationRuleFactoryMock.Setup(
f =>
f.Create(It.IsAny<IConditionEvaluator<ValidatableStub>>(), It.IsAny<Severity>(), It.IsAny<string>(),
It.IsAny<string>()))
.Returns(_validationRuleMock.Object).Callback<IConditionEvaluator<ValidatableStub>, Severity, string, string[]>((evaluator, severity, arg3, arg4) => _message = arg3);
validationServiceDependenciesMock.SetupGet(d => d.ValidationRuleFactory).Returns(_validationRuleFactoryMock.Object);
_notificationServiceMock = new Mock<INotificationService>();
_notificationServiceMock.Setup(s => s.TryRemoveNotification(It.IsAny<Guid>(), It.IsAny<Guid>())).Verifiable();
_validationService = new ValidationService<ValidatableStub>(validationServiceDependenciesMock.Object);
var validateMock = new Mock<IValidate<ValidatableStub>>();
_validationService.Register(validateMock.Object);
_validationService.AddAbsoluteRule(new Mock<IHaveId>().Object, stub => stub.NumberInt, Condition.MustBeGreaterThan, 0, Severity.Error, "Test{0}");
}
public ValidateRunner(
ITimedLog log,
IValidationService<Uri> validationService,
IValidationModule validationModule,
IInterpretationModule interpretationModule
)
{
if (null == log)
throw new ArgumentNullException("log");
this.Log = log;
if (null == validationService)
throw new ArgumentNullException("validationService");
this.ValidationService = validationService;
if (null == validationModule)
throw new ArgumentNullException("validationModule");
this.ValidationModule = validationModule;
if (null == interpretationModule)
throw new ArgumentNullException("interpretationModule");
this.InterpretationModule = interpretationModule;
}
public ValidationController(IValidationService validationService)
{
_validationService = validationService;
}
/// <summary>
/// Initialises a new instance of the RefController class.
/// </summary>
/// <param name="validationService"><c>ValidationService</c> instance.</param>
/// <param name="webClientService"><c>WebClientService</c> instance.</param>
public V3Controller(IValidationService validationService, IWebClientService webClientService)
: base(validationService, webClientService)
{
}
public PersonViewModel(Person model, IValidationService validationService = null)
{
Model = model;
_validationService = validationService;
ConvertModelToViewModel(Model, this);
}
public void Setup()
{
_validationService = new ValidationService(GetSampleBoard());
}
public void BeforeEach()
{
var validationServiceDependenciesMock = new Mock<IValidationServiceDependencies>();
var greaterThanEvaluatorMock = new Mock<IConditionEvaluator<ValidatableStub>>();
var conditionEvaluatorFactoryMock = new Mock<IConditionEvaluatorFactory>();
conditionEvaluatorFactoryMock.Setup(
f =>
f.CreateGreaterThanEvaluator(It.IsAny<Func<ValidatableStub, int>>(), It.IsAny<Func<ValidatableStub, int>>()))
.Returns(greaterThanEvaluatorMock.Object);
validationServiceDependenciesMock.SetupGet(d => d.ConditionEvaluatorFactory)
.Returns(conditionEvaluatorFactoryMock.Object);
_validationRuleMock = new Mock<IValidationRule<ValidatableStub>>();
_validationRuleMock.Setup(r => r.Evaluate(It.IsAny<ValidatableStub>())).Returns(false);
_validationRuleId = Guid.NewGuid();
_validationRuleMock.SetupGet(r => r.Id).Returns(_validationRuleId);
_validationRuleMessage = "Test";
_validationRuleMock.SetupGet(r => r.Message).Returns(_validationRuleMessage);
var validationRuleFactoryMock = new Mock<IValidationRuleFactory>();
validationRuleFactoryMock.Setup(
f =>
f.Create(It.IsAny<IConditionEvaluator<ValidatableStub>>(), It.IsAny<Severity>(), It.IsAny<string>(),
It.IsAny<string>()))
.Returns(_validationRuleMock.Object);
validationServiceDependenciesMock.SetupGet(d => d.ValidationRuleFactory).Returns(validationRuleFactoryMock.Object);
_notificationServiceMock = new Mock<INotificationService>();
_notificationServiceMock.Setup(s => s.TryRemoveNotification(It.IsAny<Guid>(), It.IsAny<Guid>())).Verifiable();
_notificationServiceMock.Setup(s => s.AddNotification(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>())).Verifiable();
validationServiceDependenciesMock.SetupGet(d => d.NotificationService).Returns(_notificationServiceMock.Object);
_validationService = new ValidationService<ValidatableStub>(validationServiceDependenciesMock.Object);
_validateMock = new Mock<IValidate<ValidatableStub>>();
_validateId = Guid.NewGuid();
_validateMock.As<IHaveId>().Setup(h => h.Id).Returns(_validateId);
_validationService.Register(_validateMock.Object);
_validationService.AddAbsoluteRule(new Mock<IHaveId>().Object, stub => stub.NumberInt, Condition.MustBeGreaterThan, 0, Severity.Error, "Test");
_validationRuleMock.SetupGet(r => r.Properties).Returns(new HashSet<string>(new[] { "NumberInt" }));
}
public SettingsController(ISettingsService settingsService, IValidationService<SettingsViewModel> settingValidationService)
{
this.settingsService = settingsService;
this.settingValidationService = settingValidationService;
}
public CustomerDepositService(IUnitOfWork uow, ICustomerService iCustomerService, IValidationService iValidationService)
: base(uow)
{
_iCustomerService = iCustomerService;
_iValidationService = iValidationService;
}
public HomeController()
{
_entryService = new EntryService();
_validationService = new ValidationService();
}
public void SetUp()
{
_validation = MockRepository.GenerateMock<IValidationService>();
}
public SecurityController(IProjectService projectService, IValidationService validationService)
{
_projectService = projectService;
_validationService = validationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseValidationListener"/> class.
/// </summary>
/// <param name="validation">The validation service.</param>
public BaseValidationListener(IValidationService validation)
{
_validation = validation;
}
