Intro
In this post, I’d like to introduce a small side project I’ve recently embarked on. As a experienced Java developer stepping into the world of IdentityIQ (IIQ), I quickly realized that our community lacks a proper IIQ plugin for IntelliJ IDEA, the most popular IDE among Java developers today. While Eclipse boasts a well-developed extension for working with IIQ, IntelliJ—now favored by a large portion of the development community according to recent surveys—doesn’t have a comparable tool.
This gap in tooling became evident to me as I worked on IIQ-related tasks, and I felt there was a need for a solution that integrates seamlessly with IntelliJ’s powerful development environment. With that in mind, I decided to start this project, building on existing resources while adapting the code to meet the specific requirements of IntelliJ. Through this post, I hope to share my progress, cover important aspects of plugin development, and encourage others in the community to contribute to creating a robust IIQ plugin for IntelliJ.
Fortunately, the IdentityIQ Deployment Accelerator (IIQDA) provided a solid foundation and a working example to get started. While I was able to leverage some of the existing code, I had to modify and adapt it to meet IntelliJ’s specific requirements.
In this post, I will cover the following key topics:
• Structure of IntelliJ IDEA plugin
• Build and test process
• What functionality is covered
• Main TODOs
I hope that thanks to this post I will encourage more people to contribute to this project and together we will develop something that will make our work much easier.
Structure of the Plugin
Creating a plugin project in IntelliJ is easy. In the New Project window we can find IDE Plugin option. After filling in some basic information about our project we are have a project structure that looks like this:
Build and Test Process
The IntelliJ plugin project is a Gradle project. Under Tool Windows → Gradle we can find everything that we need to build and test our plugin.
The two most useful tasks are:
buildPlugin -
This task compiles the entire project, including all the source code, resources, and dependencies. This step ensures that the plugin is in a ready-to-run state by resolving any code issues and ensuring that all necessary dependencies are correctly included. The zip file can be found in this folder:
build/distributions/iiqda-intellij-plugin-1.0-SNAPSHOT.zip
This allows you to easily distribute and install the plugin in any compatible JetBrains IDE.
runIde –
This task launches a new instance of an IntelliJ-based IDE (e.g., IntelliJ IDEA, PyCharm, WebStorm) with the current plugin already installed, allowing you to test and debug your plugin in a real-world environment. It is an essential part of the workflow for developers creating IntelliJ plugins, as it allows them to quickly validate their work without disrupting their primary development environment.
Plugin Installation
If you’re developing or downloading a custom plugin for IntelliJ IDEA or another JetBrains IDE, you may want to install the plugin manually from a .zip file. This can be useful when testing plugins during development or when installing a plugin that isn’t available in the JetBrains plugin repository.
Here’s a step-by-step guide on how to install a plugin from disk in IntelliJ:
Settings → Plugins → 
→ Install Plugin from Disk
Browse to the location where your plugin .zip file is stored.
Once the IDE restarts, your plugin will be installed and available for use, ready to extend your development environment with new functionality.
Functionality
Here are the main functions available right now in the current version of the plugin:
-
Detecting properties files
-
Importing objects
-
Filtering
-
Cleaning
-
-
Exporting objects
Detecting Properties Files
First thing we need to do is to connect to an IIQ instance. This is achieved via the .properties files. Right now files for every environment should be placed in the main project folder. The plugin is able to handle multiple environments at once. If we provide more than one file, when selecting most operations, we will be asked to select which environment we want to use.
Names of environments are taken from the first part of the file name.
Here is an example of a .properties file:
%%INTELLIJ_USER%%=spadmin
debugPort=8000
debugTransport=dt_socket
%%INTELLIJ_URL%%=http\://localhost\:8080/iiq
%%INTELLIJ_PASS%%=admin
Importing Objects
Once the connection is established, we can focus on working with objects from IIQ. As shown in the image below, we have the ability to import artifacts into our project. To begin, right-click on one of the source folders in the project window and select the Import Artifacts option.
Next, choose the environment you wish to work with:
A selection window will appear, allowing you to:
- Choose the object type you want to import from the dropdown menu at the top.
- View a list of all available objects of that type from IIQ.
After selecting the desired object and clicking Finish, an XML file will be saved to your local project.
Filtering
A useful feature has been added to streamline the selection process. If Import Artifacts is invoked on a folder named after an existing IIQ object, the corresponding category will be automatically selected in the import window. This enhancement makes the import process faster and more user-friendly.
Cleaning
Another helpful feature is the automatic file cleaning function. When importing XML files, elements such as “id,” “created,” and “modified” tags are automatically removed. This ensures that you don’t have to manually clean these tags before exporting modified files, preventing any potential ID conflicts during installation.
Exporting Objects
Once the work on new functionality within a selected object is complete, the next step is to export it back into IIQ. The plugin simplifies this process by offering an integrated deployment feature. To do this, open the file you’ve been working on and navigate to the tool menu. From there, select Deploy Artifacts and choose the appropriate environment.
The plugin will then automatically send the file to IIQ, replacing the existing version based on the object’s name as the identifier. This streamlined process allows you to deploy changes—such as updated rules or other objects—into your IIQ instance with just a few clicks, significantly speeding up the workflow and ensuring smooth integration of changes.
TODOs
There are still some TODOs that are waiting in a backlog. I will mention only some of them. It would be great if someone would help with implementation. This is why projects exist in the CoLab. When anyone has some time, they are more then welcome to contribute and implement any helpful new feature.
Right now I am thinking about:
- Comparing files – It might be helpful to check what the differences are between our local copy of an object and what exactly is deployed.
- Running rules – It would be nice to test rules execution.
- Preventing timeouts – from time to time there are problems with the connection between the plugin and the IIQ instance. This could be investigated and improved.
…
Summary
In this article, I introduced the process of developing a custom IntelliJ plugin, specifically tailored for the IIQ community. The goal was to fill the gap in plugin support for IntelliJ, the most popular Java IDE, and offer functionality similar to the well-established Eclipse extension. Using an existing GitHub project as a starting point, I adapted the code to meet IntelliJ’s requirements.
The post covers key aspects such as the structure of an IntelliJ IDEA plugin, the build and test process using Gradle tasks like buildPlugin and runIde, and how to manually install the plugin. It also highlights the current features of the plugin, such as detecting properties files, importing and exporting objects, and future improvements that need to be addressed. Through this project, I hope to inspire others in the community to contribute and help improve our development workflows.
If you have any ideas for new functionality that will be helpful for your day to day work, just let me know and I will try to implement it as soon as possible.
The IntelliJ plugin for IIQ can be found in the CoLab: