public ResultManagerService(ITestResultRepository testResultRepository, ITestsService testsService, ICourseService courseService, IUserRepository <User> userRepository)
{
this.testResultRepository = testResultRepository;
this.testsService = testsService;
this.courseService = courseService;
this.userRepository = userRepository;
}
public ApplyChangesViewModel(ITestsService testsService)
{
this.testsService = testsService;
Title = "Settings";
Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel);
Commands.Single(c => c.IsDefault).Command = new DelegateCommand(() => {
if (string.IsNullOrWhiteSpace(CommitCaption))
{
_CommitCaption = DefaultCommitCaption;
}
if (CommitCaption.Length > 255)
{
_CommitCaption = CommitCaption.Substring(0, 255);
}
Confirmed = true;
});
ChangedTests = testsService.SelectedState.ChangedTests;
var teams = ChangedTests.GroupBy(t => t.TeamName).Select(g => g.Key).ToList();
CommitCaption = $"Fix tests for {string.Join(", ", teams)} team{(teams.Count > 1 ? "s" : "")}";
if (ChangedTests.FirstOrDefault(x => x.Repository.ReadOnly) != null)
{
CanChangeAutoCommit = false;
IsAutoCommit = false;
}
}
public ViewResourcesViewModel(ITestsService testsService)
{
Commands = UICommand.GenerateFromMessageButton(MessageButton.OK, new DialogService(), MessageResult.OK);
Dispatcher = Dispatcher.CurrentDispatcher;
this.testsService = testsService;
Status = ProgramStatus.Loading;
Task.Factory.StartNew(() => UpdateUsedFiles(testsService.ActualState.UsedFiles, testsService.ActualState.Teams)).ConfigureAwait(false);
}
public ApplyChangesViewModel(ITestsService testsService)
{
this.testsService = testsService;
Title = "Settings";
Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel);
Commands.Where(c => c.IsDefault).Single().Command = new DelegateCommand(() => Confirmed = true);
ChangedTests = testsService.ActualState.ChangedTests;
}
public ViewResourcesViewModel(ITestsService testsService, IMinioWorker minioWorker)
{
Commands = UICommand.GenerateFromMessageButton(MessageButton.OK, new DialogService(), MessageResult.OK);
_testsService = testsService;
_minioWorker = minioWorker;
Status = ProgramStatus.Loading;
Task.Factory.StartNew(() => UpdateUsedFiles(testsService.SelectedState.UsedFilesLinks)).ConfigureAwait(false);
}
public TestManagerService(ITestsService testsService, IClassReportBuilder builder, IQuestionService questionService, ICourseService courseService, ITestResultRepository testResultRepository)
{
this.testsService = testsService;
this.builder = builder;
this.questionService = questionService;
this.courseService = courseService;
this.testResultRepository = testResultRepository;
}
public KarmaTestContainerDiscoverer(
[Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
ITestsService testsService,
KarmaTestSettingsProvider testSettingsService,
ILogger logger
)
: base(serviceProvider, testsService, testSettingsService, new KarmaLogger(logger, true))
{
}
public JasmineTestContainerDiscoverer(
[Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
ITestsService testsService,
JasmineTestSettingsProvider testSettingsService,
ILogger logger
)
: base(serviceProvider, testsService, testSettingsService, new JasmineLogger(logger, true))
{
}
public TestsController(
ITestsService testsService,
IValidator <AddTestRequestDto> addTestRequestValidator,
IValidator <UpdateTestRequestDto> updateTestRequestValidator,
IMapper mapper) : base(mapper)
{
_testsService = testsService;
_addTestRequestValidator = addTestRequestValidator;
_updateTestRequestValidator = updateTestRequestValidator;
}
public RepositoryOptimizerViewModel(ITestsService testsService, IMinioWorker minioWorker)
{
_dispatcher = Dispatcher.CurrentDispatcher;
_minioWorker = minioWorker;
_testsService = testsService;
RemovedFiles = new ObservableCollection <RepositoryFileModel>();
Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel);
Commands.Single(c => c.IsDefault).Command = new DelegateCommand(Commit);
Status = ProgramStatus.Loading;
Task.Factory.StartNew(() => UpdateUnusedFiles(testsService.SelectedState.UsedFilesLinks)).ConfigureAwait(false);
}
public RepositoryOptimizerViewModel(ITestsService testsService)
{
Title = "Repository Optimizer";
Dispatcher = Dispatcher.CurrentDispatcher;
this.testsService = testsService;
RemovedFiles = new ObservableCollection <RepositoryFileModel>();
Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel);
Commands.Where(c => c.IsDefault).Single().Command = new DelegateCommand(() => Commit());
Status = ProgramStatus.Loading;
Task.Factory.StartNew(() => UpdateUnusedFiles(testsService.ActualState.UsedFiles, testsService.ActualState.Teams)).ConfigureAwait(false);
}
public PatientController(IPatientService patientService,
IOtherService otherService,
ITestsService testService,
IDhlRegistrationService dhlRegistrationService,
IMaintenanceService maintenanceService)
{
this.patientService = patientService;
this.otherService = otherService;
this.testService = testService;
this.dhlRegistrationService = dhlRegistrationService;
this.maintenanceService = maintenanceService;
}
public SubmissionController(
ISubmissionsService submissions,
IExecutionService executionService,
ITestsService tests,
IUsersService users,
ITestResultsService testResults)
: base(users)
{
this.submissions = submissions;
this.executionService = executionService;
this.tests = tests;
this.testResults = testResults;
}
public DashboardController(IResultService results,
IMappingProvider mapper,
ITestsService tests,
IAnswersService answers,
ICategoryService categories,
UserManager <User> userManager)
{
this.mapper = mapper ?? throw new ArgumentNullException("Mapper can not be null");
this.tests = tests ?? throw new ArgumentNullException("Tests service cannot be null");
this.answers = answers ?? throw new ArgumentNullException("Answers service cannot be null");
this.categories = categories ?? throw new ArgumentNullException("Categories service cannot be null");
this.userManager = userManager ?? throw new ArgumentNullException("User manager cannot be null");
this.results = results;
}
public DashboardController(IAdminService adminService,
IMappingProvider mapper,
ITestsService tests,
IResultService resultService,
UserManager <User> userManager,
IMemoryCache memoryCache)
{
this.mapper = mapper ?? throw new ArgumentNullException("Mapper can not be null");
this.tests = tests ?? throw new ArgumentNullException("Tests service cannot be null");
this.userManager = userManager ?? throw new ArgumentNullException("User manager cannot be null");
this.resultService = resultService ?? throw new ArgumentNullException("Result service cannot be null");
this.adminService = adminService ?? throw new ArgumentNullException("Admin service can not be null.");
this.cache = memoryCache ?? throw new ArgumentNullException("MemoryCache cannot be null!");
}
public ManageTestController(IMappingProvider mapper,
ITestsService tests,
ICategoryService categories,
IStatusesService statuses,
UserManager <User> userManager,
IMemoryCache memoryCache)
{
this.mapper = mapper ?? throw new ArgumentNullException("Mapper can not be null");
this.tests = tests ?? throw new ArgumentNullException("Tests service cannot be null");
this.categories = categories ?? throw new ArgumentNullException("Categories service cannot be null");
this.statuses = statuses ?? throw new ArgumentNullException("Statuses service cannot be null");
this.userManager = userManager ?? throw new ArgumentNullException("User manager cannot be null");
this.cache = memoryCache ?? throw new ArgumentNullException("Cache cannot be null!");
}
public RepositoryAnalyzerViewModel(ITestsService testsService)
{
Commands = UICommand.GenerateFromMessageButton(MessageButton.OK, new DialogService(), MessageResult.OK);
ElapsedTimes = new Dictionary <string, List <TimingModel> >();
Versions = new List <string>();
if (testsService.ActualState.ElapsedTimes == null || testsService.ActualState.ElapsedTimes.Count == 0)
{
return;
}
foreach (var et in testsService.ActualState.ElapsedTimes)
{
ElapsedTimes.Add(et.Key.Version, et.Value.Select(eti => new TimingModel(eti.Name, eti.Time)).ToList());
Versions.Add(et.Key.Version);
}
CurrentVersion = Versions.Last();
}
public TakeTestController
(
IResultService resultService,
IMappingProvider mapper,
ITestsService tests,
IAnswersService answers,
UserManager <User> userManager,
IMemoryCache memoryCache)
{
this.mapper = mapper ?? throw new ArgumentNullException("Mapper can not be null");
this.tests = tests ?? throw new ArgumentNullException("Tests service cannot be null");
this.answers = answers ?? throw new ArgumentNullException("Answers service cannot be null");
this.userManager = userManager ?? throw new ArgumentNullException("User manager cannot be null");
this.cache = memoryCache ?? throw new ArgumentNullException("MemoryCache cannot be null");;
this.resultService = resultService ?? throw new ArgumentNullException("Result service cannot be null");
}
public BoardsController(IMapper mapper,
IProjectsService projectsService,
IBoardsService boardColumnsService,
ISprintsService sprintsService,
IUserStoryService userStoryService,
ITestsService testsService,
ITasksService tasksService,
IBugsService bugsService,
IBurndownDataService burndownDataService)
: base(projectsService)
{
this.mapper = mapper;
this.boardColumnsService = boardColumnsService;
this.sprintsService = sprintsService;
this.userStoryService = userStoryService;
this.testsService = testsService;
this.tasksService = tasksService;
this.bugsService = bugsService;
this.burndownDataService = burndownDataService;
}
protected TestContainerDiscoverer(
IServiceProvider serviceProvider,
ITestsService testsService,
TestSettingsProvider testSettingsProvider,
ITestLogger logger
)
{
Logger = logger;
try
{
TestSettingsProvider = testSettingsProvider;
TestAdapterInfo = CreateTestAdapterInfo();
Containers = new TestContainerList(this);
ServiceProvider = serviceProvider;
_testsService = testsService;
SolutionListener = new SolutionListener(serviceProvider);
SolutionListener.SolutionLoaded += OnSolutionLoaded;
SolutionListener.SolutionUnloaded += OnSolutionUnloaded;
SolutionListener.ProjectChanged += OnSolutionProjectChanged;
SolutionListener.StartListening();
ProjectListener = new ProjectListener(serviceProvider, Logger);
ProjectListener.FileAdded += (source, e) => OnProjectFileAdded(e.Project, e.File);
ProjectListener.FileRemoved += (source, e) => OnProjectFileRemoved(e.Project, e.File);
ProjectListener.FileRenamed += (source, e) => OnProjectFileRenamed(e.Project, e.OldFile, e.NewFile);
ProjectListener.StartListening();
RunScheduler = new Scheduler(250, RunTestsInternal);
RefreshTestContainersScheduler = new Scheduler<string>(250, RefreshTestContainersInternal);
Logger.Debug("TestContainerDiscoverer created");
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
public WorkItemsController(IWorkItemService workItemService,
IBacklogPrioritiesService backlogPrioritiesService,
IProjectsService projectsService,
IMapper mapper,
IUserStoryService userStoryService,
ITasksService tasksService,
ITestsService testsService,
IBugsService bugsService,
ISprintsService sprintsService,
IConfiguration config) : base(projectsService)
{
this.workItemService = workItemService;
this.backlogPrioritiesService = backlogPrioritiesService;
this.mapper = mapper;
this.userStoryService = userStoryService;
this.tasksService = tasksService;
this.testsService = testsService;
this.bugsService = bugsService;
this.sprintsService = sprintsService;
this.config = config;
}
public MainViewModel(INotificationService notificationService,
IRegionManager regionManager,
ILoggingService loggingService,
IFarmIntegrator farmIntegrator,
IConfigSerializer configSerializer,
ILoadingProgressController loadingProgressController,
ITestsService testsService,
IGitWorker gitWorker)
{
Dispatcher = Dispatcher.CurrentDispatcher;
this.notificationService = notificationService;
this.regionManager = regionManager;
this.loggingService = loggingService;
this.farmIntegrator = farmIntegrator;
this.configSerializer = configSerializer;
LoadingProgressController = loadingProgressController;
TestService = testsService;
_GitWorker = gitWorker;
TestService.PropertyChanged += TestService_PropertyChanged;
loggingService.MessageReserved += OnLoggingMessageReserved;
UpdateConfig();
}
public MainViewModel(INotificationService notificationService,
ILoggingService loggingService,
IConfigSerializer configSerializer,
ILoadingProgressController loadingProgressController,
ITestsService testsService,
IGitWorker gitWorker,
IPlatformProvider platformProvider,
IActiveService isActiveService, ITestsService testService)
{
dispatcher = Dispatcher.CurrentDispatcher;
this.notificationService = notificationService;
this.loggingService = loggingService;
this.configSerializer = configSerializer;
this.platformProvider = platformProvider;
this.isActiveService = isActiveService;
this.testService = testService;
this.gitWorker = gitWorker;
obsolescenceTracker = new RepositoryObsolescenceTracker(this.gitWorker, () => _config.Repositories, NoticeRepositoryObsolescenceAsync);
LoadingProgressController = loadingProgressController;
testService = testsService;
testService.PropertyChanged += TestService_PropertyChanged;
loggingService.MessageReserved += OnLoggingMessageReserved;
}
public ATestsController(IWebHostEnvironment environment, IOptions <AppSettings> appSettings, IAppLogger appLogger,
IHubContext <NotificationsHub> notificationHubContext, IHubConnectionManager userConnectionManager,
IDataService dataService,
ICloudStorageService cloudStorageService, IOptions <AdminSettings> adminSettings,
INoticesService noticesService, IMailService mailService,
Web.Services.ISubscribesService subscribesService, ITestsService testsService)
{
_environment = environment;
_appSettings = appSettings.Value;
_logger = appLogger;
_dataService = dataService;
_cloudStorageService = cloudStorageService;
_notificationHubContext = notificationHubContext;
_userConnectionManager = userConnectionManager;
_noticesService = noticesService;
_mailService = mailService;
_subscribesService = subscribesService;
_adminSettings = adminSettings.Value;
_testsService = testsService;
}
public TestsController(UserManager <ApplicationUser> userManager, ITestsService testsService, IQuestionsService quesionsService)
{
this.UserManager = userManager;
this.TestsService = testsService;
this.QuesionsService = quesionsService;
}
public TestsController(ITestsService testsService)
{
_testsService = testsService;
}
public TestController(ITestsService tests)
{
Guard.WhenArgument(tests, nameof(tests)).IsNull().Throw();
this.tests = tests;
}
public TestsController(ITestsService testsService)
{
_testsService = testsService;
}
public static HashSet <string> GetUsedFiles(Dictionary <Repository, List <string> > usedFilesByRep, ITestsService testsService)
{
HashSet <string> usedFiles = new HashSet <string>();
foreach (var usedFileByRep in usedFilesByRep)
{
foreach (string fileRelPath in usedFileByRep.Value)
{
string filePath = testsService.GetResourcePath(usedFileByRep.Key, fileRelPath);
if (File.Exists(filePath))
{
usedFiles.Add(filePath.ToLower());
}
}
}
return(usedFiles);
}
public TestViewModel(ITestsService testsService, PluginRunner runner)
: base(runner)
{
this.testsService = testsService;
}
public StudentsController(ITestsRepository testsRepository, ITestsService testsService)
{
_testsRepository = testsRepository;
_testsService = testsService;
}
public TestsController(ITestsService serv)
{
_testService = serv;
}
public TestsController(ITestsService tests)
{
this.Tests = tests;
}
public ReagentController(IReagentService reagentService, ITestsService testsService)
{
_reagentService = reagentService;
_testsService = testsService;
}
public TestsController(ITestsService service)
//public TestsController()
{
this.service = service;
}
