public void ShouldSyncLibraryWhenShareImportCompletedIsWithSuccess() { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); SetSettings(mediaPortalServices, new TraktPluginSettings { IsAutomaticLibrarySyncEnabled = true, ShowAutomaticSyncNotifications = true }); IAsynchronousMessageQueue messageQueue = GetMockedMsgQueue(mediaPortalServices); IFileOperations fileOperations = Substitute.For <IFileOperations>(); fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true); ILibrarySynchronization librarySynchronization = Substitute.For <ILibrarySynchronization>(); librarySynchronization.SyncMovies().Returns(new TraktSyncMoviesResult()); librarySynchronization.SyncSeries().Returns(new TraktSyncEpisodesResult()); TraktSyncHandlerManager traktScrobbleHandler = new TraktSyncHandlerManager(mediaPortalServices, librarySynchronization, fileOperations); // Act // send share import completed message messageQueue.MessageReceivedProxy += Raise.Event <MessageReceivedHandler>(new AsynchronousMessageQueue(new object(), new[] { "ContentDirectory" }), GetSystemMessageForMessageType(ContentDirectoryMessaging.MessageType.ShareImportCompleted)); // Assert mediaPortalServices.GetTraktNotificationModel().Received().ShowNotification(Arg.Any <TraktSyncLibrarySuccessNotification>(), Arg.Any <TimeSpan>()); }
public void ShouldEnableTraktSyncHandlerWhenSettingsChange() { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); TraktPluginSettings settings = new TraktPluginSettings { IsAutomaticLibrarySyncEnabled = false }; ITraktSettingsChangeWatcher settingsChangeWatcher = Substitute.For <ITraktSettingsChangeWatcher>(); settingsChangeWatcher.TraktSettings.Returns(settings); mediaPortalServices.GetTraktSettingsWatcher().Returns(settingsChangeWatcher); ISettingsManager settingsManager = Substitute.For <ISettingsManager>(); settingsManager.Load <TraktPluginSettings>().Returns(settings); mediaPortalServices.GetSettingsManager().Returns(settingsManager); ILibrarySynchronization librarySynchronization = Substitute.For <ILibrarySynchronization>(); IFileOperations fileOperations = Substitute.For <IFileOperations>(); fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true); TraktSyncHandlerManager traktSyncHandler = new TraktSyncHandlerManager(mediaPortalServices, librarySynchronization, fileOperations); // Act settings.IsAutomaticLibrarySyncEnabled = true; settingsChangeWatcher.TraktSettingsChanged += Raise.Event(); // Assert Assert.True(traktSyncHandler.IsActive); }
public Core(IRequestExecuter requestExecuter, ICoreRequestGenerator requestGenerator, Options options) { OAuth2 = new OAuth2(requestExecuter, requestGenerator.OAuth2, options); Accounts = new Accounts(requestExecuter, requestGenerator.Accounts); Metadata = new Metadata(requestExecuter, requestGenerator.Metadata, options); FileOperations = new FileOperations(requestExecuter, requestGenerator.FileOperations, options); }
public LibrarySynchronization(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, ITraktCache traktCache, IFileOperations fileOperations) { _mediaPortalServices = mediaPortalServices; _traktClient = traktClient; _traktCache = traktCache; _fileOperations = fileOperations; }
public Core(RequestExecuter requestExecuter, ICoreRequestGenerator requestGenerator, Options options) { OAuth2 = new OAuth2(requestExecuter, requestGenerator.OAuth2, options); Accounts = new Accounts(requestExecuter, requestGenerator.Accounts); Metadata = new Metadata(requestExecuter, requestGenerator.Metadata, options); FileOperations = new FileOperations(requestExecuter, requestGenerator.FileOperations, options); }
public void ShouldFailToAuthorizeUserWhenTraktAuthorizationThrowsException() { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); ITraktClient traktClient = Substitute.For <ITraktClient>(); traktClient.GetAuthorization(Arg.Any <string>()).Throws(new TraktException("Pin code is not valid")); ILibrarySynchronization librarySynchronization = Substitute.For <ILibrarySynchronization>(); IFileOperations fileOperations = Substitute.For <IFileOperations>(); fileOperations.DirectoryExists(DataPath).Returns(true); string expectedStatus = "[Trakt.AuthorizationFailed]"; TraktSetupModel setupModel = new TraktSetupModel(mediaPortalServices, traktClient, librarySynchronization, fileOperations); // Act setupModel.AuthorizeUser(); string actualStatus = setupModel.TestStatus; // Assert Assert.Equal(expectedStatus, actualStatus); Assert.False(setupModel.IsUserAuthorized); }
public void GetCollectedMovies(List <ITraktCollectionMovie> onlineCollectedMovies, ITraktSyncLastActivities onlineLastSyncActivities, int expectedCollectedMoviesCount) { // Arrange ITraktClient traktClient = Substitute.For <ITraktClient>(); traktClient.GetCollectedMovies().Returns(onlineCollectedMovies); traktClient.GetLastActivities().Returns(onlineLastSyncActivities); IFileOperations fileOperations = Substitute.For <IFileOperations>(); SetFileOperationsForFile(fileOperations, DataPath, FileName.LastActivity.Value); SetFileOperationsForFile(fileOperations, DataPath, FileName.CollectedMovies.Value); SetFileOperationsForFile(fileOperations, DataPath, FileName.WatchedMovies.Value); IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); // Act ITraktCache traktCache = new TraktCache(mediaPortalServices, traktClient, fileOperations); TraktMovies traktMovies = traktCache.RefreshMoviesCache(); // Assert int actualCollectedMoviesCount = traktMovies.Collected.Count(); Assert.Equal(expectedCollectedMoviesCount, actualCollectedMoviesCount); }
public SettingsFactory(IFileOperations fileManager, string instellingenFileName, string masksFileName) { _fileManager = fileManager; _baseDir = Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath); _instellingenFileName = instellingenFileName; _masksFileName = masksFileName; }
private void SetFileOperationsForFile(IFileOperations fileOperations, string path, string fileName) { fileOperations.FileExists(Arg.Is <string>(x => x.Equals(Path.Combine(path, fileName)))) .Returns(true); fileOperations.FileReadAllText(Arg.Is <string>(x => x.Equals(Path.Combine(path, fileName)))) .Returns(File.ReadAllText(TestUtility.GetTestDataPath(Path.Combine(@"Cache\", fileName)), Encoding.UTF8)); }
public void StartScrobble(TraktPluginSettings settings, MediaItem mediaItem, ITraktClient traktClient, ITraktNotification notification) { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); SetSettings(mediaPortalServices, settings); SetPlayerAndContentDirForMovie(mediaPortalServices, mediaItem); IAsynchronousMessageQueue messageQueue = GetMockedMsgQueue(mediaPortalServices); IFileOperations fileOperations = Substitute.For <IFileOperations>(); fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true); TraktScrobbleHandlerManager traktScrobbleHandler = new TraktScrobbleHandlerManager(mediaPortalServices, traktClient, fileOperations); TraktScrobbleStartedNotification expectedNotification = (TraktScrobbleStartedNotification)notification; // Act // start the player messageQueue.MessageReceivedProxy += Raise.Event <MessageReceivedHandler>(new AsynchronousMessageQueue(new object(), new[] { "PlayerManager" }), GetSystemMessageForMessageType(PlayerManagerMessaging.MessageType.PlayerStarted)); // Assert mediaPortalServices.GetTraktNotificationModel().Received() .ShowNotification(Arg.Is <TraktScrobbleStartedNotification>(x => x.IsSuccess == expectedNotification.IsSuccess && x.Message == expectedNotification.Message && x.ActionType == expectedNotification.ActionType && x.Progress == expectedNotification.Progress && x.SuperLayerScreenName == expectedNotification.SuperLayerScreenName), Arg.Any <TimeSpan>()); }
public void EnableTraktScrobbleHandlerWhenUserChanged() { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); mediaPortalServices.GetTraktUserHomePath().Returns(DataPath); TraktPluginSettings settings = new TraktPluginSettings { IsScrobbleEnabled = false }; ITraktSettingsChangeWatcher settingsChangeWatcher = Substitute.For <ITraktSettingsChangeWatcher>(); settingsChangeWatcher.TraktSettings.Returns(settings); mediaPortalServices.GetTraktSettingsWatcher().Returns(settingsChangeWatcher); IUserMessageHandler userMessageHandler = Substitute.For <IUserMessageHandler>(); mediaPortalServices.GetUserMessageHandler().Returns(userMessageHandler); ITraktClient traktClient = Substitute.For <ITraktClient>(); IFileOperations fileOperations = Substitute.For <IFileOperations>(); fileOperations.FileExists(Path.Combine(DataPath, FileName.Authorization.Value)).Returns(true); TraktScrobbleHandlerManager traktScrobbleHandler = new TraktScrobbleHandlerManager(mediaPortalServices, traktClient, fileOperations); // Act settings.IsScrobbleEnabled = true; userMessageHandler.UserChangedProxy += Raise.Event(); // Assert Assert.True(traktScrobbleHandler.IsActive); }
public FileFinder(IFileOperations fileManager, string atDir, bool itemsHaveSubContent, bool askCached) { _fileManager = fileManager; _atDir = atDir; _itemsHaveSubContent = itemsHaveSubContent; _cached = askCached; }
public SubtitleDownloaderWrapper(ISubtitleDownloader downloader, IEpisodeParser nameParser, ILogger logger, IFileOperations fileOperations) { _downloader = downloader; _nameParser = nameParser; _logger = logger; _fileOperations = fileOperations; }
public FileContent(IFileOperations fileManager, string filePath) { _fileManager = fileManager; _filePath = filePath; Type = _filePath != null?Path.GetExtension(_filePath).Substring(1) : string.Empty; }
/// <summary> /// Lists all of the files in Task directories on the specified Compute Node. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='nextPageLink'> /// The NextLink from the previous successful call to List operation. /// </param> /// <param name='fileListFromComputeNodeNextOptions'> /// Additional parameters for the operation /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <IPage <NodeFile> > ListFromComputeNodeNextAsync(this IFileOperations operations, string nextPageLink, FileListFromComputeNodeNextOptions fileListFromComputeNodeNextOptions = default(FileListFromComputeNodeNextOptions), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ListFromComputeNodeNextWithHttpMessagesAsync(nextPageLink, fileListFromComputeNodeNextOptions, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public ProfilingActionsModel( IProfileRepository profileRepository, IFileOperations fileOperations, IImplicationRuleValidator ruleValidator, ILinguisticVariableValidator variableValidator, IImplicationRuleCreator ruleCreator, ILinguisticVariableCreator variableCreator, IKnowledgeBaseValidator knowledgeValidator) { _profileRepository = profileRepository ?? throw new ArgumentNullException(nameof(profileRepository)); _fileOperations = fileOperations ?? throw new ArgumentNullException(nameof(fileOperations)); _ruleValidator = ruleValidator ?? throw new ArgumentNullException(nameof(ruleValidator)); _variableValidator = variableValidator ?? throw new ArgumentNullException(nameof(variableValidator)); _ruleCreator = ruleCreator ?? throw new ArgumentNullException(nameof(ruleCreator)); _variableCreator = variableCreator ?? throw new ArgumentNullException(nameof(variableCreator)); _knowledgeValidator = knowledgeValidator ?? throw new ArgumentNullException(nameof(knowledgeValidator)); AddProfileCommand = new RelayCommand(obj => OpenAddProfileForm(), obj => true); RemoveProfileCommand = new RelayCommand(obj => RemoveProfile(), obj => SelectedProfile != null); CreateProfileCommand = new RelayCommand(obj => CreateProfile(), obj => !string.IsNullOrEmpty(NewProfileName)); CloseCreateProfileCommand = new RelayCommand(obj => CloseCreateProfileForm(), obj => true); UpdateProfileCommand = new RelayCommand(obj => OpenUpdateProfileForm(), obj => true); CloseUpdateProfileCommand = new RelayCommand(obj => CloseUpdateProfileForm(), obj => true); GetRulesFromFileCommand = new RelayCommand(obj => GetRulesFromFile(), obj => true); GetVariablesFromFileCommand = new RelayCommand(obj => GetVariablesFromFile(), obj => true); StartImportFromFilesCommand = new RelayCommand(obj => StartImportFromFiles(), obj => !string.IsNullOrEmpty(RuleFilePath) && !string.IsNullOrEmpty(VariableFilePath)); ImportRuleFromInputCommand = new RelayCommand(obj => ImportRuleFromInput(), obj => !string.IsNullOrEmpty(UpdatingInput)); ImportVariableFromInputCommand = new RelayCommand(obj => ImportVariableFromInput(), obj => !string.IsNullOrEmpty(UpdatingInput)); CommitProfileCommand = new RelayCommand(obj => CommitProfile(), obj => true); CloseValidationResultsCommand = new RelayCommand(obj => CloseValidationResultsForm(), obj => true); ValidationResults = new ObservableCollection <string>(); Profiles = new ObservableCollection <InferenceProfileModel>(); }
/// <summary> /// Deletes the specified Task file from the Compute Node where the Task ran. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='jobId'> /// The ID of the Job that contains the Task. /// </param> /// <param name='taskId'> /// The ID of the Task whose file you want to delete. /// </param> /// <param name='filePath'> /// The path to the Task file or directory that you want to delete. /// </param> /// <param name='recursive'> /// Whether to delete children of a directory. If the filePath parameter /// represents a directory instead of a file, you can set recursive to true to /// delete the directory and all of the files and subdirectories in it. If /// recursive is false then the directory must be empty or deletion will fail. /// </param> /// <param name='fileDeleteFromTaskOptions'> /// Additional parameters for the operation /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <FileDeleteFromTaskHeaders> DeleteFromTaskAsync(this IFileOperations operations, string jobId, string taskId, string filePath, bool?recursive = default(bool?), FileDeleteFromTaskOptions fileDeleteFromTaskOptions = default(FileDeleteFromTaskOptions), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.DeleteFromTaskWithHttpMessagesAsync(jobId, taskId, filePath, recursive, fileDeleteFromTaskOptions, null, cancellationToken).ConfigureAwait(false)) { return(_result.Headers); } }
public TraktSetupModel(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, ILibrarySynchronization librarySynchronization, IFileOperations fileOperations) { _mediaPortalServices = mediaPortalServices; _traktClient = traktClient; _fileOperations = fileOperations; _librarySynchronization = librarySynchronization; }
public void AddWatchedEpisodeToTraktIfMediaLibraryAvailable(IList <MediaItem> databaseEpisodes, IList <EpisodeWatched> traktEpisodes, int?expectedEpisodesCount) { // Arrange IMediaPortalServices mediaPortalServices = GetMockMediaPortalServices(databaseEpisodes); ITraktClient traktClient = Substitute.For <ITraktClient>(); traktClient.AddCollectionItems(Arg.Any <ITraktSyncCollectionPost>()).Returns(new TraktSyncCollectionPostResponse()); traktClient.AddWatchedHistoryItems(Arg.Any <ITraktSyncHistoryPost>()).Returns( new TraktSyncHistoryPostResponse { Added = new TraktSyncPostResponseGroup { Episodes = expectedEpisodesCount } }); TraktAuthorization authorization = Substitute.For <TraktAuthorization>(); authorization.AccessToken = "ValidToken"; traktClient.TraktAuthorization.Returns(authorization); ITraktCache traktCache = Substitute.For <ITraktCache>(); traktCache.RefreshSeriesCache().Returns(new TraktEpisodes { Watched = traktEpisodes, UnWatched = new List <Episode>(), Collected = new List <EpisodeCollected>() }); IFileOperations fileOperations = Substitute.For <IFileOperations>(); ILibrarySynchronization librarySynchronization = new LibrarySynchronization(mediaPortalServices, traktClient, traktCache, fileOperations); // Act TraktSyncEpisodesResult result = librarySynchronization.SyncSeries(); // Assert Assert.Equal(expectedEpisodesCount, result.AddedToTraktWatchedHistory); }
public SettingsFactory(IFileOperations fileManager, string instellingenFileName, string masksFileName) { _fileManager = fileManager; _baseDir = Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath); // TODO alternatief voor vinden _instellingenFileName = instellingenFileName; _masksFileName = masksFileName; }
public void MarkMovieAsUnwatchedIfMediaLibraryAvailable(List <MediaItem> databaseMovies, List <Movie> traktMovies, int expectedMoviesCount) { // Arrange IMediaPortalServices mediaPortalServices = GetMockMediaPortalServices(databaseMovies); ITraktClient traktClient = Substitute.For <ITraktClient>(); traktClient.AddCollectionItems(Arg.Any <ITraktSyncCollectionPost>()).Returns(new TraktSyncCollectionPostResponse()); traktClient.AddWatchedHistoryItems(Arg.Any <ITraktSyncHistoryPost>()).Returns(new TraktSyncHistoryPostResponse()); TraktAuthorization authorization = Substitute.For <TraktAuthorization>(); authorization.AccessToken = "ValidToken"; traktClient.TraktAuthorization.Returns(authorization); ITraktCache traktCache = Substitute.For <ITraktCache>(); traktCache.RefreshMoviesCache().Returns(new TraktMovies { UnWatched = traktMovies, Watched = new List <MovieWatched>(), Collected = new List <MovieCollected>() }); IFileOperations fileOperations = Substitute.For <IFileOperations>(); ILibrarySynchronization librarySynchronization = new LibrarySynchronization(mediaPortalServices, traktClient, traktCache, fileOperations); // Act TraktSyncMoviesResult result = librarySynchronization.SyncMovies(); // Assert Assert.Equal(expectedMoviesCount, result.MarkedAsUnWatchedInLibrary); }
public void Should_BackupTwoEpisodes_When_FourEpisodesCollectedAndFourWatched_WithDuplicatedEpisodeNumbers() { // Arrange IMediaPortalServices mediaPortalServices = Substitute.For <IMediaPortalServices>(); IContentDirectory contentDirectory = Substitute.For <IContentDirectory>(); IList <MediaItem> databaseMediaItems = new List <MediaItem> { new MockedDatabaseEpisode("272127", 1, new List <int> { 7, 8 }, 100).Episode, new MockedDatabaseEpisode("275278", 2, new List <int> { 1, 1, 1 }, 100).Episode, new MockedDatabaseEpisode("275278", 4, new List <int> { 10, 10 }, 100).Episode, new MockedDatabaseEpisode("275271", 2, new List <int> { 11, 12 }, 90).Episode }; contentDirectory.SearchAsync(Arg.Any <MediaItemQuery>(), true, null, false).Returns(databaseMediaItems); mediaPortalServices.GetServerConnectionManager().ContentDirectory.Returns(contentDirectory); IFileOperations fileOperations = Substitute.For <IFileOperations>(); IMoverOperations operations = new MoverOperations(mediaPortalServices, fileOperations); // Act BackupResult result = operations.BackupSeries(FakePath); // Assert Assert.Equal(4, result.WatchedCount); Assert.Equal(6, result.CollectedCount); }
/// <summary> /// Returns the content of the specified Compute Node file. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='poolId'> /// The ID of the Pool that contains the Compute Node. /// </param> /// <param name='nodeId'> /// The ID of the Compute Node that contains the file. /// </param> /// <param name='filePath'> /// The path to the Compute Node file that you want to get the content of. /// </param> /// <param name='fileGetFromComputeNodeOptions'> /// Additional parameters for the operation /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <Stream> GetFromComputeNodeAsync(this IFileOperations operations, string poolId, string nodeId, string filePath, FileGetFromComputeNodeOptions fileGetFromComputeNodeOptions = default(FileGetFromComputeNodeOptions), CancellationToken cancellationToken = default(CancellationToken)) { var _result = await operations.GetFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, filePath, fileGetFromComputeNodeOptions, null, cancellationToken).ConfigureAwait(false); _result.Request.Dispose(); return(_result.Body); }
/// <summary> /// Lists all of the files in Task directories on the specified Compute Node. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='poolId'> /// The ID of the Pool that contains the Compute Node. /// </param> /// <param name='nodeId'> /// The ID of the Compute Node whose files you want to list. /// </param> /// <param name='recursive'> /// Whether to list children of a directory. /// </param> /// <param name='fileListFromComputeNodeOptions'> /// Additional parameters for the operation /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <IPage <NodeFile> > ListFromComputeNodeAsync(this IFileOperations operations, string poolId, string nodeId, bool?recursive = default(bool?), FileListFromComputeNodeOptions fileListFromComputeNodeOptions = default(FileListFromComputeNodeOptions), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ListFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, recursive, fileListFromComputeNodeOptions, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public WordSearchProgramHelper(IConsoleWrapper consoleWrapper, IFileOperations fileOperations, IWordFinder wordFinder, ISearchOrientationManager searchOrientationManager) { _consoleWrapper = consoleWrapper; _fileOperations = fileOperations; _wordFinder = wordFinder; _searchOrientationManager = searchOrientationManager; }
public AsyncOperations(IFileOperations synchronousFileOperations) { if (synchronousFileOperations == null) { throw new ArgumentNullException("synchronousFileOperations"); } _synchronousFileOperations = synchronousFileOperations; }
public TraktSyncHandlerManager(IMediaPortalServices mediaPortalServices, ILibrarySynchronization librarySynchronization, IFileOperations fileOperations) { _mediaPortalServices = mediaPortalServices; _fileOperations = fileOperations; _librarySynchronization = librarySynchronization; _mediaPortalServices.GetTraktSettingsWatcher().TraktSettingsChanged += ConfigureHandler; _mediaPortalServices.GetUserMessageHandler().UserChangedProxy += ConfigureHandler; ConfigureHandler(); }
public FileProcessor(IEpisodeParser episodeParser, ILogger logger, ISubtitleDownloadService subtitleService, IFileOperations fileOperations, LanguageSettings languageSettings) { _episodeParser = episodeParser; _logger = logger; _subtitleService = subtitleService; _fileOperations = fileOperations; _languageSettings = languageSettings; }
public TraktScrobbleHandlerManager(IMediaPortalServices mediaPortalServices, ITraktClient traktClient, IFileOperations fileOperations) { _mediaPortalServices = mediaPortalServices; _traktClient = traktClient; _fileOperations = fileOperations; _mediaPortalServices.GetTraktSettingsWatcher().TraktSettingsChanged += ConfigureHandler; _mediaPortalServices.GetUserMessageHandler().UserChangedProxy += ConfigureHandler; ConfigureHandler(); }
/// <summary> /// Constructor /// </summary> public ConfigMaker(IFileOperations fileOperations) { //// Initialize this.FileOperations = fileOperations; //// Set default example activity entries. AddDefaultActivityEntries(); logger.Info("Configuration Entries are initialized"); }
public TraktSetupModel() { _mediaPortalServices = new MediaPortalServices(); _traktClient = new TraktClientProxy(ApplicationId, SecretId, _mediaPortalServices.GetLogger()); _fileOperations = new FileOperations(); ITraktCache traktCache = new TraktCache(_mediaPortalServices, _traktClient, _fileOperations); _librarySynchronization = new LibrarySynchronization(_mediaPortalServices, _traktClient, traktCache, _fileOperations); }
public PpGenerator(Func<IBuilder> builderResolver, IFileOperations fileManager) { _builderResolver = builderResolver; _fileManager = fileManager; _huidigeStatus = State.Onbekend; _wachtrij = new List<WachtrijRegel>(); _verwerkt = new List<WachtrijRegel>(); _startThread = new Thread(PollVoorStart); _startThread.Start(); }
/// <summary> /// Constructor, dependency injection happening here /// </summary> /// <param name="fileOperations">Injects FileOperations instance</param> /// <param name="distanceOperations">Injects DistanceOperations instance</param> /// <param name="configuration">Injects ConfigurationSettings instance</param> /// <param name="configurationValidator">Injects ConfigurationValidator instance</param> /// <param name="logger">Injects Logger instance</param> public InviteCustomerService(IFileOperations fileOperations, IDistanceOperations distanceOperations, IOptions <ConfigurationSettings> configuration, IConfigurationValidator configurationValidator, ILogger <InviteCustomerService> logger) { _fileOperations = fileOperations; _distanceOperations = distanceOperations; _configuration = configuration; _configurationValidator = configurationValidator; _logger = logger; }
public AnswersController(IAsyncRepository repository, IMapper mapper, IWebHostEnvironment webHostEnvironment, IFileOperations fileOperations, UserManager <ApplicationUser> userManager) { _repository = repository; _mapper = mapper; _webHostEnvironment = webHostEnvironment; _fileOperations = fileOperations; _userManager = userManager; }
public FileItem(IFileOperations fileManager, string filePath) { _fileManager = fileManager; var dirPath = Path.GetFileNameWithoutExtension(filePath); Name = new DbItemName { Name = dirPath, SafeName = FileEngineDefaults.CreateSafeName(dirPath), }; Content = new FileContent(_fileManager, filePath); }
public RemotePowerpointClient(IFileOperations fileManager, string endpoint) { _fileManager = fileManager; _streams = new List<StreamTokenHolder>(); var binding = new NetTcpBinding(); binding.TransferMode = TransferMode.Streamed; binding.MaxBufferSize = 65536; // 64kb binding.MaxReceivedMessageSize = 67108864; // max 64mb binding.OpenTimeout = new TimeSpan(0, 1, 0); binding.CloseTimeout = new TimeSpan(0, 1, 0); binding.ReceiveTimeout = new TimeSpan(0, 10, 0); binding.SendTimeout = new TimeSpan(0, 10, 0); var address = new EndpointAddress(endpoint); var factory = new ChannelFactory<IWCFServer>(binding, address); _proxy = factory.CreateChannel(); }
private static Instellingen LoadFromXmlFile(IFileOperations fileManager, string instellingenFile, string maskFile) { Instellingen instellingen; if (!fileManager.FileExists(instellingenFile)) return null; var serializer = new XmlSerializer(typeof(Instellingen)); var settings = new XmlReaderSettings(); using (var textReader = new StreamReader(fileManager.FileReadStream(instellingenFile))) { using (var xmlReader = XmlReader.Create(textReader, settings)) { instellingen = serializer.Deserialize(xmlReader) as Instellingen; } } if (instellingen == null) return null; if (!fileManager.FileExists(maskFile)) return instellingen; using (var maskStream = fileManager.FileReadStream(maskFile)) { var xdoc = new XmlDocument(); xdoc.Load(maskStream); var root = xdoc.DocumentElement; if (root == null) return instellingen; var masklist = root.GetElementsByTagName("Mask"); foreach (XmlNode mask in masklist) { var nameNode = mask.SelectSingleNode("Name"); var realnameNode = mask.SelectSingleNode("RealName"); if (nameNode != null && realnameNode != null) instellingen.AddMask(new Mapmask(nameNode.InnerText, realnameNode.InnerText)); } } return instellingen; }
public FileItem(IFileOperations fileManager, string filePath) { _fileManager = fileManager; Name = Path.GetFileNameWithoutExtension(filePath); Content = new FileContent(_fileManager, filePath); }
public FileOperationService() { Configuration = ConfigurationSettings.GetConfig("image") as ImageConfiguration; _fileOperations = new FileOperations(); }
private static bool WriteToXmlFile(IFileOperations fileManager, string instellingenFile, string maskFile, Instellingen instellingen) { try { // verwijder oude bestand (zelfde effect als overschreven worden) if (fileManager.FileExists(instellingenFile)) fileManager.Delete(instellingenFile); //schrijf instellingen weg var serializer = new XmlSerializer(typeof(Instellingen)); using (var sw = new StreamWriter(fileManager.FileWriteStream(instellingenFile))) { serializer.Serialize(sw, instellingen); sw.Flush(); } //schrijf Masks weg using (var xw = XmlWriter.Create(maskFile, new XmlWriterSettings() { Indent = true })) { xw.WriteStartDocument(); xw.WriteStartElement("Masks"); foreach (var mask in instellingen.Masks) { xw.WriteStartElement("Mask"); xw.WriteStartElement("Name"); xw.WriteString(mask.Name); xw.WriteEndElement(); xw.WriteStartElement("RealName"); xw.WriteString(mask.RealName); xw.WriteEndElement(); xw.WriteEndElement(); } xw.WriteEndElement(); xw.WriteEndDocument(); xw.Flush(); } return true; } catch (PathTooLongException) { return false; } }
public DownloaderApplication(IFileOperations fileOperations, IStateSerializer serializer, IFileProcessor fileProcessor) { _fileOperations = fileOperations; _serializer = serializer; _fileProcessor = fileProcessor; }
protected TemporaryFile(string fileName, IFileOperations fileOperations) { this.fileName = fileName; this.fileOperations = fileOperations; }
public DirContent(IFileOperations fileManager, string dirPath, bool cached) { _fileManager = fileManager; _inDir = dirPath; _cached = cached; }
public StreamTokenHolder(IFileOperations fileManager, string url) { Stream = fileManager.FileReadStream(url); ID = Guid.NewGuid(); }
public FileContent(IFileOperations fileManager, string filePath) { _fileManager = fileManager; _filePath = filePath; Type = _filePath != null ? Path.GetExtension(_filePath).Substring(1) : string.Empty; }
internal FileBundledItem(IFileOperations fileManager, string dirPath, bool cached) { _fileManager = fileManager; Name = FileEngineDefaults.ClosestPathName(dirPath); Content = new DirContent(_fileManager, dirPath, cached); }
public static ITemporaryFile Create(IFileOperations fileOperations) { return new TemporaryFile(fileOperations.GetTempFileName(), fileOperations); }
public AsyncOperations(IFileOperations synchronousFileOperations) { if (synchronousFileOperations == null) throw new ArgumentNullException("synchronousFileOperations"); _synchronousFileOperations = synchronousFileOperations; }