Export Task

Definition

An Export Task enables to export information (attributes) about a large population of objects (Identities, Organizations or Resources) to a file.

The generated export file can be exported by the user who triggered the export or by authorized users for exports triggered periodically by the system.

Two file formats supported are CSV and XLSX (Microsoft Excel).

Exported objects are sorted by identifier. Data is not ordered according to dependencies (such as manager first then user referencing manager). This is not an issue because an Import Task is able to re-order objects according to their dependencies.

Binary and encrypted attributes cannot be exported.

Use

An Export task can be :

Private, meaning the task has been executed on demand by a end user
Public, meaning the task is executed periodically by a scheduled job

Launch and Download an export file - Private Export

When a task execution is "private", only the user who launched it can access the corresponding export file (other users with administrative rights may also access it).

	Steps	Preview
1	In the My Exports Section, click on the Run Task button	Private Exports - Step 1 : Run Tasks
2	Select the Export to Run and click on Run Button	Private Exports - Step 2 : Select Export

Download an export file - Public Export

When a task execution is "public", only the users with appropriate rights can retrieve the export files produced by the scheduled job execution.

	Steps	Preview
1	In the Public Exports Section, for a dedicated task, click on the Download button	Public Exports - Downloads

Access Control

Execution rights can be granted on a per-task basis. For example, if two Export Tasks "A"and "B" are configured, a user may be allowed to execute "A" only, but not "B".

Administrative rights can also be granted so that a user can execute any Export Task (more on that later).

Access control is applied when:

configuring an Export Task, i.e. when creating/updating an Export Task Definition.
executing/canceling an Export Task
downloading the export file produced by an Export Task execution
deleting the export file produced by an Export Task execution

All these use cases are controlled using Permissions that follow the standard schemes:

Permissions

Permissions

Scope

Description

ExportTaskDefinition:create

ExportTaskDefinition:read

ExportTaskDefinition:update

ExportTaskDefinition:delete

GLOBAL

Configuration of ExportTaskDefinition.

Those are the CRUD permissions on the export task definitions. These are GLOBAL permissions, i.e. they are not applied on a per-task basis, they apply to all tasks, similar to other configuration permissions in Memority.

ExportTaskAccess:private

ExportTaskAccess:public

TASK (per Export Task Definition)

These permissions are based on a per-task definition basis. This means that a user can have those permissions to access task executions for some ExportTaskDefinitions only, but not others.

Here the permissions give access to either private task executions or public task executions:

for private executions:
- can run, read, cancel, download, cleanup executions that are launched by the user
for public executions:
- can read, download any public instance launched by a scheduled job

ExportTaskAdmin:run

ExportTaskAdmin:read

ExportTaskAdmin:cancel

ExportTaskAdmin:download

ExportTaskAdmin:cleanup

TASK (per Export Task Definition)

These permissions are based on a per-task definition basis. This means that a user can have those permissions to access task executions for some ExportTaskDefinitions only, but not others.

Here the permissions give access to task executions regardless of their "public" or "private" visibility. Those are administration capabilities.

Those permissions are arranged in the following rights that can be granted to users:

Rights

Right	Permissions	Security Scope	Description
sys.sync-export-task-definition-read	`ExportTaskDefinition:read`	GLOBAL	Reader of all Export Task Definitions.
sys.sync-export-task-definition-crud	`ExportTaskDefinition:create` `ExportTaskDefinition:read` `ExportTaskDefinition:update` `ExportTaskDefinition:delete`	GLOBAL	CRUD capability on all Export Task Definitions.
sys.sync-export-task-definition-admin	`ExportTaskDefinition:create` `ExportTaskDefinition:read` `ExportTaskDefinition:update` `ExportTaskDefinition:delete`	GLOBAL	Same as CRUD right above.
sys.sync-export-task-private	`ExportTaskAccess:private`	TASK (per Export Task Definition)	Give capacity to run an Export Task Definition and create a new private Export Task execution. Also give the capacity to manage any private Export Task that is owned by the same User (read, cancel, download, cleanup)
sys.sync-export-task-public	`ExportTaskAccess:public`	TASK (per Export Task Definition)	Give capacity to access the result of a public Export Task launched by a scheduled job (read, download).
sys.sync-export-task-manage	`ExportTaskAdmin:run ExportTaskAdmin:read ExportTaskAdmin:cancel ExportTaskAdmin:download ExportTaskAdmin:cleanup`	TASK (per Export Task Definition)	Give capacity to read/cancel/download/cleanup any execution (administration privilege) without taking ownership into consideration.

Configuration

The execution of an Export Task is not to be confused with its configuration. Tasks are configured by administrators, and can then be executed by end-users (or by the system when scheduled export), if they have the appropriate execution right on the Export Task.

If an attribute is multi-valued, its values are exported as concatenated using a configurable separator, e.g. a pipe "|", which would give: value1|value2|value3. However, it is possible to export one and only one multi-valued attribute as "expanded". For this attribute, one line is generated per value (which would give 3 lines in the previous example). For all those lines, other column values are duplicated, i.e. they are redundant.

Properties

An Export Task is configured through an Export Task Definition, whose properties are listed below.

Export Task Definition

Here are the "general" properties of an Export Task Definition:

Property Name	Type	Mandatory	Description	Values (default value in bold)
id	`String`	YES	The Export Task identifier.	-
name	`String`	YES	The Export Task name.	-
description	`String`	NO	The Export Task description.	-
active	`Boolean`	NO	Whether the Task is active or not. If not it cannot be launched.	true, false
fileType	`Choice`	YES	The format of the export file. Possible values are `CSV` or `XLSX`.	CSV, XLSX
csvFileOptions	-	NO	How the export file is formatted. Relevant only if `fileType` is `CSV`. If not defined, then defaults will apply (see next table below).	-
xlsxFileOptions	-	NO	How the export file is formatted. Relevant only if `fileType` is `XLSX`. If not defined, then defaults will apply (see next table below).	-
scope	-	YES if no reportingSource	Mutually exclusive with "reportingSource". The population targeted by the export. It may be further restricted by a search expression passed in the Export Options by the user launching the Export Task in the step 2 above. This is a "hard-coded" scope, i.e. it cannot contain variables (such as attribute values) that may be dynamically substituted according to the context. The scope format is represented in the XML example below.	-
reportingSource	-	YES if no scope	Mutually exclusive with "scope". Configuration for targeting an export from the REP service.	-
limit	`Integer`	NO	The maximum number of objects to export. If not defined, then all objects targeted by `scope` are exported. An implicit "order by id" sort criterion is applied when searching for objects to export.	-
relativeFilePath	`String`	NO	Optional: The relative path to the export file, e.g. `idm-export/SRHM-employees-{timestamp}.csv`. This relative path is appended to the root directory configured at the platform level (in a "properties" file) under which all export files are located. The full path is constructed using the tenant and the task definition id, as follows: "Private" exports: `/<configuredRoot>/<tenant>/private/<owner>/<exportTaskDefinitionId>/<relativeFilePath>` "Public" exports: `/<configuredRoot>/<tenant>/public/<exportTaskDefinitionId>/<relativeFilePath>` If the file extension is not explicitly provided here, then ".csv" or ".xlsx" is appended, according to the file format. Default value: `{taskDefinitionId}-{taskInstanceId}-{timestamp}.<type>` (where "type" is either "csv" or "xlsx"). Available placeholders are: `{timestamp}` the current date formatted as YYYYMMDDHHMMSS `{tenant}` the current tenant `{taskDefinitionId}` the identifier of the export task definition `{taskInstanceId}` the identifier of the task instance `{kind}` the object kind among "identity", "organization", "resource"	`{taskDefinitionId}-{taskInstanceId}-{timestamp}.<type>`
retentionPeriod	`Integer (days)`	NO	Number of days: the period during which the export file is available. It is deleted after this period. Defaults to 7 days.	7
attributes	`List of strings`	NO	For Object exports configured with the "scope" property: The list of attributes to export. If empty, then all attributes are exported, except binary and encrypted attributes which are always ignored by the export process. For Reporting exports configured with the "reportingSource" property: The list of Mongo documents fields. Cannot be empty.	Empty list
expandedMultiValuedAttribute	`String`	NO	The identifier of a multi valued attribute whose values will be expanded in the export file, i.e. one line is generated per attribute value. Only one multi valued attribute can be expanded when exporting.	-
executionPlan	`Complex`	NO	Configure the execution plan if the task is scheduled (see Execution Plan).	-
exportHooksRule	`Complex`	NO	Optional: If this rule is configured, it must by convention return an instance of import com.memority.domino.shared.api.sync.export.ExportHooks	-

Export Options

When executing an Export Task, export options can be submitted in the JSON body of the POST request. The possible export options are listed below:

Property Name	Type	Mandatory	Description	Values (default value in bold)
searchExpression	`-`	NO	A `SearchExpression` restricting the Scope configured in the `scope` property of the `ExportTaskDefinition`.	-
attributes	`List of strings`	NO	Restrict the list of exported attributes. If non empty then this list replaces the attributes configured in the `attributes` property of an `ExportTaskDefinition`. This list must be either empty, or a sub list of the `attributes` property of the `ExportTaskDefinition`.	Empty list
limit	`Integer`	NO	Can restrict the limit configured in the `limit` property of the `ExportTaskDefinition`.	-
fileType	`Choice`	NO	The format of the export file. Possible values are `CSV` or `XLSX`. If not present, the `fileType` configured on the `ExportTaskDefinition` is used.	CSV
fileOptions	-	NO	How the export file is formatted. See `CsvFileOptions` and `XlsxFileOptions`.	-

Csv File Options

The following table describes the properties of the CSV file options (see property csvFileOptions in the above table):

Property Name	Type	Mandatory	Description	Values (default value in bold)
quoteChar	`Single char`	NO	Character used for quotes.	Single quote '
delimiterChar	`Single char`	NO	Character delimiting columns.	Semi-colon ;
commentChar	`Single char`	NO	Character indicating a comment line.	Pound #
encoding	`Choice`	NO	Character encoding.	UTF-8
lineSeparator	`String`	NO	New line separator.	\r\n
multiValueDelimiterChar	`Single char`	NO	Separator character for multi values.	Pipe \|
includeHeaders	`Boolean`	NO	Whether the header line is written or not.	true, false

Xlsx File Options

The following table describes the properties of the XLSX file options (see property xlsxFileOptions in the above table):

Property Name	Type	Mandatory	Description	Values (default value in bold)
sheetName	`String`	NO	Name of the Excel sheet.	MemorityExport
multiValueDelimiterChar	`Single char`	NO	Separator character for multi values.	\n
autoSize	`Boolean`	NO	Whether to auto-size the columns or not.	true, false
includeHeaders	`Boolean`	NO	Whether the header line is written or not.	true, false

Export Rule Hooks

The export Rule Hooks property is a Compute Rule that must return a class implementing Export Hook interface.

Don't forget to import 2 classes in your Groovy script :

JAVA

import com.memority.domino.shared.api.sync.export.ExportHooks
import com.memority.domino.shared.api.sync.export.ExportWriter

Export Hook interface is as follow:

ExportHook interface

JAVA

/**
* Expose hooks enabling to alter the content of an export file during the various steps of the export file generation.
* Those hooks are meant to be implemented by a {@link ComputeRule} configured on an ExportTaskDefinition.
* The {@code ComputeRule}, if configured, returns an object implementing {@code ExportHooks} that performs
* custom write operations if needed.
* <p>
* A default implementation that does nothing is provided for each hook method, so that one may only override
* the methods requiring a custom processing.
*/
public interface ExportHooks {

/**
* Called at the very beginning of the export process, before writing headers.
* <p>
* By default this method does nothing.
*
* @param writer to write to the export file
*/
default void init(ExportWriter writer) {
// Do nothing by default
}

/**
* Called when the headers are about to be written to the export file.
* <p>
* By default this method writes the given attribute ids without modifying them.
*
* @param exportedAttributeIds the ids of the exported attributes, such as {@code "firstName"} or {@code "lastName"}
* @param writer to write to the export file
*/
default void headers(List<String> exportedAttributeIds, ExportWriter writer) {
writer.writeHeaders(exportedAttributeIds);
}

/**
* Called when a row is about to be written to the export file. This method may alter the values of the columns
* to be written, or write several rows by calling the given {@code writer} multiple times.
* <p>
* By default this method writes the given row without modifying it.
*
* @param row an ordered representation of the row's columns (the order is enforced by the {@link LinkedHashMap}
* implementation), whose keys are the exported attribute ids (such as {@code "firstName"}),
* and values the exported values (such as {@code "John")}
* @param writer to write to the export file
*/
default void row(LinkedHashMap<String, Object> row, ExportWriter writer) {
writer.writeRow(row);
}

/**
* Called at the end of the export process, after the last row has been written.
* <p>
* By default this method does nothing.
*
* @param writer to write to the export file
*/
default void finalize(ExportWriter writer) {
// Do nothing by default
}
}

Example

Here is a sample XML representation of an Export Task:

Sample Export Task

XML

<?xml version="1.0" encoding="UTF-8"?>
<dmn:ExportTaskDefinition xmlns:ctdcore="http://www.memority.com/citadel/core/1_0" xmlns:ctdidm="http://www.memority.com/citadel/idm/1_0" 
   xmlns:dmn="http://www.memority.com/domino_sync/1_0" xmlns:kit="http://www.memority.com/toolkit/1_0" 
   xmlns:notify="http://www.memority.com/toolkit/addons/notify/1_0" xmlns:rule="http://www.memority.com/toolkit/rule/1_0" 
   xmlns:search="http://www.memority.com/toolkit/search-expression/1_0" xmlns:xs="http://www.w3.org/2001/XMLSchema" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" id="sample_export_task">
   <name>Sample Export Task</name>
   <description>Description of Sample Export Task</description>
   <active>true</active>
   <scope objectKind="IDENTITY">
      <objectTypes>
         <objectType>employee</objectType>
      </objectTypes>
      <searchExpression>
         <search:Prop op="IS_NOT_NULL" name="status"/>
      </searchExpression>
   </scope>
   <fileType>XLSX</fileType>
   <csvFileOptions>
      <quoteChar>'</quoteChar>
      <delimiterChar>,</delimiterChar>
      <commentChar>#</commentChar>
      <encoding>UTF-8</encoding>
      <lineSeparator>

</lineSeparator>
      <multiValueDelimiterChar>|</multiValueDelimiterChar>
      <includeHeaders>true</includeHeaders>
   </csvFileOptions>
   <attributes>
      <attribute>id</attribute>
      <attribute>firstName</attribute>
      <attribute>lastName</attribute>
      <attribute>rights</attribute>
   </attributes>
   <expandedMultiValuedAttribute>rights</expandedMultiValuedAttribute>
   <limit>250</limit>
   <executionPlan>
      <scheduleType>ONCE</scheduleType>
      <fireTime>2020-05-15T16:10:05.540Z</fireTime>
      <interval>0</interval>
   </executionPlan>
   <relativeFilePath>idm-export/ACME-employees-{timestamp}.{type}</relativeFilePath>
   <retentionPeriod>P21D</retentionPeriod>
   <exportHooksRule type="COMPUTE" category="OBJECT" engineType="GROOVY">
        <spec><![CDATA[import com.memority.domino.shared.api.sync.export.ExportHooks
import com.memority.domino.shared.api.sync.export.ExportWriter

return new ExportHooks() {
    String COLUMN_NAME_1 = "NEW_COLUMN_1"
    String COLUMN_NAME_2 = "NEW_COLUMN_2"

    int counter

    void init(ExportWriter writer) {
        writer.writeLine("This is a comment at the beginning")
    }

    void headers(List<String> exportedAttributeIds, ExportWriter writer) {
        List<String> enhancedHeaders = new ArrayList<>(exportedAttributeIds);
        enhancedHeaders.add(COLUMN_NAME_1)
        enhancedHeaders.add(COLUMN_NAME_2)

        writer.writeHeaders(enhancedHeaders)
    }

    void row(LinkedHashMap<String, Object> row, ExportWriter writer) {
        LinkedHashMap<String, Object> amendedRow = new LinkedHashMap<>(row)

        counter++;
        if (counter % 2 == 0) {
            amendedRow.put(COLUMN_NAME_1, "new_value_1")
        } else {
            amendedRow.put(COLUMN_NAME_2, "new_value_2")
        }

        writer.writeRow(amendedRow)

        if (counter == 20) {
            writer.writeLine("This is a comment in the middle")
        }
    }

    void finalize(ExportWriter writer) {
        writer.writeLine("This is a comment at the end")
    }
}

]]></spec>
   </exportHooksRule>
</dmn:ExportTaskDefinition>

REST API

The Memority Synchronization service exposes the Export REST API.

The table below lists the full export REST API:

Full export REST API

Resource	Method	Body	Permission	Description	Response
APIs related to the configuration of an Export Task
`{tenant}/api/sync/conf/export-tasks/`	GET	N/A	`ExportTaskDefinition:read`	List all the export task definitions	As usual for configuration management.
`{tenant}/api/sync/conf/export-tasks/`	POST	JSON	`ExportTaskDefinition:create`	Create a new export task definition	As usual for configuration management.
`{tenant}/api/sync/conf/export-tasks/{task-id}`	GET/PUT/DELETE	N/A	`ExportTaskDefinition:read/update/delete`	Get or update or delete an export task definition	As usual for configuration management.
APIs related to the execution of an Export Task (require an `ExportTaskAdmin:?:?` permission)
`{tenant}/api/sync/export-tasks/{task-id}/instances`	POST	JSON	`ExportTaskAdmin:run:{task-id}`	Launch an export task by providing the identifier of an `ExportTaskDefinition` task configuration (path variable) and an `ExportOptions` object (JSON payload). The execution of this method is asynchronous, it immediately returns to the caller an UUID, the task instance id, that can then be used in the API methods below.	Success HTTP code 200. Body: a task instance id as a simple string (not JSON): an UUID identifier enabling to monitor the task progress, or cancel the running task (see below). Errors HTTP code 404 if the task configuration id is not found.
`{tenant}/api/sync/export-tasks/{task-id}/instances`	GET	N/A	`ExportTaskAdmin:read:{task-id}`	Get the report of all the export task executions of the given task definition	Success HTTP code 200. Body: a JSON list of task reports (see above)
`{tenant}/api/sync/export-tasks/{task-id}/instances/{task-instance-id}`	GET	N/A	`ExportTaskAdmin:read:{task-id}`	Monitor the execution of an export task. It returns a task progress The `task-instance-id` path parameter is the task tracking id that was immediately returned when the task was launched (see above).	Success HTTP code 200. Body: JSON Task progress information of a given task instance (see below) Errors HTTP code 404 if the task instance id is not found.
`{tenant}/api/sync/export-tasks/{task-id}/instances/{task-instance-id}/~cancel`	POST	N/A	`ExportTaskAdmin:cancel:{task-id}`	Cancel a task.	Success HTTP code 200 Body: empty. Errors HTTP code 404 if the task instance id is not found. HTTP code 409 ("conflict") if the task cannot be canceled because it is in a terminal state.
`{tenant}/api/sync/export-tasks/{task-id}/instances/{task-instance-id}/~content`	GET	N/A	`ExportTaskAdmin:download:{task-id}`	Return a multi-part corresponding to the content of the export file.	Success HTTP code 200. Body: a multi-part content (TODO specify more). Errors HTTP code 404 if the task instance id is not found. HTTP code 410 ("Gone") if the file is no longer available
`{tenant}/api/sync/export-tasks/{task-id}/instances/{task-instance-id}/~content`	DELETE	N/A	`ExportTaskAdmin:cleanup:{task-id}`	Need admin `cleanup` action. This will delete the output file of the corresponding export task.	Success HTTP code 204 ("No content"). Errors HTTP code 404 if the task instance id is not found.
`{tenant}/api/sync/export-tasks/~instances{?filter,kind,owner,visibility,triggerType}` `{tenant}/api/sync/export-tasks/~instances/~search{?filter,kind,owner,visibility,triggerType}`	GET	N/A	`ExportTaskAdmin:read:{task-id}`	Get all export task instances. Query parameters: filter = to filter by name kind = to filter by object kind owner = to filter by owner of the instance visibility = to filter based on visibility (either PRIVATE or PUBLIC) triggerType = to filter based on trigger type (either MANUAL or SCHEDULED) Note that access control is enforced. Instances are filtered based on the following rules: user has `read` action on the corresponding task definition This requires a post filter on the instances. This is used to populate the "All Exports" tab in the GUI	Success HTTP code 200.
APIs related to the execution of a private Export Task (require an `ExportTaskAccess:private:?` permission )
`{tenant}/api/sync/export-tasks/~private{?filter,kind}` `{tenant}/api/sync/export-tasks/~private/~search{?filter,kind}`	GET	N/A	`ExportTaskAccess:private:?`	Return all the export task definitions that I can run as private instances.	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~private/{task-id}`	GET	N/A	`ExportTaskAccess:private:{task-id}`	Get the export task definition for the given task identifier.	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~private/{task-id}/instances`	GET	N/A	`ExportTaskAccess:private:{task-id}`	Get the export task instances that are private to me for the given task identifier.	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~private/{task-id}/instances`	POST	JSON	`ExportTaskAccess:private:{task-id}`	Launch an private Export Task for the given task definition id and `ExportOptions` object (JSON payload). The execution of this method is asynchronous, it immediately returns to the caller an UUID, the task instance id, that can then be used in the API methods below.	Success HTTP code 200. Body: a task instance id as a simple string (not JSON): an UUID identifier enabling to monitor the task progress, or cancel the running task (see below). Errors HTTP code 404 if the task configuration id is not found.
`{tenant}/api/sync/export-tasks/~private/{task-id}/instances/{task-instance-id}/~cancel`	POST	N/A	`ExportTaskAccess:private:{task-id}`	Cancel a task. This method is idempotent. It may be launched consecutively several times without error, even if the task is not currently running.	Success HTTP code 200 Body: empty. Errors HTTP code 404 if the task instance id is not found.
`{tenant}/api/sync/export-tasks/~private/{task-id}/instances/{task-instance-id}/~content` `{tenant}/api/sync/export-tasks/~private/{task-id}/instances/{task-instance-id}`	GET	N/A	`ExportTaskAccess:private:{task-id}`	Return a multi-part corresponding to the content of the export file.	Success HTTP code 200. Body: a multi-part content (TODO specify more). Errors HTTP code 404 if the task instance id is not found. HTTP code 410 ("Gone") if the file is no longer available
`{tenant}/api/sync/export-tasks/~private/{task-id}/instances/{task-instance-id}/~content` `{tenant}/api/sync/export-tasks/~private/{task-id}/instances/{task-instance-id}`	DELETE	N/A	`ExportTaskAccess:private:{task-id}`	Need `private` and be owner of the instance. Deletes the output file of the corresponding export task instance.	Success HTTP code 204 ("No content"). Errors HTTP code 404 if the task instance id is not found.
`{tenant}/api/sync/export-tasks/~private/~instances{?filter,kind}` `{tenant}/api/sync/export-tasks/~private/~instances/~search{?filter,kind}`	GET	N/A	`ExportTaskAccess:private:?`	Return all of the private Export Task Instances (reports) that are owned by me. This is used to populate the "My Exports" tab in the GUI	Success HTTP code 200.
APIs related to the execution of a public Export Task (require an an `ExportTaskAccess:public:?` permission )
`{tenant}/api/sync/export-tasks/~public{?filter,kind} {tenant}/api/sync/export-tasks/~public/~search{?filter,kind}`	GET	JSON	`ExportTaskAccess:public:?`	Return all the export task definitions that are accessible by me. This is used to populate the "Public Exports" tab in the GUI	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~public/{task-id}`	GET	JSON	`ExportTaskAccess:public:{task-id}`	Get the export task definition for the given task identifier.	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~public/{task-id}/instances`	GET	JSON	`ExportTaskAccess:public:{task-id}`	Get the export task instances that are public to me for the given task identifier.	Success HTTP code 200.
`{tenant}/api/sync/export-tasks/~public/{task-id}/instances/{task-instance-id}/~content` `{tenant}/api/sync/export-tasks/~public/{task-id}/instances/{task-instance-id}`	GET	N/A	`ExportTaskAccess:public:{task-id}`	Return a multi-part corresponding to the content of the export file.	Success HTTP code 200. Body: a multi-part content (TODO specify more). Errors HTTP code 404 if the task instance id is not found. HTTP code 410 ("Gone") if the file is no longer available
`{tenant}/api/sync/export-tasks/~public/~instances{?filter,kind}` `{tenant}/api/sync/export-tasks/~public/~instances/~search{?filter,kind}`	GET	JSON	`ExportTaskAccess:public:?`	Return all of the public Export Task Instances (reports) that are available to me This is used to populate the "Public Exports" tab in the GUI, to know which task has available files to download.	Success HTTP code 200.

Use