Let’s imagine. Together.

Let’s imagine that you have the need for a Confluence Cloud user macro.  This macro needs to examine some aspect of itself, such as the contents stored in its body.   In other words, we want the macro to look inward and take some action based on what it sees.

Please note that user macros in Confluence Cloud are the resulting having ScriptRunner installed.  Unlike Confluence Server, user macros are not a default feature in the cloud.

We know that the attributes of the macro itself can be queried with the REST API, using this endpoint:  

/wiki/rest/api/content/{id}/history/{version}/macro/id/{macroId}

When queried, this endpoint returns a JSON blob that gives us everything there is to know about the macro:

{
  "name": "<string>",
  "body": "<string>",
  "parameters": {},
  "_links": {}
}

Thus, we conclude that we need to somehow fetch three pieces of information, to in turn fetch information about the macro. We need the page ID, the page version, and the macro ID.  This information is easily returned through the parameters method. 

Confluence Cloud macros have the concept of parameters built in from the beginning. That is, they don’t require imports or additional references to other libraries. Let’s take a look:

def currentPageId = parameters.pageId

return currentPageId.toString()

In order to reference any of the parameters of the macro (and the page), we’re using parameters.<element>.   The parameters class will return pageVersion, macroId, spaceKey, and pageId. Three of the four of these elements were precisely what we needed to return the body of the macro. Thus, we have a method of achieving the goal.

def macroBody = get("/wiki/rest/api/content/${parameters.pageId}/history/${parameters.pageVersion}/macro/id/${parameters.macroId}")
.asJson()

 return macroBody.body.jsonObject.body.toString()

In this code, we’re explicitly interpolating the required values in the string that makes up the REST API endpoint.   In a production version of the script, these values would be assigned to a variable.

Note the structure of the macroBody object.  macroBody iself is an HTTP request, which has its own body.  The body has a JSON object, which in turn has its own “body” element.  Finally, we cast the resulting JSON to a string, because that is the only thing that a Confluence Macro can return.

If this macro were to be added to a page, it would return any content stored within the macro.  This includes rich text content, images, and anything else that can be stored on a Confluence page.   While not especially useful on its own, this illustrates how a Confluence Cloud macro may examine itself.