The challenge in working with ScriptRunner is that returning and exporting large amounts of data can be tricky. It’s doable, especially if you have access to the filesystem, but not always the best way to approach the issue. Say you wanted to return a list of every issue for every project in the… Read more: Return All Issues for All Jira Cloud Projects, Using Python (Quick Bite)
Here’s my recipe for banana bread. I’ve written some notes at the bottom, but let’s start with the recipe itself. Is this technology related? No, but it’s my website, and I think banana bread is nifty. Estimated Time Investment 10 minutes to prepare 50 minutes to bake Ingredients Four large bananas, very ripe (mine are… Read more: Banana Bread, And the Importance of Measuring By Weight
Introduction Here’s the challenge: there’s an image that consists of a white background, black text, and an inner image underneath. You want to crop the text off the top, leaving just the inner image. To complicate matters, you have several thousand of these images, and they’re all different sizes. This precludes scripting a solution that… Read more: Image Transition Detection Using Edge Intensity in Python
What Is a JWT and Why Am I looking At It? ScriptRunner Behaviours are amendments or changes to custom fields, implemented by installing a free app on top of ScriptRunner (which is definitely NOT free). The app allows for modifying the way in which some fields work. Simple enough. All behaviors for all app users… Read more: Atlassian, JSON Web Tokens, and The Death of Cookie Monster
Intro to Macro-IDs The structure of a Confluence macro is predictable. The structure of one instance of a macro looks the same as that of another instance of the same macro. The only thing that makes two copies of the same macro unique is the UUID (or macro-id). Example, here’s a page with two copies… Read more: I Went Down a Rabbit Hole, And All I Got Was This Confluence UUID
Abstract The division and quantification of the constituent pieces of a Confluence user macro allows for granular analysis and adjustment on a system-wide level. This approach to analysis also provides a means by which the inbuilt macro usage feature of Confluence may be extended to include additional metrics. Overview Confluence user macros are those macros… Read more: Tokenization of Confluence User Macros as a Vector of Meta-Analysis
Abstract Reddit provides no easy way by which a person might delete their posting or comment history. You can delete your account, but the contents of the account remain. One imagines that this is by design, as Reddit’s business model is predicated on both an influx of new content, and a historical record of past… Read more: Asserting My Right to be Forgotten (on Reddit)
The task was to determine which Confluence page templates were using a given macro, without resorting to doing it by hand. The most obvious way to do this is to parse the body of the template as text, and use regex to look for macro references. Here’s an example of some code that does this:… Read more: Assessing Confluence DC Page Templates for Macro Usage
I’ve written before about accessing REST APIs using Scriptrunner for Jira DC. Frankly, I think the solution was a bit over-complicated. Let’s take a look at accessing REST API endpoints, using ScriptRunner for Confluence. Specifically, we’re going to use it to return user macro usage information. The code below is the basic, foundational approach to… Read more: Accessing REST API Endpoints Using Scriptrunner for Confluence Server/DC
I had a recent need to pull a lot of data out of OpenAir. There was a requirement to audit some data specific to each employee of the organization. Ordinarily this sort of task would come with API access to the system in question, and it would be fairly trivial to retrieve the required data… Read more: Extracting Data From OpenAir Without API Access
Here’s a quick one. Fetch a list of all projects in a Jira Cloud instance, then fetch a list of all of the issues in each project. Paginate through the resulting list of issues, and for each issue write the issue key and issue status to a CSV file. import requests import json import base64… Read more: Fetch Issue Status for All Issues in All Jira Projects
Management of users, groups, authentication, and directories happens outside of an organization’s primary Atlassian Cloud domain. Even if an organization uses https://org1234.atlassian.net for their Jira, all user administration happens on https://admin.atlassian.com Atlassian has provided very little in the way of API methods by which Cloud users may be managed. For example, the quickest way to… Read more: Cloud.Session.Tokens and API Access to Admin.Atlassian.com
This script builds upon the previous script. It authenticates against both Jira Server and Jira Cloud. It then takes a list of Projects as input, and compares the issue count for the project on the Server and Cloud side. This would be most useful in the case of an ongoing migration, to validate a successful… Read more: Compare Jira Server and Jira Cloud Issue Counts With Python
Connecting to server and Cloud instances of Jira with Python is accomplished with much the same method and approach. The only differences between the two are that Server uses a username and password, while Cloud uses a username and token. Generating a token is pretty straightfoward. I recommend reading the documentation first. The script below… Read more: Connect Jira Server and Jira Cloud With Python
Here’s a very basic example of a script to review group membership on Jira Server/DC By first fetching the groups, and then the users in each group, we take the most efficient path toward only fetching the users who are in a group. On the other hand, we could also tweak this script to show… Read more: Group Membership Review Script For Jira Server/DC
There’s a simple way to return a list of field configurations and field configuration schemes in Jira DC/Jira Server. However, in order to find that information you have to know that Jira once referred to these as field layouts. Using the FieldLayoutManager class, this script returns a list of field layouts: import com.atlassian.jira.component.ComponentAccessor import com.atlassian.jira.issue.fields.layout.field.FieldLayoutManager… Read more: Return a List of Field Configurations and Field Configuration Schemes in Jira
This simple script fetches all projects, then fetches each issue in the project. For each issue, it counts the number of attachments and adds it to a running tally for that project. import com.atlassian.jira.component.ComponentAccessor def projectManager = ComponentAccessor.getProjectManager() def projects = projectManager.getProjectObjects() def issueManager = ComponentAccessor.getIssueManager() projects.each{ project -> def attachmentsTotal = 0 def issues… Read more: Count All Attachments For All Jira Server Issues
Introduction I’ve started working on a QR-code based inventory management and pricing system. One of the foundational elements of this system is the ability to print a price tag with a QR code on it, and to be able to update the link associated with that QR code without replacing the sticker. This is possible… Read more: Python and the Bitly API
I wanted to create an interface in Python that had a row of icons at the top. Depending on the screen being displayed, I wanted one of those icons to be highlighted or a different color than the others. This proved to be more challenging than I expected. You can set the color of all… Read more: Individual Icon Colours in KivyMD’s TopAppBar Widget
Once upon a time, things were simple. If you wanted to retrieve a page using the Confluence Java API, you simply called getPage(). Fetching Spaces was similarly easy, and intuitive. Those days are over. The methods are deprecated. Instead, we now need to use SpaceService and ContentService to manage spaces and content, respectively. Let’s take… Read more: ContentService and SpaceService in Confluence for Datacenter
This script fetches all of the projects in a Jira Cloud instance. It then fetches all of the project roles for that project, and finally fetches all of the users in that role for that project. In this way, it iterates through the projects and returns information about the users in the project roles.… Read more: Get All Users in All Project Roles for Jira Cloud
Mitigating CORS Errors With Custom Jira REST API Endpoints If you dive into the world of REST requests and APIs, you may encounter a CORS error that prevents your request from completing. CORS stands for Cross-Origin Resource Sharing. Same-origin is a security feature in browsers that prevents requests coming from one place (origin) to access… Read more: Mitigating CORS Errors With Custom Jira REST API Endpoints
Overview Tempo Planner allows for planning team capacity and schedules within Jira. However, you may have some need to pull that resource planning information out of the Tempo interface and add it to a ticket. The Tempo API has some severe limitations, but where there’s a will there’s a way. Team Info The first thing… Read more: Tempo Planner and the Jira REST API
There may come a day when you’re asked to create a large number of Confluence pages. Rather than doing it by hand, why not script it? This Python script essentially does two things: it reads the CSV file, and it sends page creation requests to a Confluence server. For each row in the CSV file,… Read more: Converting CSV Files to Confluence Pages
The amount of code required to fetch information from Confluence Cloud and bring it into Jira Cloud is a bit shocking. In a good way. Here’s the code: import org.jsoup.* def authString = "<authstring>" def fieldConfigsResult = get("https://<url>.atlassian.net/wiki/rest/api/content/229377?expand=body.storage") .header('Content-Type', 'application/json') .header("Authorization", "Basic ${authString}") .asObject(Map) def storage = fieldConfigsResult.body.body.storage.value return storage In the end it’s… Read more: Connect to Confluence Cloud From Jira Cloud
The request on the Atlassian Forums that caught my eye last night was a request to return all Jira Cloud attachments with a certain extension. Ordinarily it would be easy enough to cite ScriptRunner as the solution to this, but the user included data residency concerns in his initial post. My solution to this was… Read more: Authenticating Against Atlassian Cloud
This script takes a list of custom field names, and searches each issue in the instance for places where that custom field has been used (i.e., where it has a value other than null). In this way, we gain insight into the usage of custom fields within a Jira Cloud instance. The script is interesting… Read more: Converting Jira Custom Field IDs to Issue Values
Get All Filters in a Jira System Here’s the truth: getting all of the filters in a Jira DC instance with ScriptRunner is awkward and fussy. There’s no method that simply returns all of the filters. Instead, we need to first return all of the users in the system. And then we need to examine… Read more: Get All Filters in a Jira System
Confluence Meta-Macros and the joy of being organized Let’s talk about meta-macros. That is, macros that examine other macros. I just made up the term, so don’t be concerned if you can’t find other examples on the internet. If you wanted some insight into which pages in your Confluence Instance were using a specific macro,… Read more: Confluence Meta-Macros
Overview I spoke to someone recently on the subject of learning to use ScriptRunner and Groovy. One of the questions he had was around the number of results that were returned when he called the API. That is, he had set maxResults to 500, but only 100 results were returned. Why? It’s true that you… Read more: Pagination and the Jira REST API
This script searches for Jira filters by name, then by filter ID, and then updates the permissions set applied to them. It’s useful for updating a bulk list of filter names, but really it’s an exercise in working with filters and the search service. The script iterates through an array of filter names. For each… Read more: Searching for Jira Filters by Name and ID
Introduction Well, it finally happened. I finally had to start learning JavaScript. It’s actually not that bad, I probably should have learned a while ago. My use case for it is writing Confluence Macros and plugins for both Confluence and Jira. I started with the plugins, for simplicity’s sake. My inspiration came from a post… Read more: Adventures In Confluence Macros #1 – What Even IS a JavaScript Promise?
As is often the case, the point of this blog isn’t so much to explain how to do something complicated. The point is that I’m trying to explain something simple that should be easy to find an answer for, but was not. In this case my question was “what on earth is a UserTemplate (User… Read more: Creating Confluence Users (What The Heck is a User Template?)
Introduction In a bid to contribute more to the Atlassian Community, I took a look at the most recent requests and questions on the Forums. One that caught my eye was a request for a Confluence Macro that would: “…display on the restricted page exactly who has access (including a breakout of all group members,… Read more: Creating a Permissions Transparency Confluence Macro
This script returns a list of pages in a Confluence instance that use a specified macro. There are a number of references to “MacroManager” in the Confluence API documentation, but none of the implementations seemed to work for me. For that reason, our best bet for checking on Macro usage is to examine the body… Read more: Assessing Confluence Macro Usage
There’s nothing terribly complicated about what I’m posting today, but it’s been a while since I put out an update. The challenge today was to create a sort of interlocking series of issues, using a listener. That is, the listener listens for an issue to be created. It creates a bug and an epic within… Read more: Interlocking Issues – Creating Epics and Bugs From a Jira Cloud Listener
One of the challenges that Jira admins face is monitoring the health of their Jira instance. While there are some built-in tools for doing this, it’s useful to know how to perform routine maintenance using ScriptRunner. One such routine maintenance task is the monitoring of Jira Project sizes. There’s no direct method or way of… Read more: Get the Size of a Project or Issue in Jira Using ScriptRunner
Here’s a relatively simple one for you. Say you had a Jira Cloud instance with hundreds or thousands of projects, and you wanted to swap them all over to using a new notification scheme. How would you go about it? Well you could certainly do it by hand. That’s an option. Or you could write… Read more: Swapping Jira Cloud Notification Schemes With ScriptRunner
I admit, this one is a very specific use case. But I had a reason to create the script, so maybe someone will find it useful. I also got to use the .collect method in a useful way! This script identifies all of the pages that are linked from a target page. It then compares… Read more: Identifying Unlinked Confluence Pages Within a Space
The Problem One of the problems we encounter with migrating large Jira instances is that when it comes to JCMA, you either have to add all of the Advanced Roadmaps plans or none of them. There’s no facility for selectively adding Roadmaps plans. One such migration involved moving a subset or portion of the instance… Read more: Deleting Advanced Roadmaps Plans From Jira With the REST API
The settings or preferences for a given user in Jira Cloud are stored in a number of locations within the system. The User Properties section contains settings relating to which interface elements the user sees or doesn’t see. For example, when you first access ScriptRunner on a Jira instance, you’re presented with a little quiz. … Read more: 100 Days of Code – Day 5 – Setting User Properties With ScriptRunner For Jira Cloud
Much like yesterday’s post about injections, it took me a little bit to figure out what was going on with pipelines and the left shift << operator in Groovy. In the end, it was simplest for me to say “X << Y basically means feed the data in Y into the function of X”. Pipelines… Read more: 100 Days of Code – Day 4 – Groovy Pipelines and the Left Shift Operator <<
When I sat down to write about injections, I thought it’d be a quick little blog post. However, it took me a lot longer than I expected to get my head around even the basic concept of what the injection was actually doing. I get the general idea now, but I don’t see myself putting… Read more: 100 Days of Code – Day 3 – Groovy Injections
Threading is a fantastic and (relatively) simple way to run parallel HTTP requests against a Jira or Confluence instance. Multithreading can drastically cut down the length of time it takes for a piece of code to run, as each HTTP request is not waiting for the previous request to finish. In Groovy we can achieve… Read more: 100 Days of Code – Day #2 – Threading vs Async in ScriptRunner
In an attempt to become a stronger user of Groovy and Jira, I’m challenging myself to learn something new each day for 100 days. These aren’t always going to be especially long blog posts, but they’ll at least be something that I find interesting or novel. If we want to work with the elements in… Read more: 100 Days of Atlassian Groovy Code – Day #1 – .each vs .collect
TrustedRequestFactory is a Jira-supplied way of authenticating against Jira itself. If I wanted to authenticate against the current instance, or an external instance, this is what I’d consider using. This script iterates through a collection of Jira URLs, and processes them as TrustedRequestFactory GET requests in parallel. This is useful in cases when a large… Read more: Running Parallel TrustedRequestFactory Instances Using Threads
Intro (If you haven’t read the previous post in this series, I highly recommend starting with that.) In order to make use of the Jira API documentation, we need to understand what classes, packages, and methods are. That’s because the JIRA API is documented, but only in the most technical sense. It is predicated on… Read more: ScriptWalking #3 – Working With the JIRA API Documentation (Server/DC)
I try to learn something new every day when it comes to Groovy, or at the very least to challenging my understanding of some of the tenets of the syntax that I think I already know. This morning I was playing around with the assert statement in ScriptRunner, trying to understand the nuances of it. … Read more: Quick Bite #1 – Assert vs Try/Catch
This is an extension of a previous post that I did, on returning all of the users in a Jira Cloud instance. The request was for a script that returns all users in a Jira Cloud instance who have been inactive for over 30 days. Unfortunately, only part of this request is doable. The Jira… Read more: Returning Jira Cloud Inactive Users With Timestamp
Introduction So you or your organization have decided to purchase, or at least trial, ScriptRunner. Now what? If you’re going to learn how to use ScriptRunner, I would very strongly advise that you set it up in a test environment. This allows you to learn to use the tool, and to not have to worry… Read more: ScriptWalking #2 – How Do I Use This Thing? (Server/DC)
I am entirely self-taught when it comes to ScriptRunner and Groovy. Everything I’ve learned has been through trial and error, and Googling different permutations of words until I find a solution. A great deal of the information out there assumes that you already know how to work with ScriptRunner, Groovy, and Jira or Confluence. I… Read more: ScriptWalking #1 – Back to the Basics of ScriptRunner and the Atlassian Stack
Adaptavist has a tool called Microscope that Jira admins can use to look into the specifics of various aspects of the system, including workflows. If you’re looking to examine an instance, I recommend using Microscope rather than writing your own script. However, it was requested that I look into workflows in a very specific… Read more: Return Jira DC Validators Using ScriptRunner and Groovy
This was actually an interesting problem to solve. Atlassian don’t seem to want anyone returning all of the users in an Jira instance through the API. There’s supposedly a method for doing this, but it doesn’t work if you’re running the script through a Connect app like ScriptRunner. This is another method that only works… Read more: Return All Jira Cloud Users Using the REST API
I spend a fair amount of time writing listeners with ScriptRunner, so that Jira will do various things for me based on certain criteria. For example, I write a lot of listeners that listen for when an issue is updated, and take action accordingly. Until today, however, I had never thought how I might leverage… Read more: Determining Jira Event Triggers by Field
In my previous post I explored how to access the Confluence Cloud Space Permissions API endpoint. This Python script extends that, and gives a user a permission set in all Spaces in Confluence. This could be useful if you wanted to give one person Administrative rights on all Spaces in Confluence, for example. Note that… Read more: Adding User Permissions to All Confluence Cloud Spaces Using the REST API
There’s a great deal of information on the internet about managing Confluence Space permissions with scripts, and how there’s no REST endpoint for it, and how it’s basically impossible. This is incorrect. There’s also a lot of information about using the JSONRPC or XMLRPC APIs to accomplish this. These APIs are only available on Server/DC.… Read more: Scripting Confluence Cloud Space Permissions
This script examines the membership of every group in Confluence. It returns information in three groups: The Confluence user directories Information about each group in Confluence Information about each user in Confluence The output looks like the blob below. As noted, the information is divided into three sections. Formatting is provided by the script: … Read more: Confluence Users Deep Dive Tool
The Jira Cloud Migration Assistant tool (JCMA) will only migrate some types of custom fields. The custom fields that it cannot migrate must be recreated on the Cloud side, or otherwise mitigated in some way. I wrote a small tool that proactively identifies any custom field in a Jira instance that JCMA will not be… Read more: Identifying Non-Migrateable Jira Custom Fields
When migrating data from Jira Server/DC to Jira Cloud, JCMA does not like tickets that have no assignee, or which have tickets with an assignee that has an inactive user status. This script checks a list of issues, and replaces any that have a missing or inactive assignee. The script comments should pretty well explain… Read more: Replace Inactive/Missing Assignees on a List of Jira Issues
Overview Please note: this solution was originally posted by Peter-Dave Sheehan on the Atlassian Forums. I’m just explaining how I use it. Sometimes when I’m trying to solve a problem with Jira, the internal Java libraries just aren’t sufficient. They’re often not documented, or they’re opaque. It’s often far easier to turn to the… Read more: ScriptRunner Foundations – Accessing Jira REST API Using Groovy
The Problem One of the challenges that I encountered this week was the need to include Advanced Roadmaps plans in a Jira DC to Cloud migration. As you may be aware, JCMA gives you the option to either migrate ALL plans, or none of them. There is no facility for selectively adding plans. This is… Read more: A Man With a Plan – Advanced Roadmaps Insights
You can easily remove all permissions from a Confluence DC Space, or a Confluence Cloud Space. Confluence Server, though? You’re out of luck. Imagine you migrated from Confluence Cloud to Confluence Server, and you wanted to remove all permissions on a Space (except for maybe “View Space”). That’s a whole lot of manually clicking, unless… Read more: Clear ALL Permissions on a Confluence Server Space (Removing Confluence Permissions With Groovy)
Overview It’s possible to connect to a Jira instance using Python, and it’s possible to connect to AWS Comprehend using Python. Therefor, it is possible to marry the two, and use Python to assess the sentiment of Jira issues. There are two caveats when it comes to using this script: The script assumes you can… Read more: Sentiment Analysis of Jira Issues With AWS Comprehend
As part of my grad school course work, I had half a dozen XML files with content that needed to be analyzed for sentiment. AWS Comprehend is a service that analyzes text in a number of ways, and one of those is sentiment analysis. My options were to either cut and paste the content of… Read more: Connecting Python to AWS Comprehend Sentiment Analysis
I found myself needing to examine issues that came through our Jira Service Desk workflow, to determine if they had a form attached. If they didn’t have a form attached, i.e. someone created the issue manually instead of through the Service Desk Portal, the workflow would be instructed to handle them in a certain way.… Read more: Detecting the Presence of Forms on a Jira Service Desk Issue
Overview I found myself with an interesting Jira problem today. We had a dashboard that wasn’t showing all issues relevant to the JQL query in the filter. The issues were fully present in the system, but would only appear if we went in after creation and tweaked them in some way. Essentially we had issues… Read more: Jira Dashboard Not Showing All Relevant Items
Introduction Once upon a time I spent a week writing a script to automate some functionality for Jira. The script was supposed to assign issues based on certain criteria, and also update a custom field that contained the name of the team that was currently responsible for the ticket. At the end of the week… Read more: Updating Single-Select Custom Fields in Jira
I have series of ProForma forms that are submitted as issues to the Jira Service Desk. I needed to run some scripts against these issues after they were created and fast-tracked into a Queued state. I elected to run a Groovy script as a Listener on Issue Update. The thinking was that because the state… Read more: Jira Listener Not Detecting Issue Updates
During the process of writing a listener for Jira, I found myself encountering a strange error. The error looked like this: com.atlassian.servicedesk.api.AuthorizationException: The action performed required a logged in user. Please log in and try again. This was strange for two reasons. First, I am a Jira administrator with total access to the entire… Read more: Authorization Exceptions When Running Listeners in Jira
I found myself in a situation wherein a ProForma form on the Jira Service Desk contained a custom field. I needed the contents of that field to dictate which team the resulting issue was assigned to. The first thing I tried was to add a Groovy script to a transition in the Service Desk Workflow. … Read more: The Forest For the Trees – Custom Field Null Values During Workflow Transitions
Introduction Jira Issues can only be transition between states in a manner that resembles the Workflow of the parent project. In other words, before you begin trying to script the transition of a Jira issue, you must understand the workflow and what the available transitions actually are. Further to that point, there’s more to transitions… Read more: Transitioning a Jira Issue With Mandatory Parameters
It is entirely possible to set up Jira so that a subtask may remain open, while the parent task is closed. This effectively creates orphan subtasks, not connected to any open issue or ticket. Identifying these is a matter of first identifying all subtasks, and then checking the status of both the subtask and its… Read more: Identifying Orphan Subtasks in Jira
This is part three of my series on using Python to connect to the Twitter API. Imagine for a moment that you had a specific vision for your Twitter account. A vision of balance, and harmony. What if you only followed people who also followed you? Whether or not you want to curate your Twitter… Read more: Using Twitter With Python, Part 3 – Unfollowing Non-Followers
Introduction There are a great number of things that you might want to do with Twitter, for which the web or mobile clients don’t have facilities. For example, you might want to run a script that automatically thanks anyone who follows you. Or you might want to run a script that Likes any comment that… Read more: Using Twitter With Python, Part 2 – Connecting Python and Twitter
Introduction A great deal of the available information regarding the use of Twitter and Python is outdated. The Twitter API has undergone several major revisions in the last few years, and many of the available tutorials now only lead to frustration. Not only has the API undergone major revisions, but there are multiple supported versions… Read more: Using Twitter With Python, Part 1 – Developer Access
Introduction I’ve been considering pivoting my career toward developer advocacy. I’m a decent developer with great customer service skills, and I can see myself doing well in such a position. In order to do that, I need to have a stronger idea of what I believe the role will entail. When I’ve established that, I’ll… Read more: You Gotta Fight For Your Right to Develop: The Role of Developer Advocacy in Shaping Ideology
Knowledge Management has an active role in shaping the ongoing ideology that an institution develops. As the curators of the information that ultimately informs ideology, the Knowledge Management team has a responsibility to be aware of not only their privilege, but also of the historic unequal privilege afforded to marginalized groups found within an organization.… Read more: The Collision of Knowledge and Power: Knowledge Management and Marginalization
Consider, if you will, a non-technical member of staff. They have been tasked with writing promotional materials for your organization’s new software offering. In order to do so, they will need to speak the technical capabilities and nuances of the product. They have entered… the Developer Zone. Rod Serling may be gone, but his legacy… Read more: Out of the Twilight Zone: Knowledge Management as a Connecting Force
How much does your organization value the ability to say, “I don’t know”? Is wilful ignorance a core tenet of the institutional ideology to which your employees are subject? The advantage of an effective Knowledge Management strategy is that as issues arise, the solutions to those issues may be catalogued. By resolving the issue and… Read more: Wilful Ignorance Lubricates the Wheels of Capitalism: A Case for Selective Knowledge Collation
The ultimate goal of Organizational Knowledge Management is not to collect, store, and curate information. Those tasks are a means to the end with which Knowledge Management ultimate concerns itself: application of ideology. All industries benefit from a focus on consistency, in both material and conceptual spaces. Knowledge Management is the facilitation of clean, ideologically… Read more: Choosing the Truth: The Role of Knowledge Management in Curating Institutional Ideology
I worked in an inbound call centre for three years. I worked as a Level 1 analyst, meaning that the work I was doing was intended to resemble all of the previous calls that I’d taken. In other words, I wasn’t paid to come up with creative or unusual solutions. In that time, I… Read more: The Sublime Beauty of Consistency
Knowledge Management exists to support an organization’s larger efforts. That is, it serves to further the larger goals of the organization; Knowledge Management is not the final goal, and rarely is captured knowledge an end unto itself. Unless an organization exists solely to capture information in something like an archival effort, there is almost certainly… Read more: To What End? – Knowledge Management as a Means Rather Than an End
Overview There may come a day where you need to script the migration of permissions from one Confluence Space to another. The permissions of a Confluence Space can be retrieved and treated as collection of objects. This allows us to easily pass them on to a source page as a new set of permissions. The… Read more: Copying Permissions From One Confluence Space to Another
Overview All Confluence Spaces have a sidebar, in which you’ll find the page hierarchy as well as any useful links that the Space Administrator has seen fit to add. Unfortunately Atlassian provide no clearly documented way of programmatically adding links to the sidebar of a Space. That doesn’t mean it’s not possible, but rather… Read more: Programmatically Adding Sidebar Shortcuts to a Confluence Space
If I wanted to perform a search of Jira using Groovy and ScriptRunner, I might make use of the SearchRequestService. This class contains many useful methods, most of them having to do with filters. A great many of these take a JiraServiceContext as an argument. For example, these are the parameters of the createFilter()… Read more: Jira Search Context
Overview It’s surprisingly difficult to simply return a list of administrators for a Jira project. I had to hunt for a relatively simple way to accomplish this. In the end I found a snippet to build on, written by Mark Markov and located here on the Atlassian forums. I initially got frustrated because I… Read more: Retrieving Users in a Given Project Role in Jira
Overview This script retrieves all the members of a supplied Confluence group, and then retrieves the timestamp of the last time that user logged in to Confluence. The Code As you can see from the code below, we’re working with three classes. The usual Component Locator, the Login Manager, and the Group Manager. After telling… Read more: Last Login Timestamp of all Members of a Confluence Group
Overview There are two types of permissions at the Space level in Confluence: Space permissions, and Page permissions. Page permissions are much simpler than Space permissions, for the simple reason that there are only TWO types of Page permission: VIEW and EDIT. Getting Permissions From a Page Simply retrieving the permissions of a Page is… Read more: Retrieving Confluence Page Permissions
Overview This piece of code does several things. It returns all of the Keys for all of the Spaces in Confluence. For each Space, it retrieves the associated categories (labels). For those Spaces with a certain category or label, it then performs some permissions management. Space Key Retrieval Let’s start with retrieving all of… Read more: Confluence Permissions Management – Removing and Adding Permissions to All Spaces
Here’s a chart of the types of permissions that may be granted to a user or group on a Confluence Space. These values would be useful in conjunction with a script that did something like setting permissions on a Confluence Space. “Delete Own” is undocumented by Atlassian, but maps to a value of “REMOVEOWNCONTENT”. “Restrictions… Read more: Confluence Space Permissions
Here’s some code that explores one of the basic tenets of programmatically managing Confluence: retrieving a list of administrators for a given Space. On it’s own this code doesn’t do much, but it is foundational to many more complicated solutions that you may be asked to code. import com.atlassian.confluence.security.SpacePermissionManager import com.atlassian.confluence.spaces.SpaceManager import com.atlassian.sal.api.component.ComponentLocator //Import the… Read more: Retrieving All Administrators For a Given Confluence Space
The basic management of Confluence Space permissions is quite trivial. However if you spend any time on the internet looking for a solution, you’ll find yourself going in circles, or starting to believe that Space permissions management is only possible via the front-end. There are essentially two ways in which an Atlassian product may be… Read more: Adding Confluence Space Permissions With Groovy and ScriptRunner