Plugins

Plugins are .net-based classes implementing IPlugin. Plugins are used to interact with Verint Community's in-process API by being installed directly within each web- and job-scheduler- node running the Verint Community platform.

IPlugin is the base interface for all plugins. Additional, special-use plugin types extend IPlugin to provide access to use-case-specific functionality and provide a tighter integration with components of Verint Community. For example, the IActivityStoryType  plugin interface extends IPlugin to provide support for extending the Verint Community activity stream.

The plugin manager both manages the lifecycle of plugins and provides access for retrieving instances of specific plugin types.

Getting started

Plugins are .net classes implementing one or more plugin interfaces. To create a new plugin:

1.   for Verint Community..
2. Use the sample class or create a new public class in the plugin project.
3. Implement the plugin type. For example, the following class would implement IPlugin:
   

   using System;
   
   namespace Samples
   {
           public class MyPlugin : Telligent.Evolution.Extensibility.Version1.IPlugin
           {
           }
   }

   
   and implement the interface:
   

   using System;
   
   namespace Samples
   {
   	public class MyPlugin : Telligent.Evolution.Extensibility.Version1.IPlugin
   	{
   		#region IPlugin Members
   
   		public string Name
   		{
   			get { throw new NotImplementedException(); }
   		}
   
   		public string Description
   		{
   			get { throw new NotImplementedException(); }
   		}
   
   		public void Initialize()
   		{
   			throw new NotImplementedException();
   		}
   
   		#endregion
   	}
   }

4. Update the plugin's Name and Description. These properties are read to identify this plugin within the administration UI (where plugins are categorized, enabled, and configured).
5. Build the project and update your test environment.
6. As an administrator, go to Administration, browse the existing categories or search for your plugin, enable the plugin, and save the changes.
7. Your plugin is now running within Verint Community.

Best practices

There are a few best practices to keep in mind when developing plugins:

1. Ensure that the plugin class is publicly accessible.
2. Either don't define an explicit constructor or ensure that a public, parameterless constructor exists. The public, parameterless constructor is the one used by the plugin manager to instantiate your plugin.
3. Register event handlers within the Initialize() method only.
4. Do not attach to any resources (database, file system, etc.) until the plugin's Initialize() method has been called.
5. Implement more than one plugin interface with a single plugin class. Plugin types are all interfaces to enable implementing many interfaces with a single concrete class.
6. Make use of other Plugin Types  when needed, for example:
   1.  IInstallablePlugin enables plugins to implement their own installation lifecycle with support for installation, upgrades, downgrades, and uninstallation.
   2.  IConfigurablePlugin  enables plugins to expose configuration on the Manage Plugins page of the Control Panel.
   3.  IRequiredConfigurationPlugin ensures that a minimal amount of configuration information is provided by users before allowing the plugin to be enabled.
   4.  IPluginGroup  enables multiple dependent plugins to be enabled/disabled as a single unit.
   5.  ITranslatablePlugin enables plugins to manage translatable text resources.
   6.  IScriptablePlugin  enables plugins to define custom UI via widgets which can then optionally be edited within the platform widget editor.
7. Make use of Verint Community's support for Application Telemetry 

Examples of common plugin types are available in developer training: Plugin Examples