public Notifier(ILogManager logManager, IEncryptionManager encryption)
{
_encryption = encryption;
_logger = logManager.GetLogger(GetType().Name);
Instance = this;
}
/// <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 RootContext(ITheaterApplicationHost appHost, INavigator navigator, ISessionManager sessionManager, ILogManager logManager) : base(appHost)
{
_appHost = appHost;
_navigator = navigator;
_sessionManager = sessionManager;
_logger = logManager.GetLogger("RootContext");
// create root navigation bindings
Binder.Bind<LoginPath, LoginContext>();
Binder.Bind<HomePath, HomeContext>();
Binder.Bind<SideMenuPath, SideMenuContext>();
Binder.Bind<FullScreenPlaybackPath, FullScreenPlaybackContext>();
Binder.Bind<ItemListPath>(async path => {
var context = appHost.CreateInstance(typeof (ItemListContext)) as ItemListContext;
context.Parameters = path.Parameter;
return context;
});
Binder.Bind<ItemPath>(async path => {
var context = appHost.CreateInstance(typeof (ItemDetailsContext)) as ItemDetailsContext;
context.Item = path.Parameter;
return context;
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionWebSocketListener" /> class.
/// </summary>
/// <param name="sessionManager">The session manager.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="dtoService">The dto service.</param>
public SessionWebSocketListener(ISessionManager sessionManager, ILogManager logManager, IDtoService dtoService, IServerApplicationHost appHost)
{
_sessionManager = sessionManager;
_logger = logManager.GetLogger(GetType().Name);
_dtoService = dtoService;
_appHost = appHost;
}
public void WriteToLog(ILogManager logManager)
{
// Enumerate over the input file counters and total up all the matched and unmatched totals.
UInt32 matchedTotal = 0, unmatchedTotal = 0;
PerformActionOverInputFileCounters((i) =>
{
matchedTotal += i.Matched;
unmatchedTotal += i.Unmatched;
});
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) processed.", matchedTotal + unmatchedTotal));
if (matchedTotal + unmatchedTotal == 0)
{
// No records processed so nothing more to report.
return;
}
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) matched.", matchedTotal));
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) not matched.", unmatchedTotal));
// Enumerate over the input file counters and write out the individual totals to the log.
PerformActionOverInputFileCounters((i) =>
{
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) processed from input file {1}.", i.Matched + i.Unmatched, i.FilePath));
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) matched from input file {1}.", i.Matched, i.FilePath));
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) not matched from input file {1}.", i.Unmatched, i.FilePath));
});
// Enumerate over the output file counters and write out the individual totals to the log.
foreach (var outputFileCounter in this.outputFileCounters.Values)
{
logManager.WriteImportantMessageToJobLog(String.Format("{0} Record(s) written to output file {1}.", outputFileCounter.Total, outputFileCounter.FilePath));
}
}
public CommandActionsEntryPoint(ICommandManager commandManager, IPresentationManager presentationManager, IPlaybackManager playbackManager, INavigationService navigationService, IScreensaverManager screensaverManager, ILogManager logManager)
{
_commandManager = commandManager;
_defaultCommandActionMap = new DefaultCommandActionMap(presentationManager, playbackManager, navigationService, screensaverManager, logManager);
_logger = logManager.GetLogger(GetType().Name);
}
public MusicBrainzAlbumProvider(ILogManager logManager, IServerConfigurationManager configurationManager, IHttpClient httpClient)
: base(logManager, configurationManager)
{
_httpClient = httpClient;
Current = this;
}
/// <summary>
/// Initializes a new instance of the <see cref="FanArtAlbumProvider"/> class.
/// </summary>
/// <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>
public FanArtAlbumProvider(IHttpClient httpClient, ILogManager logManager, IServerConfigurationManager configurationManager, IProviderManager providerManager, IFileSystem fileSystem)
: base(logManager, configurationManager)
{
_providerManager = providerManager;
_fileSystem = fileSystem;
HttpClient = httpClient;
}
public EpisodeProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager, IItemRepository itemRepo, IFileSystem fileSystem)
: base(logManager, configurationManager)
{
_itemRepo = itemRepo;
_fileSystem = fileSystem;
Current = this;
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="options">The options.</param>
private static void StartApplication(ServerApplicationPaths appPaths,
ILogManager logManager,
StartupOptions options)
{
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; });
var fileSystem = new ManagedFileSystem(new PatternsLogger(logManager.GetLogger("FileSystem")), false, true);
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
var nativeApp = new NativeApp(logManager.GetLogger("App"));
AppHost = new ApplicationHost(appPaths, logManager, options, fileSystem, "Emby.Server.Mac.pkg", nativeApp);
if (options.ContainsOption("-v")) {
Console.WriteLine (AppHost.ApplicationVersion.ToString());
return;
}
Console.WriteLine ("appHost.Init");
Task.Run (() => StartServer(CancellationToken.None));
}
/// <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;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerConfigurationManager" /> class.
/// </summary>
/// <param name="applicationPaths">The application paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="xmlSerializer">The XML serializer.</param>
public ServerConfigurationManager(IApplicationPaths applicationPaths, ILogManager logManager, IXmlSerializer xmlSerializer)
: base(applicationPaths, logManager, xmlSerializer)
{
UpdateItemsByNamePath();
UpdateTranscodingTempPath();
UpdateMetadataPath();
}
/// <summary>
/// Initializes a new instance of the <see cref="ReloadLoggerFileTask" /> class.
/// </summary>
/// <param name="logManager">The logManager.</param>
/// <param name="appHost"></param>
/// <param name="httpClient"></param>
public StatisticsTask(ILogManager logManager, IApplicationHost appHost, INetworkManager networkManager, IHttpClient httpClient)
{
LogManager = logManager;
ApplicationHost = appHost;
NetworkManager = networkManager;
HttpClient = httpClient;
}
/// <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);
}
public LogForm(ILogManager logManager)
{
InitializeComponent();
_logManager = logManager;
_uiThread = TaskScheduler.FromCurrentSynchronizationContext();
}
public WindowManager(INavigator navigator, IInternalPlayerWindowManager internalPlayerWindowManager, ILogManager logManager, ITheaterApplicationHost appHost)
{
_navigator = navigator;
_internalPlayerWindowManager = internalPlayerWindowManager;
_appHost = appHost;
_logger = logManager.GetLogger("WindowManager");
}
public SearchEngine(ILogManager logManager, ILibraryManager libraryManager, IUserManager userManager)
{
_libraryManager = libraryManager;
_userManager = userManager;
_logger = logManager.GetLogger("Lucene");
}
/// <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;
}
/// <summary>
/// Initializes a new instance of the <see cref="ApplicationManager"/> class.
/// </summary>
public ApplicationManager()
{
this._mainForm = new MainForm();
var obj = (ContainerConfiger)ConfigurationSettings.GetConfig("MenuProvider");
var menuProvider = Activator.CreateInstance(Type.GetType(obj.ClassName), obj.ConfigFile) as IMenuManager;
this._mainForm.TopMenu = menuProvider;
obj = (ContainerConfiger)ConfigurationSettings.GetConfig("ContainerProvider");
var contianerProvider = Activator.CreateInstance(Type.GetType(obj.ClassName), obj.ConfigFile) as IContainerProvider;
this._mainForm.ModuleContainer = contianerProvider;
obj = (ContainerConfiger)ConfigurationSettings.GetConfig("MessageProvider");
var messageProvider = Activator.CreateInstance(Type.GetType(obj.ClassName), obj.ConfigFile) as IMessageManager;
this._mainForm.MessageContainer = messageProvider;
Medical.Forms.Implements.MessageManager.Instance.Load(obj.ConfigFile);
obj = (ContainerConfiger)ConfigurationSettings.GetConfig("LogProvider");
var logProvider = Activator.CreateInstance(Type.GetType(obj.ClassName)) as ILogManager;
logProvider.MessageProvider = messageProvider;
this._mainForm.LogManager = logProvider;
log = logProvider;
//var viewManager = new ViewManager();
//this._mainForm.ViewManager = viewManager;
int clinicId = Int32.Parse(ConfigurationSettings.AppSettings.Get("ID"));
// IClinicRepository clinicRepository = new ClinicRepository();
// AppContext.CurrentClinic = clinicRepository.Get(clinicId);
AppContext.CurrentClinicId = clinicId;
this._mainForm.Text = ConfigurationSettings.AppSettings.Get("Title");
this._mainForm.Icon = System.Drawing.Icon.ExtractAssociatedIcon(ConfigurationSettings.AppSettings.Get("IconPath"));
// this._mainForm.CommonInitilize();
}
public DropboxServerSyncProvider(IConfigurationRetriever configurationRetriever, IDropboxApi dropboxApi, IDropboxContentApi dropboxContentApi, ILogManager logManager)
{
_configurationRetriever = configurationRetriever;
_dropboxApi = dropboxApi;
_dropboxContentApi = dropboxContentApi;
_logger = logManager.GetLogger("Dropbox");
}
/// <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 MashupScriptStorage(IPluginContext context, IMashupLocalFolder folder, ILogManager logManager, IMashupLoader mashupLoader)
{
_folder = folder;
_mashupLoader = mashupLoader;
_log = logManager.GetLogger(GetType());
_accountName = context.AccountName;
}
public MashupInfoRepository(ILogManager logManager, IPluginContext context, ITpBus bus, IMashupScriptStorage scriptStorage)
{
_bus = bus;
_scriptStorage = scriptStorage;
_log = logManager.GetLogger(GetType());
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="SSDPServer" /> class.
/// </summary>
/// <param name="logManager">
/// The <see cref="ILogManager"/> to use for logging the debug information.
/// </param>
private SSDPServer(ILogManager logManager = null)
{
if (logManager != null)
{
this.logger = logManager.GetLogger<SSDPServer>();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaResource"/> class.
/// </summary>
/// <param name="logManager">
/// The log manager to use for logging.
/// </param>
public MediaResource(ILogManager logManager = null)
{
if (logManager != null)
{
this.logger = logManager.GetLogger<MediaResource>();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMetadataProvider" /> class.
/// </summary>
/// <param name="logManager">The log manager.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="mediaEncoder">The media encoder.</param>
public AudioImageProvider(ILogManager logManager, IServerConfigurationManager configurationManager, IMediaEncoder mediaEncoder)
: base(logManager, configurationManager)
{
_mediaEncoder = mediaEncoder;
ImageCache = new FileSystemRepository(Kernel.Instance.FFMpegManager.AudioImagesDataPath);
}
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options)
{
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; });
var fileSystem = new CommonFileSystem(logManager.GetLogger("FileSystem"), false, true);
var nativeApp = new NativeApp();
_appHost = new ApplicationHost(appPaths, logManager, options, fileSystem, "MBServer.Mono", nativeApp);
if (options.ContainsOption("-v"))
{
Console.WriteLine(_appHost.ApplicationVersion.ToString());
return;
}
Console.WriteLine("appHost.Init");
var initProgress = new Progress<double>();
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
Console.WriteLine("Running startup tasks");
task = _appHost.RunStartupTasks();
Task.WaitAll(task);
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
public TuneInChannel(IHttpClient httpClient, ILogManager logManager)
{
_httpClient = httpClient;
_logger = logManager.GetLogger(GetType().Name);
partnerid = "uD1X52pA";
}
/// <summary>
/// Creates a new instance of the LogManager.
/// </summary>
public LogManager()
{
InitializeComponent();
_loggers = new Dictionary<int, ILogger>();
_currentKey = 0;
DefaultLogManager = this;
}
public DlnaEntryPoint(IServerConfigurationManager config,
ILogManager logManager,
IServerApplicationHost appHost,
INetworkManager network,
ISessionManager sessionManager,
IHttpClient httpClient,
ILibraryManager libraryManager,
IUserManager userManager,
IDlnaManager dlnaManager,
IImageProcessor imageProcessor,
IUserDataManager userDataManager,
ILocalizationManager localization,
IMediaSourceManager mediaSourceManager,
ISsdpHandler ssdpHandler)
{
_config = config;
_appHost = appHost;
_network = network;
_sessionManager = sessionManager;
_httpClient = httpClient;
_libraryManager = libraryManager;
_userManager = userManager;
_dlnaManager = dlnaManager;
_imageProcessor = imageProcessor;
_userDataManager = userDataManager;
_localization = localization;
_mediaSourceManager = mediaSourceManager;
_ssdpHandler = (SsdpHandler)ssdpHandler;
_logger = logManager.GetLogger("Dlna");
}
public CliqueModule(ILogManager logManager, ICliqueBridge cliqueBridge)
{
_cliqueBridge = cliqueBridge ?? throw new ArgumentNullException(nameof(cliqueBridge));
}
public NethermindApi(IConfigProvider configProvider, IJsonSerializer jsonSerializer, ILogManager logManager)
{
ConfigProvider = configProvider;
EthereumJsonSerializer = jsonSerializer;
LogManager = logManager;
CryptoRandom = new CryptoRandom();
DisposeStack.Push(CryptoRandom);
}
public NethermindApi(IConfigProvider configProvider, ILogManager logManager)
: this(configProvider, new EthereumJsonSerializer(), logManager)
{
}
public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer, IHttpClient http, ILogManager logger)
private RocksDb Init(string basePath, string dbPath, IDbConfig dbConfig, ILogManager logManager, ColumnFamilies columnFamilies = null, bool deleteOnStart = false)
{
public DbOnTheRocks(string basePath, RocksDbSettings rocksDbSettings, IDbConfig dbConfig, ILogManager logManager, ColumnFamilies columnFamilies = null, bool deleteOnStart = false)
{
Name = rocksDbSettings.DbName;
_settings = rocksDbSettings;
Db = Init(basePath, rocksDbSettings.DbPath, dbConfig, logManager, columnFamilies, deleteOnStart);
}
public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer, ILogManager logManager, IEncryptionManager encryption)
: base(applicationPaths, xmlSerializer)
{
_encryption = encryption;
Instance = this;
Logger = logManager.GetLogger("SMTP Notifications");
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="authManager"></param>
/// <param name="logManager"></param>
/// <param name="emailManager"></param>
public UserManager(QuizContext context, IAuthManager authManager, ILogManager logManager, IEmailManager emailManager) : base(context, logManager)
{
this.authManager = authManager;
this.emailManager = emailManager;
}
public CodeRocksDb(string basePath, IDbConfig dbConfig, ILogManager logManager = null)
: base(basePath, "code", dbConfig, logManager)
{
}
public SimpleExceptionLogger(ILogManager logManager)
{
_log = logManager.GetLog(typeof(SimpleExceptionLogger));
}
public TestPerformedReportPollingAgent(ICorporateAccountRepository corporateAccountRepository, ILogManager logManager, ISettings settings,
ITestResultService testResultService, ITestPerformedCsvExportHelper testPerformedCsvExportHelper)
{
_corporateAccountRepository = corporateAccountRepository;
_testResultService = testResultService;
//_baseExportableReportHelper = baseExportableReportHelper;
_testPerformedCsvExportHelper = testPerformedCsvExportHelper;
_reportDestinationPath = settings.ReportDestinationPath;
_dayOfMonth = settings.DayOfMonthServiceRun;
_logger = logManager.GetLogger("Reporting Service");
}
public HtmlTextController(IHtmlTextRepository htmlText, ILogManager logger, IHttpContextAccessor accessor) : base(logger, accessor)
{
_htmlText = htmlText;
}
public NethmModule(IConfigProvider configurationProvider, ILogManager logManager) : base(configurationProvider,
logManager)
{
}
public MarkFailedResultArchiveUploadPollingAgent(ILogManager logManager, IResultArchiveUploadRepository resultArchiveUploadRepository, ISettings settings)
{
_resultArchiveUploadRepository = resultArchiveUploadRepository;
_markFailedAfterHours = settings.MarkResultArchiveFailedAfterHours;
_logger = logManager.GetLogger("Result Archive Failed Records");
}
public CallQueueCustomerDetailService(ICallQueueCustomerLockRepository callQueueCustomerLockRepository, ISessionContext sessionContext,
ICallQueueCustomerRepository callQueueCustomerRepository, ICustomerRepository customerRepository, IProspectCustomerRepository prospectCustomerRepository,
IProspectCustomerFactory prospectCustomerFactory, ICallQueueRepository callQueueRepository,
ICallQueueCustomerContactService callQueueCustomerContactService, ICustomerCallQueueCallAttemptRepository customerCallQueueCallAttemptRepository, ILogManager logManager,
IHealthPlanOutboundCallQueueService healthPlanOutboundCallQueueService, ICallQueueCriteriaRepository callQueueCriteriaRepository, IEventCustomerRepository eventCustomerRepository)
{
_callQueueCustomerLockRepository = callQueueCustomerLockRepository;
_sessionContext = sessionContext;
_callQueueCustomerRepository = callQueueCustomerRepository;
_customerRepository = customerRepository;
_prospectCustomerRepository = prospectCustomerRepository;
_prospectCustomerFactory = prospectCustomerFactory;
_callQueueRepository = callQueueRepository;
_callQueueCustomerContactService = callQueueCustomerContactService;
_customerCallQueueCallAttemptRepository = customerCallQueueCallAttemptRepository;
_healthPlanOutboundCallQueueService = healthPlanOutboundCallQueueService;
_callQueueCriteriaRepository = callQueueCriteriaRepository;
_eventCustomerRepository = eventCustomerRepository;
_logger = logManager.GetLogger <CallQueueCustomerDetailService>();
}
public PageModuleController(IPageModuleRepository PageModules, IUserPermissions UserPermissions, ILogManager logger)
{
this.PageModules = PageModules;
this.UserPermissions = UserPermissions;
this.logger = logger;
}
public Channel(IHttpClient httpClient, IJsonSerializer jsonSerializer, ILogManager logManager)
{
_httpClient = httpClient;
_logger = logManager.GetLogger(GetType().Name);
_jsonSerializer = jsonSerializer;
}
public ClientRepositoryV1(IConnectionFactory connectionFactory, ILogManager loggerManager, ClientDto dto)
: base(connectionFactory, loggerManager, dto)
{
}
public SkillController(ISkillsService skillsService, ILogManager logManager)
{
_skillsService = skillsService;
_logManager = logManager;
}
public ConsoleLogManagerTests()
{
_logManager = new ConsoleLogManager();
}
protected VersionedContract(IDictionary <UInt256, T> versions, ICache <Keccak, UInt256> cache, long activation, ILogManager logManager)
{
_versions = versions ?? throw new ArgumentNullException(nameof(versions));
_versionSelectorContract = versions.Values.Last();
Activation = activation;
_versionsCache = cache ?? throw new ArgumentNullException(nameof(cache));
_logger = logManager.GetClassLogger();
}
public NotificationController(INotificationRepository notifications, IUserPermissions userPermissions, ILogManager logger)
{
_notifications = notifications;
_userPermissions = userPermissions;
_logger = logger;
}
protected ProtocolHandlerBase(ISession session, INodeStatsManager nodeStats, IMessageSerializationService serializer, ILogManager logManager)
{
Logger = logManager?.GetClassLogger(GetType()) ?? throw new ArgumentNullException(nameof(logManager));
StatsManager = nodeStats ?? throw new ArgumentNullException(nameof(nodeStats));
Session = session ?? throw new ArgumentNullException(nameof(session));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_initCompletionSource = new TaskCompletionSource <MessageBase>();
}
public ExtendedHealthCheckService(ILogManager logManager, HealthCheckConfig config, INomisApiService nomisApiService)
: base(logManager)
{
_nomisApiService = nomisApiService;
_config = config;
}
public virtual async Task <INdmCapabilityConnector> InitAsync(IConfigProvider configProvider,
IDbProvider dbProvider, string baseDbPath, IBlockTree blockTree, ITxPool txPool, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, IFilterStore filterStore, IFilterManager filterManager,
ITimestamper timestamper, IEthereumEcdsa ecdsa, IRpcModuleProvider rpcModuleProvider, IKeyStore keyStore,
IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager consumerChannelManager, INdmDataPublisher dataPublisher, IGrpcServer grpcServer,
INodeStatsManager nodeStatsManager, IProtocolsManager protocolsManager,
IProtocolValidator protocolValidator, IMessageSerializationService messageSerializationService,
bool enableUnsecuredDevWallet, IWebSocketsManager webSocketsManager, ILogManager logManager,
IBlockProcessor blockProcessor, IJsonRpcClientProxy jsonRpcClientProxy,
IEthJsonRpcClientProxy ethJsonRpcClientProxy, IHttpClient httpClient)
{
var(config, services, faucet, ethRequestService, accountService, consumerService, consumerAddress,
providerAddress) = await PreInitAsync(configProvider, dbProvider, baseDbPath, blockTree, txPool,
specProvider, receiptStorage, wallet, filterStore, filterManager, timestamper, ecdsa, rpcModuleProvider,
keyStore, jsonSerializer, cryptoRandom, enode, consumerChannelManager, dataPublisher, grpcServer,
enableUnsecuredDevWallet, webSocketsManager, logManager, blockProcessor, jsonRpcClientProxy,
ethJsonRpcClientProxy, httpClient);
if (!config.Enabled)
{
return(default);
public KoreaIMBCLoginProvider(ILogManager logManager) : base(logManager)
{
}
public ThemeController(IThemeRepository themes, IInstallationManager installationManager, IWebHostEnvironment environment, ILogManager logger)
{
_themes = themes;
_installationManager = installationManager;
_environment = environment;
_logger = logger;
}
public JsonSerializer(ILogManager logManager)
{
_logger = logManager.GetClassLogger();
}
/// <summary>
/// Enable logging with the log manager
/// </summary>
/// <param name="manager">Log manager to use for logging</param>
/// <returns>Builder instance</returns>
public XmppClientBuilder EnableLogging(ILogManager manager)
{
_logManager = manager;
return(this);
}
public RemainsSender(ILogManager logManager, IXmlConverter <RemainRow> xmlConverter)
: base(logManager, xmlConverter)
{
//*** proxy class inject
}