/// <summary> Add a repository to the collection </summary>
public void Add(ISourceRepository repo)
{
lock (_lockObject)
{
if (_repositoriesByName.ContainsKey(repo.Name))
{
throw new ArgumentException($"A repository with the name '{repo.Name}' already exist", nameof(repo));
}
_repositories.Add(repo);
_repositoriesByName.Add(repo.Name, repo);
if (_useFileListeners != FileListeningMode.None)
{
// Since we still use repo location as key, but can have severla (i know, stupid) we must check so we don't create two file listeners for same location
if (!_fileListeners.ContainsKey(repo.Location))
{
_fileListeners.Add(repo.Location, new DelayedFileSystemWatcher(_useFileListeners == FileListeningMode.IndexOnly?repo.IndexLocation:repo.Location, repo.RefreshLocalStatus));
}
}
repo.RefreshLocalStatus();
repo.RepositoryStatusChanged += OnRepoChangedEventPropagator;
}
// Raise event
OnRepositoryListChanged(new RepositoryEventArgs(repo.Location, RepoStatus.Unknown, repo.LastStatus, repo.Name, RepositoryEventType.Added));
}
public GetCsvFileSourceQueryHandler(
ISourceRepository repository,
ICsvFileSourceAdapter adapter)
{
_repository = repository;
_adapter = adapter;
}
public Synchronizer(ILogger logger, ISourceRepository sourceRepository, ITargetRepository targetRepository, IMergeStrategy mergeStrategy)
{
_logger = logger;
_sourceRepository = sourceRepository;
_targetRepository = targetRepository;
_mergeStrategy = mergeStrategy;
}
public TaskBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
taskGrid.Grid.MultiSelect = false;
this.ExecuteLater(10, () => SwitchCurrentTab(true));
}
private static void CreateController(out ISourceRepository fakeService, out SourceController controller)
{
var fakeContext = new FakeContext("SourceControllerTests");
fakeService = fakeContext.FakeSourceRepository().Object;
controller = new SourceController();
}
public CollectionPreparationHandler(string collectionName, IDestinationRepository destination, ISourceRepository source, ILogger logger)
{
_collectionName = collectionName;
_destination = destination;
_source = source;
_logger = logger;
}
public ICommandStrategyFactory <IButtonCommand> CreateButtonCSF(
IBotClient botClient,
ISourceRepository sourceRepo,
IMetricRepository metricRepo,
IValueRepository valueRepo)
{
var buttonCommands = new List <IButtonCommand>
{
new AddMetricButtonCommand(botClient, sourceRepo),
new ChooseDelMetricButtonCommand(botClient, sourceRepo, metricRepo),
new ChooseDelValueButtonCommand(botClient, metricRepo, valueRepo),
new ChooseMainMetricButtonCommand(botClient, sourceRepo, metricRepo),
new DelMetricButtonCommand(botClient, sourceRepo, metricRepo),
new DelValueButtonCommand(botClient, valueRepo),
new FileMenuButtonCommand(botClient),
new FromJsonButtonCommand(botClient),
new PlotButtonCommand(botClient, metricRepo, valueRepo),
new MetricMenuButtonCommand(botClient),
new SetMainMetricButtonCommand(botClient, metricRepo),
new ShowMetricButtonCommand(botClient, metricRepo),
new ToJsonButtonCommand(botClient, metricRepo, sourceRepo),
new TopMenuButtonCommand(botClient),
};
return(new ButtonCommandStrategyFactory(buttonCommands));
}
public SourceController(ISourceRepository sourceRepository, ITeamRepository teamRepository, ITrackingRepository trackingRepository, ILogger logger)
{
_sourceRepository = sourceRepository;
_teamRepository = teamRepository;
_trackingRepository = trackingRepository;
_logger = logger;
}
public PointwiseControllerFactory(
IArticleRepository articleRepository,
ISourceRepository sourceRepository,
ICategoryRepository categoryRepository)
{
if (articleRepository == null)
{
throw new ArgumentNullException(nameof(articleRepository));
}
if (sourceRepository == null)
{
throw new ArgumentNullException(nameof(sourceRepository));
}
if (categoryRepository == null)
{
throw new ArgumentNullException(nameof(categoryRepository));
}
this.controllerMap = new Dictionary <string, Func <RequestContext, IController> >
{
["Home"] = ctx => new HomeController(),
["Source"] = ctx => new SourceController(sourceRepository),
["Category"] = ctx => new CategoryController(categoryRepository)
};
}
private DBContext()
{
_accounts = new AccountRepository();
_accountTypes = new AccountTypeRepository();
_audits = new AuditRepository();
_categories = new CategoryRepository();
_containers = new ContainerRepository();
_dimensions = new DimensionRepository();
_facilities = new FacilityRepository();
_facilityTypes = new FacilityTypeRepository();
_priorities = new PriorityRepository();
_users = new UserRepository();
_packagingLevels = new PackagingLevelRepository();
_pictures = new PictureRepository();
_projects = new ProjectRepository();
_ratings = new RatingRepository();
_requests = new RequestRepository();
_requestItems = new RequestItemRepository();
_requestItemTypes = new RequestItemTypeRepository();
_roles = new RoleRepository();
_sources = new SourceRepository();
_status = new StatusRepository();
_status = new StatusRepository();
_tasks = new TaskRespository();
_dcIssueItems = new DCIssueItemRepository();
_dcIssues = new DCIssueRepository();
_dcIssuesFacilities = new DCIssueFacilityRepository();
_failedSamples = new FailedSampleRepository();
_requestCategories = new RequestCategoryRepository();
}
public PurchaseTransactionRepository(DatabaseContext dbContext,
IAppConfigRepository appConfigRepository,
IBalingStationRepository balingStationRepository,
IUserAccountRepository userAccountRepository,
IPrintLogRepository printLogRepository,
IVehicleRepository vehicleRepository,
ISupplierRepository supplierRepository,
IRawMaterialRepository rawMaterialRepository,
ISourceRepository sourceRepository,
IMoistureReaderRepository moistureReaderRepository,
IMoistureSettingsRepository mcRepository,
IBaleTypeRepository baleTypeRepository,
IVehicleDeliveryRestrictionRepository vehicleDeliveryRestrictionRepository,
IAuditLogEventRepository auditLogEventRepository,
IAuditLogRepository auditLogRepository,
IPurchaseOrderRepository purchaseOrderRepository)
{
this.dbContext = dbContext;
this.appConfigRepository = appConfigRepository;
this.balingStationRepository = balingStationRepository;
this.userAccountRepository = userAccountRepository;
this.printLogRepository = printLogRepository;
this.vehicleRepository = vehicleRepository;
this.supplierRepository = supplierRepository;
this.rawMaterialRepository = rawMaterialRepository;
this.sourceRepository = sourceRepository;
this.moistureReaderRepository = moistureReaderRepository;
this.mcRepository = mcRepository;
this.baleTypeRepository = baleTypeRepository;
this.vehicleDeliveryRestrictionRepository = vehicleDeliveryRestrictionRepository;
this.auditLogEventRepository = auditLogEventRepository;
this.auditLogRepository = auditLogRepository;
this.purchaseOrderRepository = purchaseOrderRepository;
}
public TaskBrowser
(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
taskGrid.Grid.MultiSelect = false;
this.ExecuteLater(10, () => SwitchCurrentTab(true));
}
public AccountController(ISourceRepository repository, IConfiguration configuration,
UserManager <IdentityUser> userMgr, SignInManager <IdentityUser> signInMgr, IPasswordHasher <IdentityUser> passwordHash)
{
_repository = repository;
_userManager = userMgr;
_signInManager = signInMgr;
_passwordHasher = passwordHash;
}
public BuildInspector(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
logViewer.InitializeDefaults();
logViewer.IsReadOnly = true;
logViewer.LongLines.EdgeMode = EdgeMode.None;
}
public CreateSourceCommand(ISourceRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(_repository));
}
_repository = repository;
}
public Poller(ISourceRepository sourceRepository,IChat chat,ILogger logger,IMessageGenerator messageGenerator)
{
_sourceRepository = sourceRepository;
_chat = chat;
_logger = logger;
_messageGenerator = messageGenerator;
_pollingInterval = int.Parse(ConfigurationManager.AppSettings["PollingInterval"]);
}
public GetSourceListQuery(ISourceRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_repository = repository;
}
public RevisionBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
_revisionInspector = new RevisionInspector(taskRepository, sourceRepository, shelvesetRepository, buildRepository);
InitializeComponent();
activityRevisions.Grid.MultiSelect = false;
}
public CollectionService(IUnitOfWork UnitOfWork, CacheManager <Collection> CollectionCacheManager,
CacheManager <Source> SourceCacheManager)
{
collectionRepository = UnitOfWork.CollectionRepository;
sourceRepository = UnitOfWork.SourceRepository;
collectionCacheManager = (CollectionCacheManager)CollectionCacheManager;
sourceCacheManager = (SourceCacheManager)SourceCacheManager;
}
public RuntimeContext(IServiceProvider provider, ISourceRepository repository, ILogger logger, IStringLocalizer localizer, string user)
{
this.Localizer = localizer;
this.Logger = logger;
this.User = user;
this.Provider = provider;
this.Repository = repository;
this.TrackerProvider = new ActionTrackerProvider(repository, User);
}
public RevisionBrowser
(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
_revisionInspector = new RevisionInspector(taskRepository, sourceRepository, shelvesetRepository, buildRepository);
InitializeComponent();
activityRevisions.Grid.MultiSelect = false;
}
public async Task <string> GenerateCoverImage(Book book, uint pageIndex, ISourceRepository sourceRepository, StorageFolder storageFolder, StorageFile pdfFile)
{
try
{
// var pdfFile = await storageFolder.GetFileAsync(book.FileName);
try
{
_pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile);
}
catch (Exception)
{
return(null);
}
if (_pdfDocument == null || _pdfDocument.PageCount <= 0)
{
return(null);
}
//Get Pdf page
using (var pdfPage = _pdfDocument.GetPage(pageIndex))
{
if (pdfPage == null)
{
return(null);
}
// next, generate a bitmap of the page
var thumbfolder = await Globals.GetCoversFolder();
var pngFile = await thumbfolder.CreateFileAsync(Utils.GenerateRandomString() + ".png", CreationCollisionOption.ReplaceExisting);
if (pngFile == null)
{
return(null);
}
using (var randomStream = await pngFile.OpenAsync(FileAccessMode.ReadWrite))
{
await pdfPage.RenderToStreamAsync(randomStream, new PdfPageRenderOptions()
{
DestinationHeight = 340, DestinationWidth = 240
});
await randomStream.FlushAsync();
}
return(pngFile.Path);
}
}
catch (Exception)
{
//rootPage.NotifyUser("Error: " + err.Message, NotifyType.ErrorMessage);
return(null);
}
}
protected AbstractHistoryComponent(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
{
_taskRepository = taskRepository;
_sourceRepository = sourceRepository;
_shelvesetRepository = shelvesetRepository;
_buildRepository = buildRepository;
this.GotFocus += AbstractHistoryComponent_GotFocus;
}
public BuildInspector
(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
logViewer.InitializeDefaults();
logViewer.IsReadOnly = true;
logViewer.LongLines.EdgeMode = EdgeMode.None;
}
public SourceController(
ILoggerFactory loggerFactory,
ISourceRepository repository,
IMapperService mapperService)
{
_logger = loggerFactory.CreateLogger <SourceController>();
_repository = repository;
_mapperService = mapperService;
}
public ProjectController(IServiceProvider provide, IStringLocalizer <ProjectController> controllerLocalizer, ISourceRepository repository, IConfiguration configuration, UserManager <IdentityUser> userManager, ILoggerFactory loggerFactory, ProjectModuleViewRegistry modulVIewDescriptors)
{
_loggerFactory = loggerFactory;
_reposiotry = repository;
_configuration = configuration;
_userManager = userManager;
_modulVIewDescriptors = modulVIewDescriptors;
_context = new RuntimeContext(provide, _reposiotry, null, null, User.GetUserId());
}
public SourceScanner(ISourceRepository sourceRepository,
ILogger <SourceScanner> logger,
IHttpClientFactory clientFactory,
IChannelRepository channelRepository)
{
_sourceRepository = sourceRepository;
_logger = logger;
_clientFactory = clientFactory;
_channelRepository = channelRepository;
}
public BranchBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
_revisionBrowser = new RevisionBrowser(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
_changeCommitter = new ChangeCommitter(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
InitializeComponent();
branchGrid.Grid.MultiSelect = false;
this.ExecuteLater(10, () => SwitchCurrentTab(true));
}
public ActionResult <Source> GetSourceById([FromServices] ISourceRepository _sourceRepository, int id)
{
var source = _sourceRepository.Get(id);
if (source != null)
{
return(Ok(source));
}
return(NotFound(new { message = "Source Id not found." }));
}
protected AbstractHistoryComponent
(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
{
_taskRepository = taskRepository;
_sourceRepository = sourceRepository;
_shelvesetRepository = shelvesetRepository;
_buildRepository = buildRepository;
this.GotFocus += AbstractHistoryComponent_GotFocus;
}
private ListViewItem RepoToRow(ISourceRepository repo)
{
var ret = new ListViewItem(new string[5]);
ret.SubItems[columnName.Index].Text = repo.Name;
ret.SubItems[columnStatus.Index].Text = repo.LastStatus.ToString();
ret.SubItems[columnPath.Index].Text = repo.Location;
ret.SubItems[columnLastUpdated.Index].Text = repo.LastStatusAt.ToString();
ret.SubItems[columnSchedule.Index].Text = repo.UpdateSchedule.ToString();
return(ret);
}
public BranchBrowser
(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
_revisionBrowser = new RevisionBrowser(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
_changeCommitter = new ChangeCommitter(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
InitializeComponent();
branchGrid.Grid.MultiSelect = false;
this.ExecuteLater(10, () => SwitchCurrentTab(true));
}
public ChangeCommitter(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
changeInspector.ActionsForChangesFunction = (branchId, changeIds) =>
GetActionsForChanges(branchId, changeIds, _sourceRepository.GetActionsForPendingChanges);
changeInspector.ChangesFunction = _sourceRepository.GetPendingChanges;
changeInspector.ComputeDifferencesFunction = _sourceRepository.ComputePendingDifferences;
changeInspector.MessageFunction = null;
changeInspector.ChangeLog.KeyDown += ChangeLog_KeyDown;
}
public AdminApplicationService(IPermissionRepository permissionRepository,
IRoleRepository roleRepository,
IUserRepository userRepository,
ISourceRepository sourceRepository,
IDestinationRepository destinationRepository)
{
_permissionRepository = permissionRepository;
_roleRepository = roleRepository;
_userRepository = userRepository;
_sourceRepository = sourceRepository;
_destinationRepository = destinationRepository;
}
public TabbedMain()
{
InitializeComponent();
_logRepository = new LogRepository(_statusMessages);
mainPanel.ActiveContentChanged += mainPanel_ActiveContentChanged;
mainPanel.ContentRemoved += mainPanel_ContentRemoved;
Load += Main_Load;
FormClosing += Main_Closing;
_statusThrottle = new Throttler(this, 100, UpdateStatusBar);
_statusCleaner.Tick += statusCleaner_Tick;
var programDirectoryInfo = GetExecutableDirectory();
var programFolder = programDirectoryInfo.FullName;
var repositoriesFolder = programFolder.CombinePath("Repositories");
if (Directory.Exists(repositoriesFolder))
{
var catalog = new DirectoryCatalog(repositoriesFolder);
var container = new CompositionContainer(catalog);
_taskRepository = TryGetExportedValueOrDefault <ITaskRepository>(container, this);
_sourceRepository = TryGetExportedValueOrDefault <ISourceRepository>(container, this);
_shelvesetRepository = TryGetExportedValueOrDefault <IShelvesetRepository>(container, this);
_buildRepository = TryGetExportedValueOrDefault <IBuildRepository>(container, this);
}
#if DEBUG
_taskRepository = _taskRepository ?? new Core.Mock.TaskRepository();
_sourceRepository = _sourceRepository ?? new Core.Mock.SourceRepository();
_shelvesetRepository = _shelvesetRepository ?? new Core.Mock.ShelvesetRepository();
_buildRepository = _buildRepository ?? new Core.Mock.BuildRepository();
#endif
if (_sourceRepository != null)
{
_sourceRepository.Log = this;
}
if (_taskRepository != null)
{
_taskRepository.Log = this;
}
if (_shelvesetRepository != null)
{
_shelvesetRepository.Log = this;
}
if (_buildRepository != null)
{
_buildRepository.Log = this;
}
RegisterComponents();
mainPanel.DocumentStyle = DocumentStyle.DockingWindow;
}
private void PullRepoTask(ISourceRepository repo)
{
var previousStatus = repo.LastStatus;
repo.Update(true);
var eventArgs = new RepositoryEventArgs(repo.Location, previousStatus, repo.LastStatus, repo.Name, RepositoryEventType.Updated);
OnRepositoryUpdated(eventArgs);
//if (previousStatus != repo.LastStatus)
// OnRepositoryStatusChanged(eventArgs);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
ISourceRepository sourceRepository)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseMvc();
sourceRepository.EnsureData();
}
public ShelvesetInspector(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
InitializeComponent();
changeInspector.ChangeLog.IsReadOnly = true;
changeInspector.ChangeLog.LongLines.EdgeMode = EdgeMode.None;
changeInspector.ActionsForChangesFunction = (branchId, changeIds) =>
GetActionsForChanges(branchId, changeIds, _shelvesetRepository.GetActionsForShelvesetChanges);
changeInspector.ChangesFunction = _shelvesetRepository.GetShelvesetChanges;
changeInspector.ComputeDifferencesFunction = _shelvesetRepository.ComputeShelvesetDifferences;
changeInspector.MessageFunction = _shelvesetRepository.GetShelvesetMessage;
}
public async Task<string> GenerateCoverImage(Book book, uint pageIndex, ISourceRepository sourceRepository, StorageFolder storageFolder, StorageFile pdfFile)
{
try
{
// var pdfFile = await storageFolder.GetFileAsync(book.FileName);
try
{
_pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile);
}
catch (Exception)
{
return null;
}
if (_pdfDocument == null || _pdfDocument.PageCount <= 0) return null;
//Get Pdf page
using (var pdfPage = _pdfDocument.GetPage(pageIndex))
{
if (pdfPage == null) return null;
// next, generate a bitmap of the page
var thumbfolder = await Globals.GetCoversFolder();
var pngFile = await thumbfolder.CreateFileAsync(Utils.GenerateRandomString() + ".png", CreationCollisionOption.ReplaceExisting);
if (pngFile == null) return null;
using (var randomStream = await pngFile.OpenAsync(FileAccessMode.ReadWrite))
{
await pdfPage.RenderToStreamAsync(randomStream, new PdfPageRenderOptions() { DestinationHeight = 340, DestinationWidth = 240 });
await randomStream.FlushAsync();
}
return pngFile.Path;
}
}
catch (Exception)
{
//rootPage.NotifyUser("Error: " + err.Message, NotifyType.ErrorMessage);
return null;
}
}
public StylizeEngine(IConfigurationParser configurationParser)
{
if (configurationParser == null) { throw new ArgumentNullException(nameof(configurationParser)); }
Log.WriteVerbose("Initializing MEF");
var catalog = new AggregateCatalog(
new AssemblyCatalog(Assembly.GetExecutingAssembly().Location));
string currentDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
foreach (string exportAssemblyName in configurationParser.ExportAssemblyNames)
{
string exportAssemblyPath = Path.IsPathRooted(exportAssemblyName)
? exportAssemblyName
: Path.Combine(currentDirectory, exportAssemblyName);
catalog.Catalogs.Add(new AssemblyCatalog(exportAssemblyPath));
}
this.container = new CompositionContainer(catalog);
IReadOnlyList<IOption> supportedOptions = this.container.GetExportedValues<IOption>(
ExportStylizeOptionAttribute.OptionContractName).ToList();
Log.WriteVerbose("Parsing configuration");
StylizeConfiguration configuration = configurationParser.ParseConfiguration(supportedOptions);
this.globalOptions = configuration.GlobalOptions;
Log.WriteVerbose("Loading exports");
if (!String.IsNullOrEmpty(configuration.RepositoryName))
{
this.repository = this.container.GetExportedValue<ISourceRepository>(configuration.RepositoryName);
this.container.ComposeExportedValue(ExportSourceRepositoryAttribute.CurrentName, this.repository);
}
this.exclusionMatchers = this.container.GetExports<IDocumentMatcher, INamedMetadata>(
configuration.ExclusionMatchers);
IReadOnlyList<Export<IStyleRule, StyleRuleMetadata>> rules =
this.container.GetExports<IStyleRule, StyleRuleMetadata>(configuration.Rules);
this.languageRuleMap = OrderAndMapRules(rules);
Log.WriteVerbose("Engine initialized");
}
public Importer(IBookRepository bookRepository, ISourceRepository sourceRepository)
{
_sourcerepo = sourceRepository;
_bookService = new BookService(bookRepository);
_sourceService = new SourceService(sourceRepository);
ProgressService.RegisterPublisher(this);
Worker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
Worker.DoWork += Worker_DoWork;
Worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
Worker.ProgressChanged += Worker_ProgressChanged;
WorkerCleanup = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
WorkerCleanup.DoWork += WorkerCleanup_DoWork;
WorkerCleanup.RunWorkerCompleted += WorkerCleanup_RunWorkerCompleted;
WorkerCleanup.ProgressChanged += WorkerCleanup_ProgressChanged;
}
public TutorialService(ITutorialRepository tutorialRepository, IExerciceRepository exerciceRepository, ISourceRepository sourceRepository)
{
_tutorialRepository = tutorialRepository;
_exerciceRepository = exerciceRepository;
_sourceRepository = sourceRepository;
}
public SourceServiceTests()
{
_sourceRepository = Substitute.For<ISourceRepository>();
_service = new SourceService(_sourceRepository);
}
public LogService(ISourceRepository sourceRepository, IBatchRepository batchRepository, ILogEventRepository eventRepository)
{
_sourceRepository = sourceRepository;
_batchRepository = batchRepository;
_eventRepository = eventRepository;
}
public CompareService()
{
_sourceRepository = ClassFactory.GetInstance<ISourceRepository>();
_TargetRepository = ClassFactory.GetInstance<ITargetRepository>();
}
public ExerciceService(IExerciceRepository exerciceRepository, ISourceRepository sourceRepository)
{
_sourceRepository = sourceRepository;
_exerciceRepository = exerciceRepository;
}
public void InitializeTest()
{
pushPassedToSource = null;
rootPassedToSource = null;
fakeSourceRepository = new SourceControlSync.Domain.Fakes.StubISourceRepository()
{
DownloadChangesAsyncPushStringCancellationToken = (push, root, token) =>
{
token.ThrowIfCancellationRequested();
pushPassedToSource = push;
rootPassedToSource = root;
foreach (var commit in push.Commits)
{
commit.Changes = Enumerable.Empty<ItemChange>();
}
return Task.FromResult(0);
}
};
commitsPassedToCalculator = null;
changesReturnedByCalculator = null;
fakeChangesCalculator = new SourceControlSync.Domain.Fakes.StubIChangesCalculator()
{
CalculateItemChangesIEnumerableOfCommit = (commits) =>
{
commitsPassedToCalculator = commits;
changesReturnedByCalculator = commits.SelectMany(commit => commit.Changes).ToList();
},
ItemChangesGet = () => { return changesReturnedByCalculator; }
};
changesPassedToDestination = null;
rootPassedToDestination = null;
fakeDestinationRepository = new SourceControlSync.Domain.Fakes.StubIDestinationRepository()
{
PushItemChangesAsyncIEnumerableOfItemChangeString = (changes, root) =>
{
changesPassedToDestination = changes;
rootPassedToDestination = root;
return Task.FromResult(0);
},
ExecutedCommandsGet = () => { return new SourceControlSync.Domain.Fakes.StubIExecutedCommands(); }
};
var fakeClock = new SourceControlSync.Domain.Fakes.StubIClock();
fakeChangesReport = new ChangesReport(fakeClock);
fakeErrorReport = new ErrorReport(fakeClock);
}
public DllDebugger(IMessageSubscriber subscriber, ISourceRepository sourceRepository)
{
this.subscriber = subscriber;
this.sourceRepository = sourceRepository;
NumberOfModulesLoaded = 0;
}
public SourceService(ISourceRepository repository)
{
_repository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="SourceService"/> class.
/// </summary>
/// <param name="sourceRepository">The source repository.</param>
public SourceService(ISourceRepository sourceRepository)
{
_sourceRepository = sourceRepository;
_sourcesByType = new Dictionary<SourceType, List<Source>>();
}
public SourceController(ISourceRepository sourceRepository)
{
_sourceRepository = sourceRepository;
}
