public Connection(IMessageBus newMessageBus, IJsonSerializer jsonSerializer, string baseSignal, string connectionId, IList<string> signals, IList<string> groups, ITraceManager traceManager, IAckHandler ackHandler, IPerformanceCounterManager performanceCounterManager, IProtectedData protectedData) { if (traceManager == null) { throw new ArgumentNullException("traceManager"); } _bus = newMessageBus; _serializer = jsonSerializer; _baseSignal = baseSignal; _connectionId = connectionId; _signals = new List<string>(signals.Concat(groups)); _groups = new DiffSet<string>(groups); _traceSource = traceManager["SignalR.Connection"]; _ackHandler = ackHandler; _counters = performanceCounterManager; _protectedData = protectedData; }
public RokuSessionController(IHttpClient httpClient, IJsonSerializer json, IServerApplicationHost appHost, SessionInfo session) { _httpClient = httpClient; _json = json; _appHost = appHost; Session = session; }
/// <summary> /// Initializes a new instance of the <see cref="SqliteItemRepository"/> class. /// </summary> /// <param name="appPaths">The app paths.</param> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="logManager">The log manager.</param> /// <exception cref="System.ArgumentNullException"> /// appPaths /// or /// jsonSerializer /// </exception> public SqliteItemRepository(IApplicationPaths appPaths, IJsonSerializer jsonSerializer, ILogManager logManager) { if (appPaths == null) { throw new ArgumentNullException("appPaths"); } if (jsonSerializer == null) { throw new ArgumentNullException("jsonSerializer"); } _appPaths = appPaths; _jsonSerializer = jsonSerializer; _criticReviewsPath = Path.Combine(_appPaths.DataPath, "critic-reviews"); _logger = logManager.GetLogger(GetType().Name); var chapterDbFile = Path.Combine(_appPaths.DataPath, "chapters.db"); var chapterConnection = SqliteExtensions.ConnectToDb(chapterDbFile, _logger).Result; _chapterRepository = new SqliteChapterRepository(chapterConnection, logManager); var mediaStreamsDbFile = Path.Combine(_appPaths.DataPath, "mediainfo.db"); var mediaStreamsConnection = SqliteExtensions.ConnectToDb(mediaStreamsDbFile, _logger).Result; _mediaStreamsRepository = new SqliteMediaStreamsRepository(mediaStreamsConnection, logManager); var providerInfosDbFile = Path.Combine(_appPaths.DataPath, "providerinfo.db"); var providerInfoConnection = SqliteExtensions.ConnectToDb(providerInfosDbFile, _logger).Result; _providerInfoRepository = new SqliteProviderInfoRepository(providerInfoConnection, logManager); }
public FanArtMovieUpdatesPrescanTask(IJsonSerializer jsonSerializer, IServerConfigurationManager config, ILogger logger, IHttpClient httpClient) { _jsonSerializer = jsonSerializer; _config = config; _logger = logger; _httpClient = httpClient; }
public RSS(string url, IHttpClient httpClient, IJsonSerializer jsonSerializer, ILogger logger) { _httpClient = httpClient; _logger = logger; _jsonSerializer = jsonSerializer; this.url = url; }
public MainWindow() { InitializeComponent(); ConnectionsListView.ItemsSource = _storageAccountConnections; IDeploymentRepositoryFactory deploymentRepositoryFactory = new DeploymentRepositoryFactory(); _deploymentRepositoryManager = new DeploymentRepositoryManager(deploymentRepositoryFactory); _jsonSerializer = new JsonSerializer(new DiagnosticsTraceWriter()); _deploymentConfigSerializer = new JsonDeploymentConfigSerializer(_jsonSerializer); if (File.Exists(SettingsFilePath)) { string json = File.ReadAllText(SettingsFilePath); _storageAccountConnections = _jsonSerializer.Deserialize<List<StorageAccountConnectionInfo>>(json); ConnectionsListView.ItemsSource = _storageAccountConnections; } if (!Directory.Exists(DeploymentsConfigsDirPath)) { Directory.CreateDirectory(DeploymentsConfigsDirPath); } _deploymentConfigFileWatcher = new FileSystemWatcher { Path = Path.GetFullPath(DeploymentsConfigsDirPath), NotifyFilter = NotifyFilters.LastWrite, Filter = "*.json" }; _deploymentConfigFileWatcher.Changed += OnDeploymentConfigFileChanged; _deploymentConfigFileWatcher.EnableRaisingEvents = true; }
public static async Task<MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null) { var mac = GetMacAddress(); var data = new Dictionary<string, string> {{"feature", feature}, {"key",SupporterKey}, {"mac",mac}, {"mb2equiv",mb2Equivalent}, {"legacykey", LegacyKey} }; var reg = new RegRecord(); try { using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false)) { reg = jsonSerializer.DeserializeFromStream<RegRecord>(json); } if (reg.registered) { LicenseFile.AddRegCheck(feature); } } catch (Exception) { //if we have trouble obtaining from web - allow it if we've validated in the past 30 days reg.registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30); } return new MBRegistrationRecord {IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true}; }
/// <summary> /// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="networkManager">The network manager.</param> /// <param name="appHost">The application host.</param> /// <param name="json">The json.</param> public UdpServerEntryPoint(ILogger logger, INetworkManager networkManager, IServerApplicationHost appHost, IJsonSerializer json) { _logger = logger; _networkManager = networkManager; _appHost = appHost; _json = json; }
public OmdbProvider(IJsonSerializer jsonSerializer, IHttpClient httpClient) { _jsonSerializer = jsonSerializer; _httpClient = httpClient; Current = this; }
public SchedulesDirect(ILogger logger, IJsonSerializer jsonSerializer, IHttpClient httpClient, IApplicationHost appHost) { _logger = logger; _jsonSerializer = jsonSerializer; _httpClient = httpClient; _appHost = appHost; }
/// <summary> /// Initializes a new instance of the <see cref="MainWindow" /> class. /// </summary> /// <param name="logManager">The log manager.</param> /// <param name="appHost">The app host.</param> /// <param name="configurationManager">The configuration manager.</param> /// <param name="userManager">The user manager.</param> /// <param name="libraryManager">The library manager.</param> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="displayPreferencesManager">The display preferences manager.</param> /// <exception cref="System.ArgumentNullException">logger</exception> public MainWindow(ILogManager logManager, IServerApplicationHost appHost, IServerConfigurationManager configurationManager, IUserManager userManager, ILibraryManager libraryManager, IJsonSerializer jsonSerializer, IDisplayPreferencesRepository displayPreferencesManager) { if (logManager == null) { throw new ArgumentNullException("logManager"); } if (appHost == null) { throw new ArgumentNullException("appHost"); } if (configurationManager == null) { throw new ArgumentNullException("configurationManager"); } _logger = logManager.GetLogger("MainWindow"); _appHost = appHost; _logManager = logManager; _configurationManager = configurationManager; _userManager = userManager; _libraryManager = libraryManager; _jsonSerializer = jsonSerializer; _displayPreferencesManager = displayPreferencesManager; InitializeComponent(); Loaded += MainWindowLoaded; }
public FilesEventPersistence( ILog log, IJsonSerializer jsonSerializer, IFilesEventStoreConfiguration configuration, IFilesEventLocator filesEventLocator) { _log = log; _jsonSerializer = jsonSerializer; _filesEventLocator = filesEventLocator; _logFilePath = Path.Combine(configuration.StorePath, "Log.store"); if (File.Exists(_logFilePath)) { var json = File.ReadAllText(_logFilePath); var eventStoreLog = _jsonSerializer.Deserialize<EventStoreLog>(json); _globalSequenceNumber = eventStoreLog.GlobalSequenceNumber; _eventLog = eventStoreLog.Log ?? new Dictionary<long, string>(); if (_eventLog.Count != _globalSequenceNumber) { eventStoreLog = RecreateEventStoreLog(configuration.StorePath); _globalSequenceNumber = eventStoreLog.GlobalSequenceNumber; _eventLog = eventStoreLog.Log; } } else { _eventLog = new Dictionary<long, string>(); } }
/// <summary> /// /// </summary> /// <param name="logger"></param> /// <param name="jsonSerializer"></param> /// <param name="userManager"></param> /// <param name="userDataManager"> </param> /// <param name="httpClient"></param> /// <param name="appHost"></param> /// <param name="fileSystem"></param> public SyncFromTraktTask(ILogManager logger, IJsonSerializer jsonSerializer, IUserManager userManager, IUserDataManager userDataManager, IHttpClient httpClient, IServerApplicationHost appHost, IFileSystem fileSystem) { _userManager = userManager; _userDataManager = userDataManager; _logger = logger.GetLogger("Trakt"); _traktApi = new TraktApi(jsonSerializer, _logger, httpClient, appHost, userDataManager, fileSystem); }
/// <summary> /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class. /// </summary> /// <param name="scheduledTask">The scheduled task.</param> /// <param name="applicationPaths">The application paths.</param> /// <param name="taskManager">The task manager.</param> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="logger">The logger.</param> /// <exception cref="System.ArgumentNullException"> /// scheduledTask /// or /// applicationPaths /// or /// taskManager /// or /// jsonSerializer /// or /// logger /// </exception> public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, IJsonSerializer jsonSerializer, ILogger logger, IFileSystem fileSystem) { if (scheduledTask == null) { throw new ArgumentNullException("scheduledTask"); } if (applicationPaths == null) { throw new ArgumentNullException("applicationPaths"); } if (taskManager == null) { throw new ArgumentNullException("taskManager"); } if (jsonSerializer == null) { throw new ArgumentNullException("jsonSerializer"); } if (logger == null) { throw new ArgumentNullException("logger"); } ScheduledTask = scheduledTask; ApplicationPaths = applicationPaths; TaskManager = taskManager; JsonSerializer = jsonSerializer; Logger = logger; _fileSystem = fileSystem; InitTriggerEvents(); }
static LogManager() { _configuration = PulsusConfiguration.Default; _eventsFactory = new DefaultEventFactory(); _eventDispatcher = new DefaultEventDispatcher(_configuration); _jsonSerializer = new JsonNetSerializer(); }
public TvMazeSeasonImageProvider(IJsonSerializer jsonSerializer, IServerConfigurationManager config, IHttpClient httpClient, IFileSystem fileSystem) { _config = config; _httpClient = httpClient; _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; }
/// <summary> /// Initializes a new instance of the <see cref="LastfmArtistProvider"/> class. /// </summary> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="httpClient">The HTTP client.</param> /// <param name="logManager">The log manager.</param> /// <param name="configurationManager">The configuration manager.</param> /// <param name="providerManager">The provider manager.</param> /// <param name="libraryManager">The library manager.</param> public LastfmArtistProvider(IJsonSerializer jsonSerializer, IHttpClient httpClient, ILogManager logManager, IServerConfigurationManager configurationManager, IProviderManager providerManager, ILibraryManager libraryManager) : base(jsonSerializer, httpClient, logManager, configurationManager) { _providerManager = providerManager; LibraryManager = libraryManager; LocalMetaFileName = LastfmHelper.LocalArtistMetaFileName; }
public SendReplyService() { _jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>(); _sendReplyRemotingClientDict = new ConcurrentDictionary<string, SocketRemotingClient>(); _remotingClientWaitHandleDict = new ConcurrentDictionary<string, ManualResetEvent>(); _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName); }
public FanartAlbumProvider(IServerConfigurationManager config, IHttpClient httpClient, IFileSystem fileSystem, IJsonSerializer jsonSerializer) { _config = config; _httpClient = httpClient; _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; }
public static async Task<MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null, string version = null) { //check the reg file first to alleviate strain on the MB admin server - must actually check in every 30 days tho var reg = new RegRecord {registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30)}; if (!reg.registered) { var mac = _networkManager.GetMacAddress(); var data = new Dictionary<string, string> { { "feature", feature }, { "key", SupporterKey }, { "mac", mac }, { "mb2equiv", mb2Equivalent }, { "legacykey", LegacyKey }, { "ver", version }, { "platform", Environment.OSVersion.VersionString } }; try { using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false)) { reg = jsonSerializer.DeserializeFromStream<RegRecord>(json); } if (reg.registered) { LicenseFile.AddRegCheck(feature); } else { LicenseFile.RemoveRegCheck(feature); } } catch (Exception e) { _logger.ErrorException("Error checking registration status of {0}", e, feature); } } return new MBRegistrationRecord {IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true}; }
protected BaseTunerHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder) { Config = config; Logger = logger; JsonSerializer = jsonSerializer; MediaEncoder = mediaEncoder; }
internal static bool TryGetCommand(Message message, IJsonSerializer serializer, out SignalCommand command) { command = null; if (!message.SignalKey.EndsWith(SignalrCommand, StringComparison.OrdinalIgnoreCase)) { return false; } command = message.Value as SignalCommand; // Optimization for in memory message store if (command != null) { return true; } // Otherwise deserialize the message value string rawValue = message.Value as string; if (rawValue == null) { return false; } command = serializer.Parse<SignalCommand>(rawValue); return true; }
public ViewHelperImplementation(BundleCollection bundles, IAmdConfiguration configuration, IJsonSerializer jsonSerializer, IRequireJsConfigUrlProvider requireJsConfigUrlProvider) { this.bundles = bundles; this.configuration = configuration; this.jsonSerializer = jsonSerializer; this.requireJsConfigUrlProvider = requireJsConfigUrlProvider; }
public ImageProcessor(ILogger logger, IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer jsonSerializer) { _logger = logger; _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; _appPaths = appPaths; _saveImageSizeTimer = new Timer(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite); Dictionary<Guid, ImageSize> sizeDictionary; try { sizeDictionary = jsonSerializer.DeserializeFromFile<Dictionary<Guid, ImageSize>>(ImageSizeFile) ?? new Dictionary<Guid, ImageSize>(); } catch (FileNotFoundException) { // No biggie sizeDictionary = new Dictionary<Guid, ImageSize>(); } catch (Exception ex) { logger.ErrorException("Error parsing image size cache file", ex); sizeDictionary = new Dictionary<Guid, ImageSize>(); } _cachedImagedSizes = new ConcurrentDictionary<Guid, ImageSize>(sizeDictionary); }
/// <summary> /// Initializes a new instance of the <see cref="MovieDbImagesProvider"/> class. /// </summary> /// <param name="logManager">The log manager.</param> /// <param name="configurationManager">The configuration manager.</param> /// <param name="providerManager">The provider manager.</param> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="httpClient">The HTTP client.</param> public MovieDbImagesProvider(ILogManager logManager, IServerConfigurationManager configurationManager, IProviderManager providerManager, IJsonSerializer jsonSerializer, IHttpClient httpClient) : base(logManager, configurationManager) { _providerManager = providerManager; _jsonSerializer = jsonSerializer; _httpClient = httpClient; }
public PersistedDictionary(string path, IObjectStorage objectStorage, IJsonSerializer serializer, int delay = 250) { _objectStorage = objectStorage; _path = path; _delay = delay; Changed += OnChanged; _timer = new Timer(OnSaveTimer, null, -1, -1); }
public FanArtSeasonProvider(IServerConfigurationManager config, IHttpClient httpClient, IFileSystem fileSystem, IJsonSerializer json) { _config = config; _httpClient = httpClient; _fileSystem = fileSystem; _json = json; }
/// <summary> /// Initializes a new instance of the <see cref="CharacterService"/> class. /// </summary> /// <param name="webRequestor">The web requestor.</param> /// <param name="jsonSerializer">The JSON serializer.</param> public CharacterService( IWebRequestor webRequestor, IJsonSerializer jsonSerializer) : base(jsonSerializer) { this.webRequestor = webRequestor; }
public AppThemeManager(IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer json, ILogger logger) { _appPaths = appPaths; _fileSystem = fileSystem; _json = json; _logger = logger; }
public HtmlTemplateToJavaScriptTransformer(string javaScriptTemplate, HtmlTemplateBundle bundle, IJsonSerializer serializer, IHtmlTemplateIdStrategy idStrategy) { this.javaScriptTemplate = javaScriptTemplate; this.bundle = bundle; this.serializer = serializer; this.idStrategy = idStrategy; }
public SmsVitriniClient(string userName, string password, TimeSpan timeOut, IPhoneNumberValidator phoneNumberValidator, IJsonSerializer serializer) { if (String.IsNullOrEmpty(userName)) { throw new ArgumentNullException("userName"); } if (String.IsNullOrEmpty(password)) { throw new ArgumentNullException("password"); } if (serializer == null) { throw new ArgumentNullException("serializer"); } _userName = userName; _password = password; _timeOut = timeOut; _serializer = serializer; _phoneNumberValidator = phoneNumberValidator; }
public MediaInfoService(IMediaSourceManager mediaSourceManager, IDeviceManager deviceManager, ILibraryManager libraryManager, IServerConfigurationManager config, INetworkManager networkManager, IMediaEncoder mediaEncoder, IUserManager userManager, IJsonSerializer json) { _mediaSourceManager = mediaSourceManager; _deviceManager = deviceManager; _libraryManager = libraryManager; _config = config; _networkManager = networkManager; _mediaEncoder = mediaEncoder; _userManager = userManager; _json = json; }
public ProcessingCommandMailbox(string aggregateRootId, IProcessingCommandHandler messageHandler, IJsonSerializer jsonSerializer, ILogger logger) { _messageDict = new ConcurrentDictionary <long, ProcessingCommand>(); _duplicateCommandIdDict = new ConcurrentDictionary <string, byte>(); _messageHandler = messageHandler; _jsonSerializer = jsonSerializer; _logger = logger; _batchSize = ENodeConfiguration.Instance.Setting.CommandMailBoxProcessBatchSize; AggregateRootId = aggregateRootId; LastActiveTime = DateTime.Now; }
public DefaultEventQueue(ExceptionlessConfiguration config, IExceptionlessLog log, ISubmissionClient client, IObjectStorage objectStorage, IJsonSerializer serializer, TimeSpan?processQueueInterval, TimeSpan?queueStartDelay) { _log = log; _config = config; _client = client; _storage = objectStorage; _serializer = serializer; if (processQueueInterval.HasValue) { _processQueueInterval = processQueueInterval.Value; } _queueTimer = new Timer(OnProcessQueue, null, queueStartDelay ?? TimeSpan.FromSeconds(2), _processQueueInterval); }
public DefaultEventQueue(ExceptionlessConfiguration config, IExceptionlessLog log, ISubmissionClient client, IObjectStorage objectStorage, IJsonSerializer serializer) : this(config, log, client, objectStorage, serializer, null, null) { }
public DynamicHlsService(IServerConfigurationManager serverConfig, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IDlnaManager dlnaManager, ISubtitleEncoder subtitleEncoder, IDeviceManager deviceManager, IMediaSourceManager mediaSourceManager, IZipClient zipClient, IJsonSerializer jsonSerializer, INetworkManager networkManager) : base(serverConfig, userManager, libraryManager, isoManager, mediaEncoder, fileSystem, dlnaManager, subtitleEncoder, deviceManager, mediaSourceManager, zipClient, jsonSerializer) { NetworkManager = networkManager; }
public EncodedRecorder(ILogger logger, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IServerApplicationPaths appPaths, IJsonSerializer json, LiveTvOptions liveTvOptions, IHttpClient httpClient, IProcessFactory processFactory, IServerConfigurationManager config) { _logger = logger; _fileSystem = fileSystem; _mediaEncoder = mediaEncoder; _appPaths = appPaths; _json = json; _liveTvOptions = liveTvOptions; _httpClient = httpClient; _processFactory = processFactory; _config = config; }
public EthController(IWeb3EthApi web3EthApi, IWeb3HandlerResolver handlerResolver, IJsonSerializer jsonSerializer) { _web3EthApi = web3EthApi ?? throw new ArgumentNullException(nameof(web3EthApi)); _handlerResolver = handlerResolver ?? throw new ArgumentNullException(nameof(handlerResolver)); _jsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer)); }
/// <summary> /// Creates an instance of <see cref="JwtValidator" /> /// </summary> /// <param name="jsonSerializer">The Json Serializer</param> /// <param name="dateTimeProvider">The DateTime Provider</param> public JwtValidator(IJsonSerializer jsonSerializer, IDateTimeProvider dateTimeProvider) { _jsonSerializer = jsonSerializer; _dateTimeProvider = dateTimeProvider; }
/// <summary> /// Initializes a new instance of the <see cref="HttpResultFactory" /> class. /// </summary> /// <param name="logManager">The log manager.</param> /// <param name="fileSystem">The file system.</param> /// <param name="jsonSerializer">The json serializer.</param> public HttpResultFactory(ILogManager logManager, IFileSystem fileSystem, IJsonSerializer jsonSerializer) { _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; _logger = logManager.GetLogger("HttpResultFactory"); }
/// <summary> /// Initializes a new instance of the <see cref="HttpResultFactory" /> class. /// </summary> public HttpResultFactory(ILoggerFactory loggerfactory, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IBrotliCompressor brotliCompressor) { _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; _brotliCompressor = brotliCompressor; _logger = loggerfactory.CreateLogger("HttpResultFactory"); }
public HdHomerunDiscovery(IDeviceDiscovery deviceDiscovery, IServerConfigurationManager config, ILogger logger, ILiveTvManager liveTvManager, IHttpClient httpClient, IJsonSerializer json) { _deviceDiscovery = deviceDiscovery; _config = config; _logger = logger; _liveTvManager = liveTvManager; _httpClient = httpClient; _json = json; }
public SqliteUserRepository(ILogManager logManager, IServerApplicationPaths appPaths, IJsonSerializer jsonSerializer, IDbConnector dbConnector, IMemoryStreamProvider memoryStreamProvider) : base(logManager, dbConnector) { _jsonSerializer = jsonSerializer; _memoryStreamProvider = memoryStreamProvider; DbFilePath = Path.Combine(appPaths.DataPath, "users.db"); }
public KlarnaClient(IKlarnaSession session) { Session = session; _client = CreateRestClient(); _jsonSerializer = new Klarna.Serialization.JsonSerializer(); }
public SendQueueMessageService() { _jsonSerializer = ObjectContainer.Resolve <IJsonSerializer>(); _logger = ObjectContainer.Resolve <ILoggerFactory>().Create(GetType().FullName); }
public RabbitMqProducer(RabbitMqPrimitiveProducer primitivePublisher, string queueName, IJsonSerializer serializer) { this.primitivePublisher = primitivePublisher; this.queueName = queueName; this.serializer = serializer; }
public SubtitleEncoder(ILibraryManager libraryManager, ILogger logger, IApplicationPaths appPaths, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IJsonSerializer json) { _libraryManager = libraryManager; _logger = logger; _appPaths = appPaths; _fileSystem = fileSystem; _mediaEncoder = mediaEncoder; _json = json; }
public UserManager(ILogger logger, IServerConfigurationManager configurationManager, IUserRepository userRepository, IXmlSerializer xmlSerializer, INetworkManager networkManager, Func <IImageProcessor> imageProcessorFactory, Func <IDtoService> dtoServiceFactory, Func <IConnectManager> connectFactory, IServerApplicationHost appHost, IJsonSerializer jsonSerializer, IFileSystem fileSystem) { _logger = logger; UserRepository = userRepository; _xmlSerializer = xmlSerializer; _networkManager = networkManager; _imageProcessorFactory = imageProcessorFactory; _dtoServiceFactory = dtoServiceFactory; _connectFactory = connectFactory; _appHost = appHost; _jsonSerializer = jsonSerializer; _fileSystem = fileSystem; ConfigurationManager = configurationManager; Users = new List <User>(); DeletePinFile(); }
public TmdbImageProvider(IJsonSerializer jsonSerializer, IHttpClientFactory httpClientFactory, IFileSystem fileSystem) { _jsonSerializer = jsonSerializer; _httpClientFactory = httpClientFactory; _fileSystem = fileSystem; }
public JsonHistoryRepositoryBase(IJsonSerializer serializer, string storageFile) { _serializer = serializer; _storageFile = storageFile; }
/// <summary> /// Initializes a new instance of the <see cref="DashboardService" /> class. /// </summary> /// <param name="appHost">The app host.</param> /// <param name="serverConfigurationManager">The server configuration manager.</param> /// <param name="fileSystem">The file system.</param> public DashboardService(IServerApplicationHost appHost, IServerConfigurationManager serverConfigurationManager, IFileSystem fileSystem, ILocalizationManager localization, IJsonSerializer jsonSerializer) { _appHost = appHost; _serverConfigurationManager = serverConfigurationManager; _fileSystem = fileSystem; _localization = localization; _jsonSerializer = jsonSerializer; }
public ImageProcessor(ILogger logger, IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder) { _logger = logger; _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; _mediaEncoder = mediaEncoder; _appPaths = appPaths; _saveImageSizeTimer = new Timer(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite); Dictionary <Guid, ImageSize> sizeDictionary; try { sizeDictionary = jsonSerializer.DeserializeFromFile <Dictionary <Guid, ImageSize> >(ImageSizeFile) ?? new Dictionary <Guid, ImageSize>(); } catch (FileNotFoundException) { // No biggie sizeDictionary = new Dictionary <Guid, ImageSize>(); } catch (Exception ex) { logger.ErrorException("Error parsing image size cache file", ex); sizeDictionary = new Dictionary <Guid, ImageSize>(); } _cachedImagedSizes = new ConcurrentDictionary <Guid, ImageSize>(sizeDictionary); }
public SettingsResponse GetSettings(ExceptionlessConfiguration config, IJsonSerializer serializer) { return(new SettingsResponse(true)); }
public EthModule(IJsonSerializer jsonSerializer, IConfigProvider configProvider, ILogManager logManager, IBlockchainBridge blockchainBridge) : base(configProvider, logManager, jsonSerializer) { _blockchainBridge = blockchainBridge; }
public SubmissionResponse PostEvents(IEnumerable <Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) { foreach (Event e in events) { string data = serializer.Serialize(e); string referenceId = !string.IsNullOrWhiteSpace(e.ReferenceId) ? e.ReferenceId : Guid.NewGuid().ToString("D"); _eventRepository[referenceId] = data; } return(new SubmissionResponse(200)); }
/// <summary> /// creates a new <see cref="ConditionalExpressionSerializer"/> /// </summary> /// <param name="serializer"></param> public ConditionalExpressionSerializer(IJsonSerializer serializer) { this.serializer = serializer; }
public LiveTvService(IHttpClient httpClient, IJsonSerializer jsonSerializer, ILogger logger) { _httpClient = httpClient; _jsonSerializer = jsonSerializer; _logger = logger; }
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) { string data = serializer.Serialize(description); _userDescriptionRepository[referenceId] = data; return(new SubmissionResponse(200)); }
/// <summary> /// Sets JWT serializer. /// </summary> /// <remarks> /// If not set then default <see cref="JsonNetSerializer" /> will be used. /// </remarks> /// <returns>Current builder instance</returns> public JwtBuilder WithSerializer(IJsonSerializer serializer) { _serializer = serializer; return(this); }