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.

[toc]

Getting started

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

1. Set up your development environment for Verint Community.
2. Create a new .NET class library project in Visual Studio using .net 4.x.
3. Add a reference to the Verint Community assembly identified in the documentation associated to the plugin you want to implement. For example, to implement IPlugin, a reference to Telligent.Evolution.Components.dll is required.
4. Create a new public class in your class library project.
5. Implement the plugin type. For example, the following class would implement IPlugin:
   

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

   
   Right-click the IPlugin reference in the code and select "Implement Interface" and Visual Studio will stub out the implementation of the plugin type. For example, the code above, once stubbed out, results in:
   

   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
   	}
   }

6. 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).
7. Implement the members defined by the plugin type. This is what defines what your plugin does. For example, it may attach an event handler to an event exposed by the In-process API and perform an action when that event occurs.
8. Build the solution.
9. Copy the resulting assembly (Samples.dll for example) into the web/bin/ folder of each Verint Community web node and job scheduler instance.
10. As an administrator, go to Administration, browse the existing categories or search for your plugin, enable the plugin, and save the changes.
11. 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 base plugin types when needed:
   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. IRenderableConfigurablePlugin enables configurable plugins to render a custom configuration UI.
   5. IPluginGroup enables multiple dependent plugins to be enabled/disabled as a single unit.
   6. ITranslatablePlugin enables plugins to manage translatable text resources.
   7. ITemplatablePlugin enables text-based configuration to make use of editor-based templating.
   8. IScriptablePlugin enables plugins to define custom UI via widgets which can then optionally be edited within the platform widget editor.
   9. ISingletonPlugin forces only a single instance of the derived plugin type to be enabled at a time.

Learn More About Plugins

Plugin Lifecycle

Learn about the plugin lifecycle.

Plugin Examples

Review plugin examples to learn more about plugin implementation and specific plugin types.

Exceptions and Logging

Plugins can utilize Verint Community's exception rendering and logging capabilities to simplify error and process logging.

Plugin API Documentation

View the Plugin API Documentation for the complete list of platform plugin types.

In-Process API Documentation

Plugins primarily interact with the Verint Community platform using the In-Process API.