public Project([NotNull] IConfiguration configuration, [NotNull] ITraceService trace, [NotNull] IFactory factory, [NotNull] IFileSystem fileSystem, [NotNull] IParseService parseService, [NotNull] IPipelineService pipelines, [NotNull] ICheckerService checker)
{
Configuration = configuration;
Trace = trace;
Factory = factory;
FileSystem = fileSystem;
ParseService = parseService;
Pipelines = pipelines;
Checker = checker;
Context = Factory.ProjectContext();
Indexes = Factory.ProjectIndexes(this);
_projectItems = new LockableList <IProjectItem>(this);
_diagnostics = new SynchronizedList <IDiagnostic>();
Options = ProjectOptions.Empty;
// load databases from configuration
foreach (var pair in Configuration.GetSubKeys(Constants.Configuration.Databases))
{
var languageNames = Configuration.GetArray(Constants.Configuration.Databases + ":" + pair.Key + ":languages");
_databases[pair.Key.ToUpperInvariant()] = Factory.Database(this, pair.Key, languageNames);
}
// set Context language
var database = GetDatabase(Configuration.GetString(Constants.Configuration.Database, "master"));
Assert.IsNotNull(database, "Database specified in 'database' configuration not found");
Context.Language = database.Languages.First();
}
public GameService(IChannelRepository channelRepository, IGameRepository gameRepository, IChannelHelper channelHelper, IParseService parseService)
{
_channelRepository = channelRepository ?? throw new ArgumentNullException(nameof(channelRepository));
_gameRepository = gameRepository ?? throw new ArgumentNullException(nameof(gameRepository));
_channelHelper = channelHelper ?? throw new ArgumentNullException(nameof(channelHelper));
_parseService = parseService ?? throw new ArgumentNullException(nameof(parseService));
}
public MatchHub(IDirectoryService directoryService,
IHttpCacheService cacheService,
IParseService parseService)
{
this.directoryService = directoryService;
this.cacheService = cacheService;
this.parseService = parseService;
}
public void TestValidInputGroupwithExclamation()
{
_mockService = new ParseService();
Assert.Equal(1, _mockService.ParseToScore("{<{},{},{{}}>}"));
Assert.Equal(9, _mockService.ParseToScore("{{<!!>},{<!!>},{<!!>},{<!!>}}"));
Assert.Equal(3, _mockService.ParseToScore("{{<a!>},{<a!>},{<a!>},{<ab>}}"));
}
public void TestValidInputGroupwithGarbge()
{
_mockService = new ParseService();
Assert.Equal(1, _mockService.ParseToScore("{<{},{},{{}}>}"));
Assert.Equal(1, _mockService.ParseToScore("{<a>,<a>,<a>,<a>}"));
Assert.Equal(9, _mockService.ParseToScore("{{<ab>},{<ab>},{<ab>},{<ab>}}"));
}
public void TestInvalidInput()
{
_mockService = new ParseService();
Exception ex = Assert.Throws <Exception>(() => _mockService.ParseToScore("{<{},{},{{}}><}"));
Exception ex2 = Assert.Throws <Exception>(() => _mockService.ParseToScore("{<{},{},{{}}!>}"));
Assert.Equal("Invalid Input", ex.Message);
Assert.Equal("Invalid Input", ex2.Message);
}
public void TestValidInputGroup()
{
_mockService = new ParseService();
Assert.Equal(1, _mockService.ParseToScore("{}"));
Assert.Equal(6, _mockService.ParseToScore("{{{}}}"));
Assert.Equal(16, _mockService.ParseToScore("{{{},{},{{}}}}"));
Assert.Equal(5, _mockService.ParseToScore("{{},{}}"));
}
public ParseController(IParseService parser, IPresenter <DateTimeRuleViewModel, DateTimeRule> dateTimeRulePresenter,
IPresenter <MessageRuleViewModel, MessageRule> messageRulePresenter,
IPresenter <SeverityRuleViewModel, SeverityRule> severityRulePresenter,
IPresenter <CustomAttributeRuleViewModel, GeneralRule> customAttributeRulePresenter)
{
_parser = parser;
_dateTimeRulePresenter = dateTimeRulePresenter;
_messageRulePresenter = messageRulePresenter;
_severityRulePresenter = severityRulePresenter;
_customAttributeRulePresenter = customAttributeRulePresenter;
}
/// <summary>
/// Initializes a new instance of the <see cref="EatThisMuchRecipeProvider"/> class.
/// </summary>
/// <param name="scrapeService">The scrape service.</param>
/// <param name="logger">The logger.</param>
public EatThisMuchRecipeProvider(
IParseService parseService,
IWebpageFactory pageFactory,
ICategoryProvider categoryProvider,
IRecipeRepository recipeRepositry,
ILogger logger)
{
_parseService = parseService;
_pageFactory = pageFactory;
_categoryProvider = categoryProvider;
_recipeRepositry = recipeRepositry;
_logger = logger;
}
public EatThisMuchCategoryProvider(
IEatThisMuchCategoryRepository categoryRepo,
IParseService parseService,
IWebpageFactory pageFactory,
ILogger logger)
{
_categoryRepo = categoryRepo;
_parseService = parseService;
_pageFactory = pageFactory;
_logger = logger;
// since we can't directly return data points we need. Scrape all missing data and send to DB.
_initialization = Task.Run(Initialize);
// todo: option to update existing data points.
}
public LogController(
INormalizedLogService normalizedLogService,
IRawLogService rawLogService,
IParsingRulesService parsingRulesService,
IParseService parseService,
IPresenter <NormalizedLogViewModel, NormalizedLog> normalizedLogPresenter,
IPresenter <RawLogViewModel, RawLog> rawLogPresenter, IAlertValueService alertValueService, IComponentService componentService)
{
_normalizedLogService = normalizedLogService;
_rawLogService = rawLogService;
_parsingRulesService = parsingRulesService;
_parseService = parseService;
_normalizedLogPresenter = normalizedLogPresenter;
_rawLogPresenter = rawLogPresenter;
_alertValueService = alertValueService;
_componentService = componentService;
}
public LogFilesViewModel(
IEventAggregator eventAggregator,
IParseService parseService,
DatabaseContext dbContext,
DpsReportService dpsReportService)
{
this.eventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
this.parseService = parseService ?? throw new ArgumentNullException(nameof(parseService));
this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
this.dpsReportService =
dpsReportService ?? throw new ArgumentNullException(nameof(dpsReportService));
this.eventAggregator.Subscribe(this);
DisplayName = "Log Files";
FilesToParse = new BindableCollection <string>();
FilesToParse.CollectionChanged += (sender, args) => NotifyOfPropertyChange(nameof(CanParseFiles));
}
public EntityValidationController(IParseService service)
{
_parseService = service;
}
public CalculatorService(IParseService parseService, ICalculatorFactory calculatorFactory, IService <Calculation> calculationService)
{
_parseService = parseService;
_calculatorFactory = calculatorFactory;
_calculationService = calculationService;
}
public UploadController(IParseService parse, ITransactionsService transactions)
{
_parseService = parse;
_transactionsService = transactions;
}
public ApplicationService(IParseService parseService, IAccountService accountService)
{
_accountService = accountService;
_parseService = parseService;
}
public Calculator(IDelimiterService deliService, IParseService parseService, ICalculateService calService)
{
_deliService = deliService;
_parseService = parseService;
_calService = calService;
}
public HomeController()
{
_parseService = new ParseService();
}
public HomeController(IParseService requestTypeService, IConfiguration configuration)
{
_requestTypeService = requestTypeService;
_configuration = configuration;
_isAsync = Convert.ToBoolean(_configuration["RuningMode:Async"]);
}
public HelpModelContextProvider(IParseService parseService, IMappingEngine mapper)
{
_mapper = mapper;
_parseService = parseService;
}
public ParseController(IParseService parseService)
{
_parseService = parseService;
}
public ParseCSVController(IParseService service)
{
_service = service;
}
public ScrapService(IDictionariesService dictionaryService,
IParseService parseService)
{
_dictionaryService = dictionaryService;
_parseService = parseService;
}
public StreamProcessController(IParseService parseServicecs)
{
_parseService = parseServicecs;
}
public LogParserViewModel(
IMapper mapper,
DatabaseContext dbContext,
IParseService parseService,
IDiscordService discordService,
SnackbarMessageQueue messageQueue,
IEventAggregator eventAggregator,
LogFilesViewModel logFilesViewModel,
LogDetailsViewModel logDetailsViewModel)
{
Log.Debug("LogParserViewModel constructor called");
this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
this.parseService = parseService ?? throw new ArgumentNullException(nameof(parseService));
this.discordService = discordService ?? throw new ArgumentNullException(nameof(discordService));
this.messageQueue = messageQueue ?? throw new ArgumentNullException(nameof(messageQueue));
this.eventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
if (logFilesViewModel == null)
{
throw new ArgumentNullException(nameof(logFilesViewModel));
}
if (logDetailsViewModel == null)
{
throw new ArgumentNullException(nameof(logDetailsViewModel));
}
this.eventAggregator.Subscribe(this);
Items.Add(logFilesViewModel);
//Items.Add(logDetailsViewModel);
LogFiles = new BindableCollection <ParsedLogFileDto>();
BossNameFilters = new BindableCollection <string>()
{
ClearFilterText
};
LogFiles.CollectionChanged += LogFilesCollectionChanged;
var fileVersion = parseService.GetFileVersionInfo();
if (string.IsNullOrWhiteSpace(fileVersion))
{
EliteInsightsVersion = Resource.EliteInsightsNotInstalled;
UpdateEliteInsightsContent = Resource.InstallEliteInsights;
installed = false;
}
else
{
EliteInsightsVersion = fileVersion;
UpdateEliteInsightsContent = Resource.UpdateEliteInsights;
installed = true;
}
ShowProgressBar = true;
_ = LoadDataFromDatabase();
}
public CompoundWordProcessor(IParseService parseService, IFileService <string> fileService)
{
_parseService = parseService;
_fileService = fileService;
}
public ParseController(IParseService parseServicecs)
{
_parseService = parseServicecs;
}
public SearchController(IParseService parseService)
{
this.parseService = parseService;
}
