public override void OnExecute(IPluginProvider provider) { // Get configuration values var resource = SecureConfig.GetValue <string>("resource"); var username = SecureConfig.GetValue <string>("username"); var password = SecureConfig.GetValue <string>("password"); // Get access token var token = provider.TokenService.GetToken(resource, username, password); // Get current versions var current = GetCurrentVersions(token); var previous = GetPreviousVersions(provider.OrganizationAdminService); var isUpdated = current.Application > previous.Application || current.Database > previous.Database; if (isUpdated) { var entity = new Entity("bg_versionlog") { ["bg_application"] = current.Application.ToString(), ["bg_database"] = current.Database.ToString() }; provider.OrganizationAdminService.Create(entity); } var output = provider.ExecutionContext.OutputParameters; output["Application"] = current.Application.ToString(); output["Database"] = current.Database.ToString(); output["IsUpdated"] = isUpdated; }
public override void Loaded(IPluginProvider pluginProvider) { _auth = pluginProvider.Get <AuthPlugin>(); _auth.LoggedIn += OnLoggedIn; database = pluginProvider.Get <CockroachDbPlugin>(); }
public ScanAgent( [NotNull] IApiService service, [NotNull] ILog logger, [NotNull] IPluginProvider pluginProvider, [NotNull] IScanAgentIdProvider scanAgentIdProvider, [NotNull] ISystemVersionProvider systemVersionProvider) { if (service == null) { throw new ArgumentNullException(nameof(service)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (pluginProvider == null) { throw new ArgumentNullException(nameof(pluginProvider)); } if (scanAgentIdProvider == null) { throw new ArgumentNullException(nameof(scanAgentIdProvider)); } if (systemVersionProvider == null) { throw new ArgumentNullException(nameof(systemVersionProvider)); } _apiService = service; _logger = logger; _pluginProvider = pluginProvider; _scanAgentIdProvider = scanAgentIdProvider; _systemVersionProvider = systemVersionProvider; }
public PluginManager(IPluginProvider pluginService, ILog log) { this.pluginService = pluginService; this.log = log; CheckWorkingDirectories(); PluginCacheDir = CoreProperties.Settings.Default.PluginCacheDir; PluginTempBaseDir = CoreProperties.Settings.Default.PluginTempBaseDir; DoUpdateRun(); }
public static IServiceCollection AddPluginProvider(this IServiceCollection pool) { IServiceProvider services = pool.GetDescriptor <IServiceProvider>().GetInstance() as IServiceProvider; IPluginProvider provider = services.CreateInstance <PluginProvider>(); pool.Add(ServiceDescriptor.Singleton <IPluginProvider>(provider)); return(pool); }
public GetPluginsByProjectQueryHandler([NotNull] IPluginProvider pluginsProvider) { if (pluginsProvider == null) { throw new ArgumentNullException(nameof(pluginsProvider)); } _pluginsProvider = pluginsProvider; }
public override void OnExecute(IPluginProvider provider) { // Get configuration values var resource = SecureConfig.GetValue <string>("resource"); var username = SecureConfig.GetValue <string>("username"); var password = SecureConfig.GetValue <string>("password"); var renderer = new Renderer(resource, username, password); var service = provider.OrganizationService; var context = provider.ExecutionContext; var target = provider.Target; // Render the report var output = string.Empty; switch (target.LogicalName) { case "report": var reportColumns = new ColumnSet("reportnameonsrs", "languagecode", "defaultfilter"); var report = service.Retrieve(target.LogicalName, target.Id, reportColumns); var format = context.InputParameterOrDefault <string>("Format"); var parameters = context.InputParameterOrDefault <string>("Parameters"); var rendered = renderer.RenderReport(report, format, parameters); output = Convert.ToBase64String(rendered); break; case "documenttemplate": var templateColumns = new ColumnSet("documenttype", "associatedentitytypecode"); var template = service.Retrieve(target.LogicalName, target.Id, templateColumns); switch (template.GetAttributeValue <OptionSetValue>("documenttype")?.Value) { case 1: var savedView = Guid.Parse(context.InputParameterOrDefault <string>("ViewId")); output = renderer.RenderExcelTemplate(template.Id, savedView); break; case 2: var typeCode = template.GetAttributeValue <string>("associatedentitytypecode"); var metadata = service.GetEntityMetadata(typeCode); var recordId = Guid.Parse(context.InputParameterOrDefault <string>("RecordId")); output = renderer.RenderWordTemplate(template.Id, recordId, metadata.ObjectTypeCode ?? 0); break; default: throw new Exception("Invalid document template type."); } break; default: throw new Exception("Invalid input target."); } // Return as Base-64 provider.ExecutionContext.OutputParameters["Output"] = output; }
public PluginManager(IPluginProvider pluginProvider, IPluginServiceProvider serviceProvider) { this.pluginProvider = pluginProvider; this.serviceProvider = serviceProvider; this.pluginControllers = new PluginControllerCollection <TPluginItem>(); this.serviceProvider.AddService(typeof(IPluginManager <>), this); }
public PluginHost(IPluginProvider pluginProvider, TServiceProviderFactory serviceProver) { this.serviceProvider = serviceProver; this.pluginProvider = pluginProvider; this.pluginManager = new PluginManager <TPluginItem>(this.pluginProvider, this.serviceProvider.ServiceProvider); this.pluginManager.PluginAdded -= new EventHandler <EventArgs <TPluginItem> >(this.OnPluginAdded); this.pluginManager.PluginAdded += new EventHandler <EventArgs <TPluginItem> >(this.OnPluginAdded); }
public override void Loaded(IPluginProvider pluginProvider) { //Setup auth dependencies var auth = pluginProvider.Get <AuthPlugin>(); if (UseAuthModule && auth != null) { auth.LoggedIn += OnUserLoggedIn; auth.LoggedOut += OnUserLoggedOut; } }
public CoreNavigationForm(IPluginProvider pluginProvider, IResourceManager resourceManager) { InitializeComponent(); this.pluginProvider = pluginProvider; this.resourceManager = resourceManager; this.InitializeRibbonMenu(); this.PopulateRibbonMenuButtons(); }
private static IEnumerable <IPlugin> CreatePlugins(Assembly assembly) { int count = 0; Type[] typesInAssembly = null; try { typesInAssembly = assembly.GetTypes(); } catch (Exception ex) { } foreach (Type type in typesInAssembly) { if (typeof(IPluginProvider).IsAssignableFrom(type)) { IPluginProvider result = Activator.CreateInstance(type) as IPluginProvider; if (result != null) { count++; yield return(result); } } else if (typeof(IPluginUI).IsAssignableFrom(type)) { IPluginUI result = Activator.CreateInstance(type) as IPluginUI; if (result != null) { count++; yield return(result); } } else if (typeof(IPlugin).IsAssignableFrom(type)) { IPlugin result = Activator.CreateInstance(type) as IPlugin; if (result != null) { count++; yield return(result); } } } //if (count == 0) //{ // string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName)); // throw new ApplicationException( // $"Can't find any type which implements ISRTPlugin in {assembly} from {assembly.Location}.\n" + // $"Available types: {availableTypes}"); //} }
/// <summary> /// Loads a plugin from selected path asynchronously. /// </summary> /// <param name="path">Path to load the plugin from. Can point either to local <b>DLL</b>, <b>C# code file</b> or a <b>GitHub project url</b>.</param> /// <param name="permissions">Permissions granted to the plugin.</param> /// <returns>Loaded plugin. If loading failed, <see cref="PluginContainer.Plugin"/> property will be null.</returns> public async Task <PluginContainer> LoadPluginAsync(string path, PluginPermissions permissions) { IPluginProvider provider = PluginProviderSelector.GetPluginProvider(path); if (provider == null) { logger?.LogError($"Couldn't load plugin from path '{path}'"); return(null); } PluginContainer plugin = await provider.GetPluginAsync(path, logger).ConfigureAwait(false); return(HandlePlugin(plugin, permissions)); }
/// <summary> /// Loads a plugin from selected path. /// <br/><b>Important note:</b> keeping references to plugin containers outside this class will make them unloadable. /// </summary> /// <param name="path">Path to load the plugin from. Can point either to local <b>DLL</b>, <b>C# code file</b> or a <b>GitHub project url</b>.</param> /// <param name="permissions">Permissions granted to the plugin.</param> /// <returns>Loaded plugin. If loading failed, <see cref="PluginContainer.Plugin"/> property will be null.</returns> public PluginContainer LoadPlugin(string path, PluginPermissions permissions) { IPluginProvider provider = PluginProviderSelector.GetPluginProvider(path); if (provider == null) { logger?.LogError($"Couldn't load plugin from path '{path}'"); return(null); } PluginContainer plugin = provider.GetPlugin(path, logger); return(HandlePlugin(plugin, permissions)); }
public PluginAssemblyCache(IPluginProvider pluginProvider, PluginLoader pluginLoader) { if (pluginProvider == null) { throw new ArgumentNullException("pluginProvider"); } _PluginProvider = pluginProvider; if (pluginLoader == null) { throw new ArgumentNullException("pluginLoader"); } _PluginLoader = pluginLoader; }
public virtual void Initialize() { CurrentPlatform = Container.GetInstance <IPlatformProvider>().GetPlatform(); Container.GetInstance <IViewModelFactory>().Initialize(); Container.GetInstance <IViewFactory>().Initialize(); Container.GetInstance <IServiceDispatcher>().Initialize(); pluginProvider = Container.GetInstance <IPluginProvider>(); serviceDispatcher = Container.GetInstance <IServiceDispatcher>(); serviceDispatcher.Subscribe <IShellNavigationService>(this); Run(); }
public GetSystemSettingsQueryHandler( IConfigManager configManager, IConfigurationProvider configurationProvider, IMailConnectionParametersProvider mailConnectionParametersProvider, IPluginProvider pluginProvider, IScanAgentRepository scanAgentRepository, IUserAuthorityValidator userAuthorityValidator, IUserPrincipal userPrincipal) { _configManager = configManager; _configurationProvider = configurationProvider; _mailConnectionParametersProvider = mailConnectionParametersProvider; _pluginProvider = pluginProvider; _scanAgentRepository = scanAgentRepository; _userAuthorityValidator = userAuthorityValidator; _userPrincipal = userPrincipal; }
public void Unsubscribe(IPluginProvider provider) { provider.PreTestInitEvent -= PreTestInit; provider.TestInitFailedEvent -= TestInitFailed; provider.PostTestInitEvent -= PostTestInit; provider.PreTestCleanupEvent -= PreTestCleanup; provider.PostTestCleanupEvent -= PostTestCleanup; provider.TestCleanupFailedEvent -= TestCleanupFailed; provider.PreTestsArrangeEvent -= PreTestsArrange; provider.TestsArrangeFailedEvent -= TestsArrangeFailed; provider.PreTestsActEvent -= PreTestsAct; provider.PostTestsActEvent -= PostTestsAct; provider.PostTestsArrangeEvent -= PostTestsArrange; provider.PreTestsCleanupEvent -= PreTestsCleanup; provider.PostTestsCleanupEvent -= PostTestsCleanup; provider.TestsCleanupFailedEvent -= TestsCleanupFailed; }
public override void OnExecute(IPluginProvider provider) { // Get services var logger = provider.LoggingService; var service = provider.OrganizationService; var context = provider.ExecutionContext; var report = service.Retrieve(context.PrimaryEntityName, context.PrimaryEntityId, new ColumnSet("originalbodytext")); var body = report.GetAttributeValue <string>("originalbodytext"); var serializer = new XmlSerializer(typeof(Report)); using (var reader = new StringReader(body)) { var r = serializer.Deserialize(reader) as Report; context.OutputParameters["Parameters"] = string.Join(", ", r.ReportParameters.Select(x => x.Name)); } }
public static IEnumerable <IPlugin> CreatePlugins(Assembly assembly) { int count = 0; Type[] typesInAssembly = null; try { typesInAssembly = assembly.GetTypes(); } catch (Exception ex) { Program.HandleException(ex); yield break; } if (typesInAssembly != null) { foreach (Type type in typesInAssembly) { if (type.GetInterface(nameof(IPluginProvider)) != null) { IPluginProvider result = (IPluginProvider)Activator.CreateInstance(type); // If this throws an exception, the plugin may be targeting a different version of SRTPluginBase. count++; yield return(result); } else if (type.GetInterface(nameof(IPluginUI)) != null) { IPluginUI result = (IPluginUI)Activator.CreateInstance(type); count++; yield return(result); } else if (type.GetInterface(nameof(IPlugin)) != null) { IPlugin result = (IPlugin)Activator.CreateInstance(type); count++; yield return(result); } } } }
public void Start() { SpeedDateConfig.Initialize(_configFile); var logger = LogManager.GetLogger("SpeedDate"); var kernel = CreateKernel(); var startable = kernel.Get <ISpeedDateStartable>(); startable.Started += () => Started?.Invoke(); startable.Stopped += () => Stopped?.Invoke(); PluginProver = kernel.Get <IPluginProvider>(); foreach (var plugin in kernel.GetAll <IPlugin>()) { PluginProver.RegisterPlugin(plugin); } foreach (var plugin in PluginProver.GetAll()) { plugin.Loaded(PluginProver); logger.Info($"Loaded {plugin.GetType().Name}"); } var server = kernel.TryGet <IServer>(); if (server != null) { logger.Info("Acting as server: " + server.GetType().Name); } var client = kernel.TryGet <IClient>(); if (client != null) { logger.Info("Acting as client: " + client.GetType().Name); } startable.Start(); }
public PluginInitializer( [NotNull] ILog log, [NotNull] IPluginLoader <IPlugin> pluginLoader, [NotNull] IPluginProvider pluginProvider) { if (log == null) { throw new ArgumentNullException(nameof(log)); } if (pluginLoader == null) { throw new ArgumentNullException(nameof(pluginLoader)); } if (pluginProvider == null) { throw new ArgumentNullException(nameof(pluginProvider)); } _log = log; _pluginLoader = pluginLoader; _pluginProvider = pluginProvider; }
public void SetUp() { _testPlugin = new Mock <IVersionControlPlugin>(); _licenceProvider = new Mock <ILicenceProvider>(); var licence = new Mock <ILicence>(); licence.Setup(_ => _.Get <PluginLicenceComponent>()).Returns(new PluginLicenceComponent()); _licenceProvider.Setup(_ => _.GetCurrent()).Returns(licence.Object); _log = new Mock <ILog>(); _pluginContainerProvider = new Mock <IPluginContainerManager>(); _pluginRepository = new Mock <IPluginRepository>(); _pluginSettingProvider = new Mock <IPluginSettingProvider>(); _target = new PluginProvider( _licenceProvider.Object, _log.Object, _pluginContainerProvider.Object, _pluginRepository.Object, _pluginSettingProvider.Object); }
public void SetExtensionProperties(IPluginProvider importProvider, IMLSection section, bool isFirstLoad) { ImportProvider = importProvider; Section = section; IsFirstLoad = isFirstLoad; }
public App(IConfigSource configSource) { #region Check whether the required or mandatory EApp configuration has been configured in config file. if (configSource == null) { throw new ArgumentNullException("configSource"); } if (configSource.Config == null) { throw new ConfigException("EAppConfigSource has not been defined in the ConfigSource instance."); } if (configSource.Config.ObjectContainer == null) { throw new ConfigException("No ObjectContainer instance has been specified in the EAppConfigSource."); } #endregion this.configSource = configSource; #region If default used object container (i.e. default used IOC component) has been configured in config file then create it by Activator.CreateInstance string objectContainerFactoryProviderName = configSource.Config.ObjectContainer.Provider; if (string.IsNullOrEmpty(objectContainerFactoryProviderName) || objectContainerFactoryProviderName.IsNullOrWhiteSpace()) { throw new ConfigException("The ObjectContainer provider has not been defined in the ConfigSource."); } Type objectContainerFactoryType = Type.GetType(objectContainerFactoryProviderName); if (objectContainerFactoryType == null) { throw new InfrastructureException("The ObjectContainer defined by type {0} doesn't exist.", objectContainerFactoryProviderName); } IObjectContainerFactory currentObjectContainerFactory = (IObjectContainerFactory)Activator.CreateInstance(objectContainerFactoryType); if (currentObjectContainerFactory != null) { this.objectContainer = currentObjectContainerFactory.ObjectContainer; } // if object container need to be initialized from config file. E.g. Unity from config file. if (this.configSource.Config.ObjectContainer.InitFromConfigFile) { string sectionName = this.configSource.Config.ObjectContainer.SectionName; string configFilePath = this.configSource.Config.ObjectContainer.File; if (!string.IsNullOrEmpty(sectionName) && !sectionName.IsNullOrWhiteSpace()) { this.objectContainer.InitializeFromConfigFile(sectionName, configFilePath); } else { throw new ConfigException("Section name for the ObjectContainer configuration should also be provided when InitFromConfigFile has been set to true."); } } #endregion #region if resource managers have been configured in config file then create these resource managers if (configSource.Config.ResourceManagers != null && configSource.Config.ResourceManagers.ElementInformation.IsPresent) { foreach (NameTypeElement resourceItem in configSource.Config.ResourceManagers) { string resourceName = resourceItem.Name; string resourceAssemblyName = resourceItem.Type; if (!string.IsNullOrEmpty(resourceName) && !string.IsNullOrEmpty(resourceAssemblyName)) { Type resourceAssemblyType = Type.GetType(resourceAssemblyName); if (resourceAssemblyType == null) { continue; } this.ObjectContainer.RegisterType <IResourceManager>(resourceAssemblyType, resourceName); this.resourceManagers.Add(resourceName, this.ObjectContainer.Resolve <IResourceManager>(resourceName)); } } } #endregion #region If module plugin architecture has been configured in config file then create plugin host, plugin provider and service provider if (configSource.Config.PluginContainer != null && configSource.Config.PluginContainer.ElementInformation.IsPresent && configSource.Config.PluginContainer.Host != null && configSource.Config.PluginContainer.Host.ElementInformation.IsPresent) { if (configSource.Config.PluginContainer.Host.ServiceProvider == null) { throw new ConfigException("Plugin Service Provider configuration has not been initialized in the ConfigSource instance."); } if (configSource.Config.PluginContainer.Host.PluginProvider == null) { throw new ConfigException("Plugin Provider configuration has not been initialized in the ConfigSource instance."); } string hostTypeName = configSource.Config.PluginContainer.Host.Provider; if (string.IsNullOrEmpty(hostTypeName) || hostTypeName.IsNullOrWhiteSpace()) { throw new ConfigException("The Plugin Host Type Name has not been defined in the Plugin Config Source."); } string pluginProviderTypeName = configSource.Config.PluginContainer.Host.PluginProvider.Provider; if (string.IsNullOrEmpty(pluginProviderTypeName) || pluginProviderTypeName.IsNullOrWhiteSpace()) { throw new ConfigException("The Plugin Provider Type Name has not been defined in the Plugin Config Source."); } string serviceProviderFacotryTypeName = configSource.Config.PluginContainer.Host.ServiceProvider.Provider; if (string.IsNullOrEmpty(serviceProviderFacotryTypeName) || serviceProviderFacotryTypeName.IsNullOrWhiteSpace()) { throw new ConfigException("The Plugin Service Provider Type Name has not been defined in the Plugin Config Source."); } Type hostType = Type.GetType(hostTypeName); if (hostType == null) { throw new InfrastructureException("The Plugin Host defined by type {0} doesn't exist.", hostTypeName); } Type pluginProviderType = Type.GetType(pluginProviderTypeName); if (pluginProviderType == null) { throw new InfrastructureException("The Plugin Provider defined by type {0} doesn't exist.", pluginProviderTypeName); } Type serviceProviderFacotryType = Type.GetType(serviceProviderFacotryTypeName); if (serviceProviderFacotryType == null) { throw new InfrastructureException("The Plugin Service Provider defined by type {0} doesn't exist.", serviceProviderFacotryTypeName); } IPluginProvider pluginProvider = (IPluginProvider)Activator.CreateInstance(pluginProviderType); IPluginServiceProviderFactory serviceProviderFactory = (IPluginServiceProviderFactory)Activator.CreateInstance(serviceProviderFacotryType, new object[] { pluginProvider }); this.pluginHost = (IHost)Activator.CreateInstance(hostType, new object[] { pluginProvider, serviceProviderFactory }); // If plugin types have been configured in config file then register them into the object container for IOC. // e.g. when clicking a button to load a module plugin UI get the plugin instance by name from object container. if (configSource.Config.PluginContainer != null && configSource.Config.PluginContainer.ElementInformation.IsPresent && configSource.Config.PluginContainer.PluginRegisters != null && configSource.Config.PluginContainer.PluginRegisters.Count > 0) { foreach (PluginRegisterElement pluginRegisterItem in configSource.Config.PluginContainer.PluginRegisters) { string pluginName = pluginRegisterItem.Name; string pluginTypeName = pluginRegisterItem.Type; if (!string.IsNullOrEmpty(pluginName) && !string.IsNullOrEmpty(pluginTypeName)) { Type pluginAssemblyType = Type.GetType(pluginTypeName); if (pluginAssemblyType == null) { continue; } this.ObjectContainer.RegisterType(typeof(IPlugin), pluginAssemblyType, pluginName); } } } } #endregion #region If windows mvc controller list have been configured in config file then register controller type if (configSource.Config.WindowsMvc != null && configSource.Config.WindowsMvc.ElementInformation.IsPresent && configSource.Config.WindowsMvc.Controllers != null) { foreach (NameTypeElement controllerRegisterItem in configSource.Config.WindowsMvc.Controllers) { string controllerName = controllerRegisterItem.Name; string controllerTypeName = controllerRegisterItem.Type; if (!string.IsNullOrEmpty(controllerName) && !string.IsNullOrEmpty(controllerTypeName)) { Type controllerAssemblyType = Type.GetType(controllerTypeName); if (controllerAssemblyType == null) { continue; } this.ObjectContainer.RegisterType(typeof(IController), controllerAssemblyType, controllerName); } } } #endregion }
//[STAThread] public static async Task Main() { Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs e) => { e.Cancel = true; running = false; }; IPlugin[] allPlugins = null; IPluginProvider providerPlugin = null; IPluginUI[] uiPlugins = null; try { allPlugins = new DirectoryInfo("plugins") .EnumerateDirectories("*", SearchOption.TopDirectoryOnly) .Select((DirectoryInfo pluginDir) => pluginDir.EnumerateFiles(string.Format("{0}.dll", pluginDir.Name), SearchOption.TopDirectoryOnly).First()) .Select(a => a.FullName) .SelectMany((string pluginPath) => { Assembly pluginAssembly = LoadPlugin(pluginPath); return(CreatePlugins(pluginAssembly)); }).ToArray(); if (allPlugins.Count(a => typeof(IPluginProvider).IsAssignableFrom(a.GetType())) > 1) { Environment.Exit(1); // Critical error. Handle better. Only one provider allowed. } providerPlugin = (IPluginProvider)allPlugins.First(a => typeof(IPluginProvider).IsAssignableFrom(a.GetType())); uiPlugins = allPlugins.Where(a => typeof(IPluginUI).IsAssignableFrom(a.GetType())).Select(a => (IPluginUI)a).ToArray(); // Startup. foreach (IPlugin plugin in allPlugins) { int pluginStartupStatus = 0; try { pluginStartupStatus = plugin.Startup(hostDelegates); if (pluginStartupStatus == 0) { Console.WriteLine("[{0} v{1}.{2}.{3}.{4}] successfully started.", plugin.Info.Name, plugin.Info.VersionMajor, plugin.Info.VersionMinor, plugin.Info.VersionBuild, plugin.Info.VersionRevision); } else { Console.WriteLine("[{0} v{1}.{2}.{3}.{4}] failed to start properly with status {5}.", plugin.Info.Name, plugin.Info.VersionMajor, plugin.Info.VersionMinor, plugin.Info.VersionBuild, plugin.Info.VersionRevision, pluginStartupStatus); } } catch (Exception ex) { Console.WriteLine("[{0}] {1}", ex.GetType().Name, ex.ToString()); } } Console.WriteLine("Press CTRL+C in this console window to shutdown the SRT."); while (running) { object gameMemory = providerPlugin.PullData(); if (gameMemory != null) { foreach (IPluginUI uiPlugin in uiPlugins) { int uiPluginReceiveDataStatus = 0; try { uiPluginReceiveDataStatus = uiPlugin.ReceiveData(gameMemory); } catch (Exception ex) { Console.WriteLine("[{0}] {1}", ex.GetType().Name, ex.ToString()); } } } await Task.Delay(16).ConfigureAwait(false); } } catch (Exception ex) { Console.WriteLine("[{0}] {1}", ex.GetType().Name, ex.ToString()); } finally { // Shutdown. foreach (IPlugin plugin in allPlugins) { int pluginShutdownStatus = 0; try { pluginShutdownStatus = plugin.Shutdown(); if (pluginShutdownStatus == 0) { Console.WriteLine("[{0} v{1}.{2}.{3}.{4}] successfully shutdown.", plugin.Info.Name, plugin.Info.VersionMajor, plugin.Info.VersionMinor, plugin.Info.VersionBuild, plugin.Info.VersionRevision); } else { Console.WriteLine("[{0} v{1}.{2}.{3}.{4}] failed to stop properly with status {5}.", plugin.Info.Name, plugin.Info.VersionMajor, plugin.Info.VersionMinor, plugin.Info.VersionBuild, plugin.Info.VersionRevision, pluginShutdownStatus); } } catch (Exception ex) { Console.WriteLine("[{0}] {1}", ex.GetType().Name, ex.ToString()); } } } }
public override void Loaded(IPluginProvider pluginProvider) { base.Loaded(pluginProvider); _roomPlugin = pluginProvider.Get <RoomPlugin>(); }
public HomeController(IPluginProvider _provider, ILogger <HomeController> _log) { provider = _provider; log = _log; }
public FileSystemWatchingRunner(INotificationService notificationService, IPluginProvider pluginProvider) { this.notificationService = notificationService; this.pluginProvider = pluginProvider; this.pluginRunner = new PluginRunner(); }
public abstract void OnExecute(IPluginProvider provider);
/// <summary> /// Initializes a new instance of the <see cref="PluginProviderProxy{T}"/> class. /// </summary> public PluginProviderProxy(T pluginConfiguration, IPluginProvider <T> pluginProvider) { _pluginConfiguration = pluginConfiguration; _pluginProvider = pluginProvider; }
public CreateProjectCommandHandler( [NotNull] IAuthorityProvider authorityProvider, [NotNull] INotificationRuleProvider notificationRuleProvider, [NotNull] IUserAuthorityValidator userAuthorityValidator, [NotNull] IProjectRepository repositoryProjects, [NotNull] IRoleProvider roleProvider, [NotNull] ISdlPolicyProvider sdlPolicyProvider, [NotNull] ITimeService timeService, [NotNull] IUnitOfWork unitOfWork, [NotNull] IUserPrincipal userPrincipal, [NotNull] IQueryRepository queryRepository, [NotNull] IReportRepository reportRepository, [NotNull] ILicenceProvider licenceProvider, [NotNull] IPluginProvider pluginProvider, [NotNull] ITelemetryScopeProvider telemetryScopeProvider) : base(userAuthorityValidator, unitOfWork, userPrincipal) { if (authorityProvider == null) { throw new ArgumentNullException(nameof(authorityProvider)); } if (notificationRuleProvider == null) { throw new ArgumentNullException(nameof(notificationRuleProvider)); } if (userAuthorityValidator == null) { throw new ArgumentNullException(nameof(userAuthorityValidator)); } if (repositoryProjects == null) { throw new ArgumentNullException(nameof(repositoryProjects)); } if (roleProvider == null) { throw new ArgumentNullException(nameof(roleProvider)); } if (sdlPolicyProvider == null) { throw new ArgumentNullException(nameof(sdlPolicyProvider)); } if (timeService == null) { throw new ArgumentNullException(nameof(timeService)); } if (userPrincipal == null) { throw new ArgumentNullException(nameof(userPrincipal)); } if (queryRepository == null) { throw new ArgumentNullException(nameof(queryRepository)); } if (reportRepository == null) { throw new ArgumentNullException(nameof(reportRepository)); } if (licenceProvider == null) { throw new ArgumentNullException(nameof(licenceProvider)); } if (pluginProvider == null) { throw new ArgumentNullException(nameof(pluginProvider)); } if (telemetryScopeProvider == null) { throw new ArgumentNullException(nameof(telemetryScopeProvider)); } _authorityProvider = authorityProvider; _notificationRuleProvider = notificationRuleProvider; _repositoryProjects = repositoryProjects; _roleProvider = roleProvider; _sdlPolicyProvider = sdlPolicyProvider; _userPrincipal = userPrincipal; _queryRepository = queryRepository; _reportRepository = reportRepository; _licenceProvider = licenceProvider; _pluginProvider = pluginProvider; _telemetryScopeProvider = telemetryScopeProvider; _timeService = timeService; }
public XpressAppNav(IPluginProvider pluginProvider) : base(pluginProvider, new CommonResourceManager()) { InitializeComponent(); }
public XpressModulePluginHost(IPluginProvider pluginProvider, CoreNavigationForm serviceProvider) : base(pluginProvider, serviceProvider) { }