Example #1
0
        /// <summary>
        /// Constructor for the MainViewModel
        /// </summary>
        /// <param name="iDialogWrapper">Interface for the log-file-open-selection-dialog</param>
        /// <param name="iAssemblyWrapper">Interface for the get-application-version class</param>
        /// <param name="iParsingFactory">Interface for determining which parsing strategy we need to use</param>
        /// <param name="iFilterFactory">Interface for the filters we need to use in the TabViewModel</param>
        /// <param name="iLog">Interface for the LogParse's log file</param>
        public MainViewModel(IDialogWrapper iDialogWrapper, IAssemblyWrapper iAssemblyWrapper, IParsingFactory iParsingFactory, IFilterFactory iFilterFactory, ILog iLog)
        {
            _dialogWrapper   = iDialogWrapper ?? throw new ArgumentNullException(nameof(iDialogWrapper));
            _assemblyWrapper = iAssemblyWrapper ?? throw new ArgumentNullException(nameof(iAssemblyWrapper));
            _parsingFactory  = iParsingFactory ?? throw new ArgumentNullException(nameof(iParsingFactory));
            _filterFactory   = iFilterFactory ?? throw new ArgumentNullException(nameof(iFilterFactory));
            _iLog            = iLog ?? throw new ArgumentNullException(nameof(iLog));
            _listLoadLine    = new ObservableCollection <LogModel>();
            _closedTabsList  = new List <ITab>();

            Tabs = new ObservableCollection <ITab>();

            ClickMenuCommand         = new RelayCommand(SelectLogFile);
            OpenClosedTabMenuCommand = new RelayCommand(ReOpenLastClosedTab);
            CloseTabCommand          = new RelayCommand <ITab>(CloseTab);
            ClickOpenNotepadCommand  = new RelayCommand(OpenNotepad);
            ExitCommand                   = new RelayCommand(ExitApplication);
            DropInFileCommand             = new RelayCommand <DragEventArgs>(OpenDroppedFiles);
            ChangeSizeWindowCommand       = new RelayCommand <EventArgs>(ChangeSizeWindow);
            CloseWindowCommand            = new RelayCommand(CloseWindow);
            LastClosedTabOpenEventCommand = new RelayCommand(ReOpenLastClosedTabEvent);
            TabMouseClickCommand          = new RelayCommand <ITab>(CloseTabMiddleButton);

            GetVersion();
        }
Example #2
0
 protected ArrivalDeparturesControllerBase(ILocationData data, IFilterFactory filters, IMapper mapper, ILogger logger)
 {
     _timetable = data;
     _filters   = filters;
     _mapper    = mapper;
     _logger    = logger;
 }
Example #3
0
 public TestController(IServiceHandlerFactory ServiceHandlerFactory
                       , IFilterFactory FilterFactory
                       , IRule RulesFactor
                       , ICommonInfo CommonInfo)
 ///  : base(ServiceHandlerFactory, FilterFactory, RulesFactor, CommonInfo)
 {
 }
Example #4
0
 public CrudService(
     AnyServiceConfig config,
     IRepository <TEntity> repository,
     CrudValidatorBase <TEntity> validator,
     WorkContext workContext,
     IModelPreparar <TEntity> modelPreparar,
     IEventBus eventBus,
     IFileStoreManager fileStoreManager,
     IFilterFactory filterFactory,
     IPermissionManager permissionManager,
     IEnumerable <EntityConfigRecord> entityConfigRecords,
     ILogger <CrudService <TEntity> > logger)
 {
     Logger                    = logger;
     Config                    = config;
     Repository                = repository;
     Validator                 = validator;
     WorkContext               = workContext;
     ModelPreparar             = modelPreparar;
     EventBus                  = eventBus;
     FileStorageManager        = fileStoreManager;
     FilterFactory             = filterFactory;
     PermissionManager         = permissionManager;
     CurrentEntityConfigRecord = entityConfigRecords.First(typeof(TEntity));
 }
Example #5
0
 public CommandLineProcessorService(ILogger <CommandLineProcessorService> logger, IOutputService outputService, IFilterFactory filterFactory)
 {
     this.logger        = logger;
     this.outputService = outputService;
     this.filterFactory = filterFactory;
     usage = CreateUsage();
 }
        public Task InvokeFiltersAsync <TContext, TFilter>(TContext context)
            where TContext : IFilterContext
            where TFilter : ICommandFilter
        {
            var filterType = typeof(TFilter);

            if (_cachedDelegates.TryGetValue(filterType, out var proccessDelegate))
            {
                return(proccessDelegate(context));
            }

            IFilterFactory selectedFilterFactory = null;

            foreach (var filterFactory in _filterFactories)
            {
                if (filterFactory.CanInvoke(filterType))
                {
                    selectedFilterFactory = filterFactory;
                    break;
                }
            }

            if (selectedFilterFactory.HasNoContent())
            {
                return(Task.CompletedTask);
            }

            var filterDelegate = selectedFilterFactory.GetFiltersDelegate();

            CheckFilterDelegate(selectedFilterFactory, filterDelegate);

            var buildedDelegate = BuildDelegate(filterType, filterDelegate);

            return(buildedDelegate(context));
        }
Example #7
0
 protected Condition(IFilterFactory filterFactory, IFilter leftPart, IFilter rightPart, string conditionValue)
 {
     _filterFactory = filterFactory;
     LeftPart       = leftPart;
     RightPart      = rightPart;
     ConditionValue = conditionValue;
 }
Example #8
0
        public EntitiesController(
            Notificator notificator,
            IFetchingRecords entitiesSource,
            IConfiguration configuration,
            IFilterFactory filterFactory)
        {
            if (notificator == null)
            {
                throw new ArgumentNullException("notificator");
            }
            if (entitiesSource == null)
            {
                throw new ArgumentException("entitiesSource");
            }
            if (configuration == null)
            {
                throw new ArgumentException("configuration");
            }
            if (filterFactory == null)
            {
                throw new ArgumentException("filterFactory");
            }

            _notificator    = notificator;
            _entitiesSource = entitiesSource;
            _configuration  = configuration;
            _filterFactory  = filterFactory;
        }
 public FilterItem(FilterChainKind kind, IFilterFactory factory, IFilter referenceFilter, FilterAccessor accessor, int perInvokeIndex = -1)
 {
     Kind = kind;
     Factory = factory;
     ReferenceFilter = referenceFilter;
     Accessor = accessor;
     PerInvokeIndex = perInvokeIndex;
 }
Example #10
0
 public SubCategoryEdits(IServiceHandlerFactory ServiceHandlerFactory
                         , IFilterFactory FilterFactory
                         , IListFactory ListFactory
                         , ICommonInfo CommonInfo
                         )
     : base(ServiceHandlerFactory, FilterFactory, ListFactory, CommonInfo)
 {
 }
Example #11
0
 public FilterItem(FilterChainKind kind, IFilterFactory factory, IFilter referenceFilter, FilterAccessor accessor, int perInvokeIndex = -1)
 {
     Kind            = kind;
     Factory         = factory;
     ReferenceFilter = referenceFilter;
     Accessor        = accessor;
     PerInvokeIndex  = perInvokeIndex;
 }
 public ReservationsController(IDeletableRepository <Reservation> reservations, IGenericRepositoy <GeneralSettings> settings, IFilterFactory filterFactory, ICalculatePricing pricingCalculator, IReservationManager reservationManager)
 {
     this.reservations       = reservations;
     this.setings            = settings;
     this.filterFactory      = filterFactory;
     this.pricingCalculator  = pricingCalculator;
     this.reservationManager = reservationManager;
 }
 public RecipeDetailsRepository(IEasyCachingProviderFactory cachingProviderFactory,
                                IMediator mediator,
                                IRecipeDetailsMapper recipeDetailsMapper, IFilterFactory <RecipeDetails, RecipeSearchFilterCriteria> filterFactory)
 {
     _mediator            = mediator;
     _recipeDetailsMapper = recipeDetailsMapper;
     _filterFactory       = filterFactory;
     _cachingProvider     = cachingProviderFactory.GetCachingProvider(RedisConstants.Name);
 }
Example #14
0
        public Bank(IFilterFactory filterFactory)
        {
            if (filterFactory == null)
            {
                throw new ArgumentNullException(nameof(filterFactory));
            }

            Filters = filterFactory.CreateFilter();
        }
        public VehicleMakeWebApiController(IVehicleMakeService service, IFilterFactory filter, IPagingParametersFactory pagingParameters, ISortingPairFactory sortingPair, ISortingParametersFactory sortingParameters)
        {
            this.Service = service;

            this.Filter = filter;
            this.PagingParameters = pagingParameters;
            this.SortingPair = sortingPair;
            this.SortingParameters = sortingParameters;
        }
Example #16
0
        /// <summary>
        /// Creates a filter parser.
        /// </summary>
        /// <param name="factory">The factory to use for constructing
        /// filters based on filter keys and a filter rule for matching string values.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="factory"/> is null.</exception>
        public FilterParser(IFilterFactory <T> factory)
        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }

            this.factory = factory;
        }
        private TBuilder AddRequestFilter(IFilterFactory filter)
        {
            if (filter != null)
            {
                _filters.Add(filter);
            }

            return((TBuilder)this);
        }
Example #18
0
 public OrderService(
     IUnitOfWork unitOfWork,
     IFilterFactory filterFactory,
     IPipeline <Order> pipline,
     IOrderPaidNotificationCenter notificationCenter) : base(unitOfWork)
 {
     _filterFactory      = filterFactory;
     _pipeline           = pipline;
     _notificationCenter = notificationCenter;
 }
Example #19
0
 public HomeController(IPipeline <IContext> pipelineManager,
                       IFilterFactory filterFactory,
                       IDatabaseManager databaseManager,
                       IMicrominer microminer)
 {
     this._pipelineManager = pipelineManager;
     this._filterFactory   = filterFactory;
     this._databaseManager = databaseManager;
     this._microminer      = microminer;
 }
		public void Init() {
			var request = new StubRequest();
			var response = new StubResponse();
			services = new StubMonoRailServices();
			engStubViewEngineManager = new StubViewEngineManager();
			services.ViewEngineManager = engStubViewEngineManager;
			filterFactoryMock = mockRepository.DynamicMock<IFilterFactory>();
			services.FilterFactory = filterFactoryMock;
			engineContext = new StubEngineContext(request, response, services, null);
		}
Example #21
0
        /// <summary>
        /// Sets up the factory to create parameters of the appropriate type (See <see cref="IFilterFactory.CreateNewParameter"/>) while respecting any global overriding parameters
        /// and any explicit <paramref name="importFromIfAny"/>
        /// </summary>
        /// <param name="factory">Decides the Type of <see cref="ISqlParameter"/> created</param>
        /// <param name="globals">Globally overriding parameters, if a filter requires a parameter that matches a global no <see cref="ISqlParameter"/> is created</param>
        /// <param name="importFromIfAny">Desired parameter values, if a filter requires a parameter that matches importFromIfAny then it will get the value from here</param>
        public ParameterCreator(IFilterFactory factory, IEnumerable <ISqlParameter> globals, ISqlParameter[] importFromIfAny)
        {
            if (globals != null)
            {
                _globals = globals.ToArray();
            }

            _factory         = factory;
            _importFromIfAny = importFromIfAny;
        }
Example #22
0
            public void SetUp()
            {
                site          = LoadFakeSite();
                log           = Substitute.For <ILog>();
                fileSystem    = Substitute.For <IFileSystem>();
                filterFactory = Substitute.For <IFilterFactory>();
                filter        = Substitute.For <IFilter>();
                filterFactory.CreateFilter(Arg.Any <string>()).Returns(filter);

                compiler = new Compiler(log, fileSystem, filterFactory);
            }
Example #23
0
			public void SetUp()
			{
				site = LoadFakeSite();
				log = Substitute.For<ILog>();
				fileSystem = Substitute.For<IFileSystem>();
				filterFactory = Substitute.For<IFilterFactory>();
				filter = Substitute.For<IFilter>();
				filterFactory.CreateFilter(Arg.Any<string>()).Returns(filter);
				
				compiler = new Compiler(log, fileSystem, filterFactory);
			}
Example #24
0
        public ExecuteCommandCreateNewFilter(IBasicActivateItems activator, IRootFilterContainerHost host) : base(activator)
        {
            _factory   = host.GetFilterFactory();
            _container = host.RootFilterContainer;
            _host      = host;

            if (_container == null && _host is AggregateConfiguration ac && ac.OverrideFiltersByUsingParentAggregateConfigurationInstead_ID != null)
            {
                SetImpossible("Aggregate is set to use another's filter container tree");
            }
        }
 public ElasticSearchWrapper(IElasticClient esClient, IQueryFactory queryFactory,
                             IPagingHelper pagingHelper, ISortFactory sortFactory, ILogger <ElasticSearchWrapper> logger, IIndexSelector indexSelector,
                             IFilterFactory filterFactory)
 {
     _esClient      = esClient;
     _queryFactory  = queryFactory;
     _pagingHelper  = pagingHelper;
     _sortFactory   = sortFactory;
     _filterFactory = filterFactory;
     _logger        = logger;
     _indexSelector = indexSelector;
 }
        public void Init()
        {
            var request  = new StubRequest();
            var response = new StubResponse();

            services = new StubMonoRailServices();
            engStubViewEngineManager   = new StubViewEngineManager();
            services.ViewEngineManager = engStubViewEngineManager;
            filterFactoryMock          = mockRepository.DynamicMock <IFilterFactory>();
            services.FilterFactory     = filterFactoryMock;
            engineContext = new StubEngineContext(request, response, services, null);
        }
Example #27
0
 public TestWebController(
     IServiceHandlerFactory ServiceHandlerFactory
     , IRule RuleFactory
     , IFilterFactory FilterFactory
     , ICommonInfo CommonInfo
     )
 //: base(ServiceHandlerFactory
 //      , RuleFactory
 //      , FilterFactory
 //      , CommonInfo
 //      , null)
 {
 }
        public WarningService(IServiceScopeFactory scopeFactory, ILogger <ModerationModule> logger,
                              IUserWarningsService userWarningService, IModerationModuleUtils moderationModuleUtils,
                              IFilterFactory filterFactory)
        {
            _scopeFactory = scopeFactory;

            _userWarningService = userWarningService;

            _logger = logger;

            _moderationModuleUtils = moderationModuleUtils;

            _filterFactory = filterFactory;
        }
Example #29
0
        //Registers all custom filters in the assembly passed as a parameter
        private static void RegisterCustomFiltersInAssembly(Assembly assembly)
        {
            //Custom filters are obtained from classes in the Filters namespace that implement the IFilterFactory interface
            var filterFactories = from c in assembly.GetTypes()
                                  where c.IsClass && c.Namespace == CUSTOM_FILTERS_NAMESPACE && typeof(IFilterFactory).IsAssignableFrom(c)
                                  select c;

            //Register each filter globally using its factory method (GetFilterType)
            filterFactories.ToList().ForEach(filterFactoryClass =>
            {
                IFilterFactory ff = (IFilterFactory)Activator.CreateInstance(filterFactoryClass);
                Template.RegisterFilter(ff.GetFilterType());
            });
        }
Example #30
0
 public OpenWithApp(
     IConfigProvider configProvider,
     IDialogService dialogService,
     IFilterFactory filterFactory,
     IProcessStarter processStarter,
     IIconProvider iconProvider
     )
 {
     _configProvider = configProvider;
     _dialogService  = dialogService;
     _filterFactory  = filterFactory;
     _processStarter = processStarter;
     _iconProvider   = iconProvider;
 }
Example #31
0
        protected ContainerMenu(IFilterFactory factory, RDMPContextMenuStripArgs args, IContainer container) : base(args, container)
        {
            _container = container;

            string operationTarget = container.Operation == FilterContainerOperation.AND ? "OR" : "AND";

            Items.Add("Set Operation to " + operationTarget, null, (s, e) => FlipContainerOperation());

            Items.Add(new ToolStripSeparator());

            Add(new ExecuteCommandCreateNewFilter(args.ItemActivator, factory, _container));
            Add(new ExecuteCommandCreateNewFilterFromCatalogue(args.ItemActivator, container));

            Items.Add(new ToolStripSeparator());
            Items.Add("Add SubContainer", _activator.CoreIconProvider.GetImage(RDMPConcept.FilterContainer, OverlayKind.Add), (s, e) => AddSubcontainer());
        }
Example #32
0
        public RecordsService(
            IIlaroAdmin admin,
            IFetchingRecords entitiesSource,
            IFilterFactory filterFactory)
        {
            if (admin == null)
                throw new ArgumentNullException(nameof(admin));
            if (entitiesSource == null)
                throw new ArgumentNullException(nameof(entitiesSource));
            if (filterFactory == null)
                throw new ArgumentNullException(nameof(filterFactory));

            _admin = admin;
            _entitiesSource = entitiesSource;
            _filterFactory = filterFactory;
        }
Example #33
0
        /// <summary>
        /// Register a built-in stream filter factory.
        /// </summary>
        /// <param name="factory">The filter factory.</param>
        /// <returns><c>true</c> if successfully added.</returns>
        public static bool AddSystemFilter(IFilterFactory factory)
        {
            PhpFilter instance;
            bool      ok = true;

            foreach (string filter in factory.GetImplementedFilterNames())
            {
                if (GetFilter(filter, false, out instance, null))
                {
                    ok = false;
                }
            }
            Debug.Assert(ok);

            systemFilters.Add(factory);
            return(ok);
        }
Example #34
0
        public ProcessEngine(IControllerFactory controllerFactory, ControllerDescriptorBuilder controllerDescriptorBuilder,
                             IViewEngine viewEngine, IFilterFactory filterFactory,
                             IResourceFactory resourceFactory, IScaffoldingSupport scaffoldingSupport,
                             IViewComponentFactory viewCompFactory, IMonoRailExtension[] extensions, IEmailSender emailSender)
        {
            this.controllerFactory  = controllerFactory;
            this.extensionComposite = new ExtensionComposite(extensions);

            AddService(typeof(IControllerFactory), controllerFactory);
            AddService(typeof(IViewEngine), viewEngine);
            AddService(typeof(IFilterFactory), filterFactory);
            AddService(typeof(IResourceFactory), resourceFactory);
            AddService(typeof(IScaffoldingSupport), scaffoldingSupport);
            AddService(typeof(IViewComponentFactory), viewCompFactory);
            AddService(typeof(ControllerDescriptorBuilder), controllerDescriptorBuilder);
            AddService(typeof(IMonoRailExtension), extensionComposite);
            AddService(typeof(IEmailSender), emailSender);
        }
        public EntitiesController(
            Notificator notificator,
            IFetchingRecords entitiesSource,
            IConfiguration configuration,
            IFilterFactory filterFactory)
        {
            if (notificator == null)
                throw new ArgumentNullException("notificator");
            if (entitiesSource == null)
                throw new ArgumentException("entitiesSource");
            if (configuration == null)
                throw new ArgumentException("configuration");
            if (filterFactory == null)
                throw new ArgumentException("filterFactory");

            _notificator = notificator;
            _entitiesSource = entitiesSource;
            _configuration = configuration;
            _filterFactory = filterFactory;
        }
Example #36
0
        private void DeepClone(IContainer into, IContainer from, IFilterFactory factory)
        {
            //clone the subcontainers
            foreach (var container in from.GetSubContainers())
            {
                var subContainer = factory.CreateNewContainer();
                subContainer.Operation = container.Operation;
                into.AddChild(subContainer);

                DeepClone(subContainer, container, factory);
            }

            var wizard = new FilterImportWizard(BasicActivator);

            //clone the filters
            foreach (var filter in from.GetFilters())
            {
                into.AddChild(wizard.Import(into, filter));
            }
        }
Example #37
0
			public void SetUp()
			{
				var fileSystem = Substitute.For<IFileSystem>();
				filterFactory = new FilterFactory(fileSystem);
			}
Example #38
0
		/// <summary>
		/// Sets the engine context. Also initialize all required services by querying
		/// <see cref="IEngineContext.Services"/>
		/// </summary>
		/// <param name="engineContext">The engine context.</param>
		public virtual void SetEngineContext(IEngineContext engineContext)
		{
			this.engineContext = engineContext;

			helperFactory = engineContext.Services.HelperFactory; // should not be null
			serviceInitializer = engineContext.Services.ServiceInitializer; // should not be null
			filterFactory = engineContext.Services.FilterFactory; // should not be null
			viewEngineManager = engineContext.Services.ViewEngineManager; // should not be null
			actionSelector = engineContext.Services.ActionSelector; // should not be null
			scaffoldSupport = engineContext.Services.ScaffoldingSupport; // might be null
			dynamicActionProviderFactory = engineContext.Services.DynamicActionProviderFactory; // should not be null
		}
Example #39
0
		public Compiler(ILog log, IFileSystem fileSystem, IFilterFactory filterFactory)
		{
			this.log = log;
			this.fileSystem = fileSystem;
			this.filterFactory = filterFactory;
		}
Example #40
0
 public static void SetFilterFactory(IFilterFactory filterFactory)
 {
     factory = filterFactory;
 }
 public void Setup()
 {
     defaultFilterFactory = new DefaultFilterFactory();
 }
Example #42
0
        /// <summary>
        /// Register a built-in stream filter factory.
        /// </summary>
        /// <param name="factory">The filter factory.</param>
        /// <returns><c>true</c> if successfully added.</returns>
        public static bool AddSystemFilter(IFilterFactory factory)
        {
            PhpFilter instance;
            bool ok = true;
            foreach (string filter in factory.GetImplementedFilterNames())
                if (GetFilter(filter, false, out instance, null)) ok = false;
            Debug.Assert(ok);

            systemFilters.Add(factory);
            return ok;
        }
		/// <summary>
		/// Invoked by the framework in order to give a chance to
		/// obtain other services
		/// </summary>
		/// <param name="provider">The service proviver</param>
		public void Service(IServiceProvider provider)
		{
			viewEngineManager = (IViewEngineManager) provider.GetService(typeof(IViewEngineManager));
			filterFactory = (IFilterFactory) provider.GetService(typeof(IFilterFactory));
			resourceFactory = (IResourceFactory) provider.GetService(typeof(IResourceFactory));
			scaffoldSupport = (IScaffoldingSupport) provider.GetService(typeof(IScaffoldingSupport));
			transformFilterFactory = (ITransformFilterFactory)provider.GetService(typeof(ITransformFilterFactory));
			
			ILoggerFactory loggerFactory = (ILoggerFactory) provider.GetService(typeof(ILoggerFactory));

			if (loggerFactory != null)
			{
				logger = loggerFactory.Create(typeof(ControllerLifecycleExecutor));
			}
		}
 public ShortcutsController(IShortcutDataProvider shortcutDataProvider, IRandomShortcutPicker randomShortcutPicker, IFilterFactory filterFactory)
 {
     _shortcutDataProvider = shortcutDataProvider;
     _randomShortcutPicker = randomShortcutPicker;
     _filterFactory = filterFactory;
 }