Redmine Plugin Development

I have written this article with the purpose of explaining how to develop a Redmine Plugin. So let us go about this basic introduction into Redmine Plugin, and how to go about developing it.

What is Redmine?


The basic definition of Redmine is this – Redmine is a project management tool which is a flexible open source software. It is cross-platform and cross-database tool, developed using the Ruby on Rails framework.

Why Redmine Plugins?


As is the case with any technology, plugins will extend the functionalities of Redmine. They will do so without modifying the Redmine core. They can also be easily added/removed into the Redmine application.

Creating a new Redmine Plugin


In order to create a new plugin, you need to use the generator mentioned below. This will generate a new plugin under the application’s plugins directory.


bundle exec ruby bin/rails generate redmine_plugin <plugin_name>


To modify the plugin information, edit the init.rb file located in plugins/plugin_name/init.rb. Next, you have to restart the application so as to see the new plugin appear in the plugins list. Now that a new plugin has been created, we need to generate a model for the same.

Generating a model


In order to create a new model, run the below generator so that it creates the model and the corresponding migration. And then, migrate the database using the following command:


bundle exec ruby script/rails generate redmine_plugin_model <pluginName> <modelName> [field[:type][:index]]


In order to migrate the plugins migration files:


bundle exec rake redmine:plugins:migrate


Obviously, next is to generate a controller.

READ NOW >>  Benefits Of Using MEAN Stack For Application Development

Generating a controller


In order to create a new controller, run this generator:


bundle exec ruby script/rails generate redmine_plugin_controller <pluginName> <controllerName>

Adding routes


Edit the file in: plugins/pluginName/config/routes.rb in order to add the routes.

Extending menus


In order to edit the menus, you need to edit the file: plugins/plugin/init.rb and add the following line at the end of the plugin registration.


Redmine::Plugin.register :redmine_polls do


menu :application_menu, :polls, { :controller => controllerName, :action => actionName }, :caption => 'Plugin'



Syntax is:


menu(menuName, itemName, url, options={})

When do we need to extend?


Sometimes plugins require a specific feature implemented in the Redmine core or the plugin overrides a specific view.


  • Add new methods to a model/controller
  • Wrap an existing method to a model/controller
  • Changing the existing view

Extending redmine model/controller


We can not override a controller and model in redmine from Plugins. But it is easy to extend the models and controllers.

Adding a new method


Create a new module under plugins/plugin/lib directory.


require_dependency 'model/controller'
module Module
def self.included(parent)
parent.send(:include, InstanceMethods)
module InstanceMethods
#Insert overrides here
def method_name
# This tells the Model/Controller to include the module
Model/Controller.send(:include, ModuleName)

Wrapping an existing method

Wrapping can only be done once per method. If multiple plugins are wrapping the same method, then only the last wrapping would be valid. And so, all the previous ones would be ignored.


Create new module under plugins/plugin/lib directory.


require_dependency 'model/controller'

module ModuleName
def self.included(base)
base.send(:include, InstanceMethods)
base.class_eval do
unloadable # This is required only in the development mode
alias_method_chain :new_method, :old_method

module InstanceMethods
#Insert overrides here
def new_method_with_old_method


  # This tells the Model/Controller to include the module

 Model/Controller.send(:include, ModuleName)

Changing the existing view


  • Unlike Model and Controller, we can override redmine views by just adding the files under plugins view directory.
  • For example, in order to override the view page, the below file can be added:
READ NOW >>  How To Get Started With Sensu – A Full Stack Monitoring Tool




Thus, a basic Redmine plugin has been developed. Try it out, and see for yourself how this can help with your development. For more on Ruby on Rails development follow Agira Technologies.