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 FileFinder(IFileOperations fileManager, string atDir, bool itemsHaveSubContent, bool askCached)
{
_fileManager = fileManager;
_atDir = atDir;
_itemsHaveSubContent = itemsHaveSubContent;
_cached = askCached;
}
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;
}
