RelativityOne

https://platform.relativity.com
Admin
RelativityOne is a cloud-based e-discovery platform that provides APIs and developer tools for...
Tokens:3,202,634
Snippets:25,442
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Application Install Status Response (Example 1)

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Library_Application_service.htm

This JSON response shows the details of a completed library application installation. It includes identifiers, status, validation results, version information, and timestamps for when the installation started and completed.

```JSON
{
    "ApplicationInstallID": 18211,
    "ApplicationIdentifier": {
        "ArtifactID": 1015285,
        "Guids": []
    },
    "WorkspaceIdentifier": {
        "ArtifactID": -1,
        "Guids": []
    },
    "InstallStatus": {
        "Code": "Completed"
    },
    "ValidationResult": {
        "RetryInstallAction": {
            "Name": "RetryApplicationInstall",
            "Href": "relativity-environment/v1/workspace/-1/libraryapplications/1015285/install",
            "Verb": "POST",
            "IsAvailable": true,
            "Reason": []
        },
        "RetryInstallRequestTemplate": {
            "WorkspaceIDs": [
                -1
            ],
            "UnlockApplications": false,
            "ConflictResolutions": []
        },
        "InstallConflicts": []
    },
    "Version": "10.3.0.0",
    "ValidationMessages": [],
    "InstalledBy": {
        "Name": "Admin, Relativity",
        "ArtifactID": 9,
        "Guids": []
    },
    "StartedOn": "2019-06-24T14:52:36.35",
    "CompletedOn": "2019-06-24T14:52:42.087"
}
```

--------------------------------

### Application Installations Response Example

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_service.htm

This is an example of the response received when querying for application installations. It includes details about each installed application.

```JSON
{
    "Results": [
        {
            "ApplicationInstallID": 53784,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "New Case Template",
                "ArtifactID": 1014823,
                "Guids": []
            },
            "ClientIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1006066,
                "Guids": []
            },
            "MatterIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1000002,
                "Guids": []
            },
            "RootFolderID": 1003697,
            "InstallStatus": {
                "Code": "Completed"
            },
            "SchemaVersion": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:02:12.11",
            "CompletedOn": "2019-12-02T17:02:55.58"
        },
        {
            "ApplicationInstallID": 53801,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "Relativity Starter Template",
                "ArtifactID": 1015024,
                "Guids": []
            },
            "ClientIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1006066,
                "Guids": []
            },
            "MatterIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1000002,
                "Guids": []
            },
            "RootFolderID": 1003697,
            "InstallStatus": {
                "Code": "Completed"
            },
            "SchemaVersion": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:02:17.017",
            "CompletedOn": "2019-12-02T17:03:00.283"
        },
        {
            "ApplicationInstallID": 53869,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "Test-0db2cf10-97e7-456f-af89-e8186c720656",
                "ArtifactID": 1015286,
                "Guids": []
            },
            "ClientIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1006066,
                "Guids": []
            },
            "MatterIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1000002,
                "Guids": []
            },
            "RootFolderID": 1003697,
            "InstallStatus": {
                "Code": "Completed"
            },
            "SchemaVersion": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:03:04.11",
            "CompletedOn": "2019-12-02T17:03:47.58"
        }
    ]
}
```

--------------------------------

### Retrieve Application Install Details by Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Use this method to get installation details for an application using its GUID. It includes parameters for pagination.

```csharp
public async Task GetApplicationInstallDetails(IApplicationInstallManager applicationInstallManager, Guid applicationGuid, int applicationInstallID, int start, int length)  
{
    try  
    {
        GetApplicationInstallDetailsResponse response = await applicationInstallManager.GetApplicationInstallDetailsAsync(ADMIN_WORKSPACE_ID, applicationGuid, applicationInstallID, start, length);  
        string info = string.Format($"The installation details for Library Application Installation with ID {response.ApplicationInstallID} were successfully retrieved.");  
        Console.WriteLine(info);  
    }
    catch (Exception ex)  
    {
        string exception = $"An error occurred: {ex.Message}";  
        Console.WriteLine(exception);  
    }
}
```

--------------------------------

### Install Application by GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Use this method to install an application from the library into one or more workspaces using its GUID. It queues installation requests and logs the outcome for each workspace.

```csharp
public async Task InstallApplication(IApplicationInstallManager applicationInstallManager, Guid applicationGuid, List<int> workspaces, bool unlockApps)
{
    try
    {
        InstallApplicationRequest request = new InstallApplicationRequest
        {
            WorkspaceIDs = workspaces,
            UnlockApplications = unlockApps
        };

        InstallApplicationResponse response = await applicationInstallManager.InstallApplicationAsync(ADMIN_WORKSPACE_ID, applicationGuid, request);

        if (response.Results.Count == workspaces.Count)
        {
            string info = string.Format($"Queuing {response.Results.Count} installation(s) for the Library Application with Guid {applicationGuid}.");
            Console.WriteLine(info);
        }
        else
        {
            string info = string.Format($"Queuing {response.Results.Count} installation(s) for the Library Application with Guid {applicationGuid} " +
                                                $"since one or more workspaces already have the same version of this application installed.");
            Console.WriteLine(info);
        }
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Library Application Response Example

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Library_Application_service.htm

This is an example of the response received after creating a library application. It includes the application's identifier, available actions, installation ID, and installation status.

```json
1
2
3
4
5
6
7
8
9
10
11
12
13
{
    "ApplicationIdentifier": {
        "ArtifactID": 1022432,
        "Guids": [
            "74f3c015-f382-476d-838e-275b13919f91"
        ]
    },
    "Actions": [],
    "ApplicationInstallID": 1,
    "InstallStatus": {
        "Code": "Pending"
    },
}
```

--------------------------------

### Application Install Response Example

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Library_Application_service.htm

This JSON response indicates the status of an application installation, including its identifier, install ID, and current status.

```JSON
{
    "ApplicationIdentifier": {
        "ArtifactID": 1015285,
        "Guids": [
            "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
        ]
    },
    "ApplicationInstallID": 18211,
    "InstallStatus": {
        "Code": "Pending"
    }
}
```

--------------------------------

### Install Application by Application GUID with Actions

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Application_Install_API.htm

This method installs an application to all workspaces using its GUID, with an option to include actions. It forces installation and can optionally unlock applications.

```csharp
public async Task InstallApplicationAll(IApplicationInstallManager applicationInstallManager, Guid applicationGuid, bool unlockApps, bool includeActions)
{
    try
    {
        InstallApplicationAllRequest request = new InstallApplicationAllRequest
        {
            Mode = ApplicationInstallTargetOption.ForceInstall,
            UnlockApplications = unlockApps
        };

        InstallApplicationResponse response = await applicationInstallManager.InstallApplicationAllAsync(ADMIN_WORKSPACE_ID, applicationGuid, request, includeActions);

        if (response.Results.Count > 0)
        {
            string info = string.Format($"Queuing {response.Results.Count} installations for the Library Application with Guid {applicationGuid}.");
            Console.WriteLine(info);
        }
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Pre Install Event Handler Example

Source: https://platform.relativity.com/llms.txt

This C# code sample illustrates a Pre Install event handler. It executes before an application is fully deployed, allowing for tasks like creating database tables or checking application versions.

```csharp
using System;
using System.Runtime.InteropServices;
using Relativity.API;

namespace MyCustomCode
{
    [kCura.EventHandler.CustomAttributes.Description("Pre Install Event Handler")]
    [kCura.EventHandler.CustomAttributes.RunForEachWorkspace]
    [kCura.EventHandler.CustomAttributes.RunInAgent]
    public class PreInstallEventHandler : kCura.EventHandler.RSAPIEventHandlers.PreInstallEventHandler
    {
        public override kCura.EventHandler.Response Execute()
        {
            // TODO: Implement your custom logic here.
            // For example, you can create database tables or perform other tasks before deployment.
            // The following is a placeholder for demonstration purposes.
            LogMessage("Pre Install Event Handler executed successfully.");

            return new kCura.EventHandler.Response { Success = true };
        }

        private void LogMessage(string message)
        {
            IServicesMgr servicesMgr = (IServicesMgr)Helper.GetServicesManager();
            IAPILog log = servicesMgr.GetLogService();
            log.LogVerbose(message);
        }
    }
}
```

--------------------------------

### Example of a Post Install Event Handler

Source: https://platform.relativity.com/llms.txt

Illustrates the structure and usage of a Post Install event handler in Relativity. This type of handler executes immediately after an application is installed.

```csharp
using Relativity.Services.Application;
using Relativity.Services.Objects.DataContracts;
using System.Threading.Tasks;

namespace Relativity.Custom.Example.PostInstall
{
    public class PostInstallEventHandler : IEventEventHandler
    {
        public async Task ExecuteAsync(IEventCallback callback)
        {
            // Example: Log a message indicating the event handler has executed.
            await callback.LogAsync("Post Install Event Handler executed successfully.");

            // Example: Retrieve application details.
            ApplicationInfo appInfo = await callback.GetApplicationInfoAsync();
            await callback.LogAsync($"Application Name: {appInfo.Name}, Version: {appInfo.Version}");

            // Example: Update a field on a specific RDO (Relativity Dynamic Object).
            // Replace 'YourRdoArtifactId' and 'YourFieldArtifactId' with actual IDs.
            // var updateRequest = new MassUpdateDataRequest
            // {
            //     ObjectArtifactID = 12345, // Example RDO Artifact ID
            //     FieldValues = new FieldValuePair[]
            //     {
            //         new FieldValuePair
            //         {
            //             FieldID = 67890, // Example Field Artifact ID
            //             Value = "Updated Value"
            //         }
            //     }
            // };
            // await callback.MassUpdateAsync(updateRequest);
            // await callback.LogAsync("Successfully updated RDO field.");
        }
    }
}
```

--------------------------------

### Application Install Search Response

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Application_Install_service.htm

This is an example of the JSON response when searching for application installations. It contains details about each installation, including its ID, application identifier, workspace, and installation status.

```JSON
{
    "Results": [
        {
            "ApplicationInstallID": 53769,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "Admin Case",
                "ArtifactID": -1,
                "Guids": []
            },
            "RootFolderID": 0,
            "InstallStatus": {
                "Code": "Completed",
                "GetDetailsAction": {
                    "Name": "GetInstallDetails-DefaultPage",
                    "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/53769/details/1/10",
                    "Verb": "GET",
                    "IsAvailable": true,
                    "Reason": []
                }
            },
            "Version": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:01:32.753",
            "CompletedOn": "2019-12-02T17:01:49.923"
        },
        {
            "ApplicationInstallID": 53784,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "New Case Template",
                "ArtifactID": 1014823,
                "Guids": []
            },
            "ClientIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1006066,
                "Guids": []
            },
            "MatterIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1000002,
                "Guids": []
            },
            "RootFolderID": 1003697,
            "InstallStatus": {
                "Code": "Completed",
                "GetDetailsAction": {
                    "Name": "GetInstallDetails-DefaultPage",
                    "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/53784/details/1/10",
                    "Verb": "GET",
                    "IsAvailable": true,
                    "Reason": []
                }
            },
            "Version": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:02:12.11",
            "CompletedOn": "2019-12-02T17:02:55.58"
        },
        {
            "ApplicationInstallID": 53801,
            "ApplicationIdentifier": {
                "Name": "Imaging",
                "ArtifactID": 1015285,
                "Guids": [
                    "c9e4322e-6bd8-4a37-ae9e-c3c9be31776b"
                ]
            },
            "WorkspaceIdentifier": {
                "Name": "New Case Template",
                "ArtifactID": 1014823,
                "Guids": []
            },
            "ClientIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1006066,
                "Guids": []
            },
            "MatterIdentifier": {
                "Name": "Relativity Template",
                "ArtifactID": 1000002,
                "Guids": []
            },
            "RootFolderID": 1003697,
            "InstallStatus": {
                "Code": "Completed",
                "GetDetailsAction": {
                    "Name": "GetInstallDetails-DefaultPage",
                    "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/53801/details/1/10",
                    "Verb": "GET",
                    "IsAvailable": true,
                    "Reason": []
                }
            },
            "Version": "11.1.0.0",
            "IsOutOfDate": false,
            "InstalledBy": {
                "Name": "Service Account, Relativity",
                "ArtifactID": 777,
                "Guids": []
            },
            "StartedOn": "2019-12-02T17:03:01.11",
            "CompletedOn": "2019-12-02T17:03:30.58"
        }
    ]
}
```

--------------------------------

### Install Application by GUID with Actions

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Application_Install_service.htm

Use this URL to install an application to a specific workspace using its GUID, with an option to include actions. The workspace ID is set to -1 to indicate all workspaces.

```HTTP
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{IncludeActions}
```

--------------------------------

### Install Application via REST API

Source: https://platform.relativity.com/llms.txt

Demonstrates how to install an application library to specific workspaces using the REST API. Requires appropriate permissions and knowledge of the application's metadata.

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Relativity.Services.ApplicationManagement;

namespace Relativity.Services.Samples.ApplicationManagement
{
    public class ApplicationInstallSample
    {
        public async Task InstallApplicationToWorkspaceAsync(IApplicationInstallManager applicationInstallManager, int workspaceArtifactId, Guid applicationGuid)
        {
            await applicationInstallManager.InstallApplicationToWorkspaceAsync(workspaceArtifactId, applicationGuid);
        }
    }
}
```

--------------------------------

### Start Target Generation Request Example

Source: https://platform.relativity.com/llms.txt

This JSON object represents a sample request body for starting target generation for a collection.

```json
{
  "collectionId": "12345-abcd-6789-efgh"
}
```

--------------------------------

### Get Application Install Status by Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Retrieves the installation status of an application using its GUID and installation ID. This method is useful when the application's GUID is known and requires polling for status updates.

```csharp
public async Task GetInstallStatus(IApplicationInstallManager applicationInstallManager, Guid applicationGuid, int applicationInstallID)  
{
    try
    {
        GetInstallStatusResponse response = await applicationInstallManager.GetStatusAsync(ADMIN_WORKSPACE_ID, applicationGuid, applicationInstallID);
        string info = string.Format($"Application Installation record for Library Application with Guid {applicationGuid} successfully read -- Status: {response.InstallStatus.Code}, Version: {response.Version}.");
        Console.WriteLine(info);
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Application Install (REST)

Source: https://platform.relativity.com/llms.txt

The Application Install service through the REST API allows clients to manage applications in the library. This includes reading metadata, uploading, updating, and deleting applications, as well as managing their installation across workspaces.

```APIDOC
## Application Install (REST)

### Description
Manages applications within the Relativity library via REST API. Supports reading metadata, uploading, updating, deleting applications, and controlling workspace installations.

### Method
GET, POST, PUT, DELETE (specific methods depend on the operation)

### Endpoint
(Specific endpoints are detailed within the linked documentation, covering operations like installing to workspaces, retrieving status, and validating names)

### Parameters
(Parameters vary by operation, including application details, workspace IDs, and installation status flags)

### Request Example
(Examples for uploading or installing applications would be provided in the detailed documentation)

### Response
(Responses include application metadata, installation status, and validation results)
```

--------------------------------

### Get Application Install Details by Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/OASFiles/Relativity.Environment.Services.Interfaces.Environment.V1.json

Retrieves details for a specific application installation within a workspace using the application GUID.

```APIDOC
## GET /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/{start}/{length}/{includeActions}

### Description
Retrieves details for a specific application installation within a workspace using its GUID.

### Method
GET

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/{start}/{length}/{includeActions}

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The unique identifier for the workspace.
- **applicationGuid** (string) - Required - The GUID of the application.
- **applicationInstallID** (string) - Required - The unique identifier for the application installation.
- **start** (integer) - Required - The starting index for pagination.
- **length** (integer) - Required - The number of items to retrieve for pagination.
- **includeActions** (boolean) - Required - Whether to include actions in the details.

### Response
#### Success Response (200)
- **schema** (object) - The schema for the application install details response.
```

--------------------------------

### Get Application Install Status by GUID with Actions

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Retrieves the installation status of an application using its GUID, with an option to include associated actions. This provides more detailed information about the installation process.

```csharp
public async Task GetInstallStatusWithoutInstallID(IApplicationInstallManager applicationInstallManager, int workspaceID, Guid applicationGuid, bool includeActions)  
{
    try
    {
        GetInstallStatusResponse response = await applicationInstallManager.GetStatusAsync(workspaceID, applicationGuid, includeActions);
        string info = string.Format($"Application Installation record for Library Application with Guid {applicationGuid} in workspace with ID {workspaceID} successfully read -- Status: {response.InstallStatus.Code}, Version: {response.Version}.");
        Console.WriteLine(info);
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Main Application Logic

Source: https://platform.relativity.com/Server2025/Content/Get_started/Lesson_6_-_Create_a_custom_page.htm

Initializes the application by importing necessary classes, creating dependencies for SearchHandler, and setting up event listeners for search functionality.

```javascript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
```

--------------------------------

### Create Proxy for Application Install API

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Application_Install_API.htm

Demonstrates how to create a proxy to interact with the IApplicationInstall API using the CreateProxy() method. Ensure you have the Client.SamplesLibrary.Helper.IHelper initialized.

```csharp
Client.SamplesLibrary.Helper.IHelper helper;

// Create a proxy
using (IApplicationRepository applicationRepository = helper.GetServicesManager().CreateProxy<IApplicationManager>(ExecutionIdentity.User))
{
    // Add your custom code ...
}
```

--------------------------------

### Install Application All Async

Source: https://platform.relativity.com/RelativityOne/Content/OASFiles/Relativity.Environment.Services.Interfaces.Environment.V1.json

Installs all available applications within the library to a specified workspace.

```APIDOC
## POST /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationID}/install/all

### Description
Installs all applications from the library into the specified workspace.

### Method
POST

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationID}/install/all

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The ID of the workspace.
- **applicationID** (string) - Required - The ID of the application.

#### Request Body
- **InstallApplicationAllRequest** (object) - Required - The request body containing details for installing all applications.

### Request Example
```json
{
  "example": "InstallApplicationAllRequest body"
}
```

### Response
#### Success Response (200)
- **InstallApplicationResponse** (object) - Details of the application installation operation.
```

--------------------------------

### Get Application Install Status by GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Retrieves the installation status of an application using its GUID. This method is useful when you have the application's unique identifier.

```csharp
public async Task GetInstallStatusWithoutInstallID(IApplicationInstallManager applicationInstallManager, int workspaceID, Guid applicationGuid)  
{
    try
    {
        GetInstallStatusResponse response = await applicationInstallManager.GetStatusAsync(workspaceID, applicationGuid);
        string info = string.Format($"Application Installation record for Library Application with Guid {applicationGuid} in workspace with ID {workspaceID} successfully read -- Status: {response.InstallStatus.Code}, Version: {response.Version}.");
        Console.WriteLine(info);
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Example rule configuration

Source: https://platform.relativity.com/Server2025/Content/Logging/Configure_logging.htm

This example demonstrates how to set a specific logging level for a particular application while setting a default logging level for all other systems. Ensure more specific rules are placed before general ones.

```xml
<rules enabled="true">
    <rule application="ed0e23f9-da60-4298-af9a-ae6a9b6a9319" loggingLevel="Verbose" sink="File1"/>
    <rule system="*" loggingLevel="Error" sink="File1"/>
</rules>
```

--------------------------------

### Get Library Install Status with Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Library_Application_API.htm

Retrieves the installation status for a library application using its GUID. Includes error handling for exceptions.

```csharp
public async Task GetLibraryInstallStatus(ILibraryApplicationManager libraryApplicationManager, Guid applicationGuid)  
{  
    try  
    {  
        GetInstallStatusResponse response = await libraryApplicationManager.GetLibraryInstallStatusAsync(ADMIN_WORKSPACE_ID, applicationGuid);  
        string info = string.Format($"Library Installation record for Library Application with GUID {applicationGuid} was successfully read -- " +  
                                    $\"Status: {response.InstallStatus.Code}, Version: {response.Version}.");  
        Console.WriteLine(info);  
    }  
    catch (Exception ex)  
    {  
        string exception = $"An error occurred: {ex.Message}";  
        Console.WriteLine(exception);  
    }  
}
```

--------------------------------

### Application Install API Operations

Source: https://platform.relativity.com/llms.txt

The Library Application API allows clients to manage applications within Relativity, including installation, updates, and retrieval of installation status.

```APIDOC
## Application Install API Operations

### Install an application library to specific workspaces
Installs an application library to a specified set of workspaces.

### Install an application library to all workspaces
Installs an application library to all available workspaces.

### Retrieve the installation status of an application
Retrieves the installation status for a given application.

### Retrieve the number of workspaces with an outdated application
Gets the count of workspaces where an application is outdated.

### Cancel pending application installations
Cancels any pending application installations.

### Retrieve installation details for an application
Fetches detailed installation information for an application.

### Generate an installation report
Generates a report detailing application installations.

### Retrieve installation status by workspace
Retrieves the installation status of an application within a specific workspace.

### Supported Condition Fields
Lists the fields supported for filtering application installations.

### Query for application installations by identifier
Queries for application installations using their unique identifier.

### Validate new artifact names
Validates the names of new artifacts for applications.

### Query for application installations with additional fields
Queries for application installations, including additional specified fields.

### Workflow-Based code samples
Provides code samples demonstrating workflow-based operations for the Application Install API.
```

--------------------------------

### TypeScript Example for rwcbutton

Source: https://platform.relativity.com/llms.txt

Provides a recommended TypeScript example for creating toolbar controls using the rwcbutton component. This is used for custom button functionalities in the Review Interface.

```typescript
import { RwcButton } from "relativity-viewer-api";

// Example usage of RwcButton
const myButton = new RwcButton({
    id: "my-custom-button",
    text: "Click Me",
    // ... other properties
});

```

--------------------------------

### Register an Action (.NET)

Source: https://platform.relativity.com/llms.txt

Example of how to register an action using the .NET SDK for Automated Workflows.

```.NET
using System;
using System.Threading.Tasks;
using Relativity.AutomatedWorkflows.SDK.Models;
using Relativity.AutomatedWorkflows.SDK.Services;

public class ActionRegistration
{
    private readonly IAutomatedWorkflowsManager _automatedWorkflowsManager;

    public ActionRegistration(IAutomatedWorkflowsManager automatedWorkflowsManager)
    {
        _automatedWorkflowsManager = automatedWorkflowsManager;
    }

    public async Task RegisterActionAsync(Guid workflowId, string actionName, string actionDisplayName)
    {
        var action = new Action
        {
            WorkflowId = workflowId,
            Name = actionName,
            DisplayName = actionDisplayName
        };

        await _automatedWorkflowsManager.RegisterActionAsync(action);
        Console.WriteLine($"Action '{actionName}' registered successfully.");
    }
}
```

--------------------------------

### SetUp Method for Unit Tests

Source: https://platform.relativity.com/Server2025/Content/Get_started/Lesson_4_-_Validate_object_changes.htm

Implement the SetUp method to initialize mocked dependencies and objects before each test runs. This includes mocking IWikipediaService, ILog, IEHHelper, and creating an activeArtifact.

```csharp
[SetUp]

public void SetUp()
{
 var wiki = new Mock < IWikipediaService > ();
 wiki.Setup(s =>s.GetCategoriesByPrefixAsync(It.IsAny < string > ())).Returns(Task.FromResult(
 new List < CategoryResponseModel > (wikiCategories.Select(s =>new CategoryResponseModel {
 Title = s
}))));

 wikiService = wiki.Object;
 logger = new Mock < ILog > ().Object;
 helper = new Mock < IEHHelper > ().Object;
 activeArtifact = new kCura.EventHandler.Artifact(0, null, 0, "", true, new kCura.EventHandler.FieldCollection());
}
```

--------------------------------

### Get Application Install Details Report by Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/OASFiles/Relativity.Environment.Services.Interfaces.Environment.V1.json

Retrieves a report of application installation details for a specific application within a workspace using its GUID.

```APIDOC
## GET /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/report

### Description
Retrieves a report of application installation details for a specific application within a workspace using its GUID.

### Method
GET

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/report

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The unique identifier for the workspace.
- **applicationGuid** (string) - Required - The GUID of the application.
- **applicationInstallID** (string) - Required - The unique identifier for the application installation.

### Response
#### Success Response (200)
- **schema** (object) - The schema for the application install details report, likely an IKeplerStream.
```

--------------------------------

### Get Library Install Status with Application Guid and Actions

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Library_Application_API.htm

Retrieves the installation status for a library application by GUID, with an option to include actions. Includes exception handling.

```csharp
public async Task GetLibraryInstallStatus(ILibraryApplicationManager libraryApplicationManager, Guid applicationGuid, bool includeActions)  
{  
    try  
    {  
        GetInstallStatusResponse response = await libraryApplicationManager.GetLibraryInstallStatusAsync(ADMIN_WORKSPACE_ID, applicationGuid, includeActions);  
        string info = string.Format($"Library Installation record for Library Application with GUID {applicationGuid} was successfully read -- " +  
                                    $\"Status: {response.InstallStatus.Code}, Version: {response.Version}.");  
        Console.WriteLine(info);  
    }  
    catch (Exception ex)  
    {  
        string exception = $"An error occurred: {ex.Message}";  
        Console.WriteLine(exception);  
    }  
}
```

--------------------------------

### Install Application All Async

Source: https://platform.relativity.com/RelativityOne/Content/OASFiles/Relativity.Environment.Services.Interfaces.Environment.V1.json

Installs all library applications for a given workspace. This operation can be invoked with or without including actions.

```APIDOC
## POST /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGUID}/install/all

### Description
Installs all library applications for the specified workspace using the application GUID.

### Method
POST

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGUID}/install/all

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The ID of the workspace.
- **applicationGUID** (string) - Required - The GUID of the application to install.

#### Request Body
- **schema** (object) - Required - Refers to `#/components/schemas/InstallApplicationAllRequest`.

### Response
#### Success Response (200)
- **schema** (object) - Refers to `#/components/schemas/InstallApplicationResponse`.
```

```APIDOC
## POST /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationID}/install/all/{includeActions}

### Description
Installs all library applications for the specified workspace, with an option to include actions.

### Method
POST

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationID}/install/all/{includeActions}

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The ID of the workspace.
- **applicationID** (string) - Required - The ID of the application to install.
- **includeActions** (boolean) - Required - Specifies whether to include actions during installation.

#### Request Body
- **schema** (object) - Required - Refers to `#/components/schemas/InstallApplicationAllRequest`.

### Response
#### Success Response (200)
- **schema** (object) - Refers to `#/components/schemas/InstallApplicationResponse`.
```

```APIDOC
## POST /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGUID}/install/all/{includeActions}

### Description
Installs all library applications for the specified workspace using the application GUID, with an option to include actions.

### Method
POST

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGUID}/install/all/{includeActions}

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The ID of the workspace.
- **applicationGUID** (string) - Required - The GUID of the application to install.
- **includeActions** (boolean) - Required - Specifies whether to include actions during installation.

#### Request Body
- **schema** (object) - Required - Refers to `#/components/schemas/InstallApplicationAllRequest`.

### Response
#### Success Response (200)
- **schema** (object) - Refers to `#/components/schemas/InstallApplicationResponse`.
```

--------------------------------

### Query Application Installations by GUID

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Application_Install_service.htm

Use this endpoint to search for application installations by their GUID. The 'start' and 'length' parameters control pagination, and 'includeActions' determines if pagination properties are populated.

```HTTP
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid:guid}/install/search?start={start}&length={length}&includeActions={includeActions}
```

--------------------------------

### C# Example: Create Instance Setting

Source: https://platform.relativity.com/Server2025/Content/BD_Environment/Instance_Setting_Manager_service.htm

This .NET code sample demonstrates how to create an instance setting using the Instance Setting Manager service. It includes setting up an HttpClient, defining the request URL and payload, and sending a POST request.

```csharp
private HttpClient GetHttpClient()  
{
    HttpClient httpClient = new HttpClient();  
    
    httpClient.BaseAddress = new Uri("https://localhost/");  
    httpClient.DefaultRequestHeaders.Add("X-CSRF-Header", "-");  
    httpClient.DefaultRequestHeaders.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes("test@test.com:SomePassword")));  
    
    return httpClient;  
}  

public async Task<int> Create()  
{
    string url = "/Relativity.REST/api/Relativity.InstanceSettings/workspace/-1/instancesettings/";  
    string payload = @"{{
        ""instanceSetting"": {{
            ""Name"": ""Sample Instance Setting name"",
            ""Section"": ""Sample Instance Setting section"",
            ""Machine"": """,
            ""ValueType"": 1,
            ""Value"": ""Sample text value!"",
            ""InitialValue"": ""Sample initial value"",
            ""Encrypted"": false,
            ""Description"": ""Sample description"",
            ""Keywords"": ""Sample keywords"",
            ""Notes"": ""Sample notes""
        }}
    }}";  

    var content = new StringContent(payload, Encoding.UTF8, "application/json");  

    HttpClient httpClient = GetHttpClient();  
    HttpResponseMessage response = await httpClient.PostAsync(url, content);  
    string result = await response.Content.ReadAsStringAsync();  

    if (response.StatusCode != HttpStatusCode.OK)  
    {
        throw new Exception($"Failed to create: {result}");  
    }

    int artifactID = int.Parse(result);  
    _logger.LogDebug($"REST call was successful. Created Instance Setting with artifact ID {artifactID}.");  

    return artifactID;  
}
```

--------------------------------

### Get Application Install Status with Actions by Application GUID

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_API.htm

Retrieves the installation status of an application by its GUID, including actions. This method is suitable for querying status when the application's GUID is known and action details are needed.

```csharp
public async Task GetInstallStatus(IApplicationInstallManager applicationInstallManager, Guid applicationGuid, int applicationInstallID, bool includeActions)  
{
    try
    {
        GetInstallStatusResponse response = await applicationInstallManager.GetStatusAsync(ADMIN_WORKSPACE_ID, applicationGuid, applicationInstallID, includeActions);
        string info = string.Format($"Application Installation record for Library Application with Guid {applicationGuid} successfully read -- Status: {response.InstallStatus.Code}, Version: {response.Version}.");
        Console.WriteLine(info);
    }
    catch (Exception ex)
    {
        string exception = $"An error occurred: {ex.Message}";
        Console.WriteLine(exception);
    }
}
```

--------------------------------

### Install Application into Workspace (.NET)

Source: https://platform.relativity.com/RelativityOne/Content/BD_Environment/Application_Install_service.htm

This C# code sample demonstrates how to install an application into a specified workspace using the Application Install service. It configures HttpClient with necessary headers and sends a POST request to the API.

```csharp
public async Task<InstallApplicationResponse> InstallApplicationIntoWorkspace(int applicationID, int workspaceID)  
{  
    InstallApplicationResponse response = null;  
    using (HttpClient client = new HttpClient())  
    {  
        client.DefaultRequestHeaders.Add("X-CSRF-Header", string.Empty);  
        client.DefaultRequestHeaders.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes("relativity.admin@kcura.com:Test1234!")));  
        client.DefaultRequestHeaders.Add("X-Kepler-Version", "2.0");  
        client.BaseAddress = new Uri("https://localhost/");  
   
        string inputJSON = $"{{ \"request\": {{ \"WorkspaceIDs\": [{workspaceID}], \"UnlockApplications\": true}} }}";  
   
        string url = $"/Relativity.REST/API/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationID}/install/";  
        System.Net.Http.HttpResponseMessage httpResponse = await client.PostAsync(url, new StringContent(inputJSON, Encoding.UTF8, "application/json"));  
        httpResponse.EnsureSuccessStatusCode();  
        string content = await httpResponse.Content.ReadAsStringAsync();  
        response = JsonConvert.DeserializeObject<InstallApplicationResponse>(content);  
    }  
   
    return response;  
}
```

--------------------------------

### Example Interaction Script for Relativity Lists

Source: https://platform.relativity.com/llms.txt

This is an example of an interaction script for Relativity Lists. It demonstrates how to subscribe to events and access service APIs for custom functionality.

```javascript
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Relativity.Lists.Interaction.Samples
{
    public class ExampleInteractionScript
    {
        // Example of an event handler for when the item list is populated.
        public void OnItemListPopulated(object sender, EventArgs e)
        {
            // Custom logic to execute when the item list is populated.
            Console.WriteLine("Item list has been populated.");
        }

        // Example of using a service API to register a custom widget.
        public void RegisterCustomWidget(IWidgetApi widgetApi)
        {
            widgetApi.Register("MyCustomWidget", new WidgetOptions
            {
                Title = "Custom Widget",
                Url = "/Custom/Widget/View"
            });
        }

        // Example of using a service API to create a custom modal.
        public void CreateCustomModal(IModalApi modalApi)
        {
            modalApi.Create("MyCustomModal", new ModalOptions
            {
                Title = "Custom Modal",
                ContentUrl = "/Custom/Modal/Content"
            });
        }
    }
}
```

--------------------------------

### Send a Trigger (.NET)

Source: https://platform.relativity.com/llms.txt

Example of how to send a trigger using the .NET SDK for Automated Workflows.

```.NET
using System;
using System.Threading.Tasks;
using Relativity.AutomatedWorkflows.SDK.Models;
using Relativity.AutomatedWorkflows.SDK.Services;

public class TriggerSender
{
    private readonly IAutomatedWorkflowsManager _automatedWorkflowsManager;

    public TriggerSender(IAutomatedWorkflowsManager automatedWorkflowsManager)
    {
        _automatedWorkflowsManager = automatedWorkflowsManager;
    }

    public async Task SendTriggerAsync(Guid workflowId, string triggerName, object triggerData = null)
    {
        var triggerEvent = new TriggerEvent
        {
            WorkflowId = workflowId,
            TriggerName = triggerName,
            TriggerData = triggerData
        };

        await _automatedWorkflowsManager.SendTriggerAsync(triggerEvent);
        Console.WriteLine($"Trigger '{triggerName}' sent successfully.");
    }
}
```

--------------------------------

### Create a .NET Client for REST Service

Source: https://platform.relativity.com/llms.txt

Example of creating a client in .NET to interact with the Automated Workflows REST Service.

```.NET
using Relativity.AutomatedWorkflows.Services.Client;

// Assuming you have the base URL for the REST service
var restServiceUrl = new Uri("https://your-relativity-instance.com/Relativity/api/AutomatedWorkflows/");

// Create a client instance
var client = new AutomatedWorkflowsClient(restServiceUrl);

// Now you can use the client to interact with the REST service
// For example: var triggers = await client.ListTriggersAsync();
```

--------------------------------

### Basic REST API Call to Relativity

Source: https://platform.relativity.com/llms.txt

A fundamental example of making a REST call to a RelativityOne instance to establish API communication. This is a starting point for integrating with Relativity's APIs.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class RelativityApiClient
{
    private readonly HttpClient _httpClient;

    public RelativityApiClient(string apiUrl, string apiKey)
    {
        _httpClient = new HttpClient { BaseAddress = new Uri(apiUrl) };
        _httpClient.DefaultRequestHeaders.Add("X-API-Key", apiKey);
    }

    public async Task<string> GetDataAsync(string endpoint)
    {
        HttpResponseMessage response = await _httpClient.GetAsync(endpoint);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

// Usage:
// var client = new RelativityApiClient("https://your-relativity-instance.com", "your-api-key");
// var data = await client.GetDataAsync("api/v1/some-resource");
```

--------------------------------

### Get Available Workspaces (by Application GUID)

Source: https://platform.relativity.com/RelativityOne/Content/OASFiles/Relativity.Environment.Services.Interfaces.Environment.V1.json

Retrieves a list of workspaces where the specified application, identified by its GUID, can be installed, with options for pagination and filtering.

```APIDOC
## POST /relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/available-workspaces

### Description
Retrieves a list of workspaces where the specified application, identified by its GUID, can be installed, with options for pagination and filtering.

### Method
POST

### Endpoint
/relativity-environment/v1/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install/available-workspaces

### Parameters
#### Path Parameters
- **workspaceID** (string) - Required - The unique identifier for the workspace.
- **applicationGuid** (string) - Required - The unique identifier for the application.
- **start** (integer) - Optional - The starting index for the results.
- **length** (integer) - Optional - The number of results to return.
- **includeActions** (boolean) - Optional - Whether to include actions in the response.

#### Request Body
- **QueryOptions** (object) - Required - Options for querying available workspaces.

### Response
#### Success Response (200)
- **ApplicationInstallSearchResponse** (object) - An object containing the list of available workspaces.
```

--------------------------------

### Example Script with Key

Source: https://platform.relativity.com/RelativityOne/Content/Scripts/Script_properties/key.htm

Demonstrates a complete script structure including the 'key' element to lock the script. This example shows how to define a script's name, description, category, key, input, display, and action.

```xml
<script>
     <name>Key Example</name>
     <description>This is an example script for using the key element</description>
     <category></category>
     <key>1234-key-456</key>
     <input orientation="horizontal" />
     <display type="itemlist" />
     <action returns="table"><![CDATA[]]></action>
</script>
```
Tokens:
Raw