### Required Relativity Applications for Import Service API

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/Import_API/Relativity_Import_Service_API/Getting_Started/Getting_started

Lists the essential Relativity applications that must be installed before using the Import Service API, including their names, GUIDs, and installation scope (workspace or instance).

```APIDOC
Application name | Application Guid | Installed
--- | --- | ---
Import | 21F65FDC-3016-4F2B-9698-DE151A6186A2 | workspace
DataTransfer.Legacy | 9f9d45ff-5dcd-462d-996d-b9033ea8cfce | instance
```

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

### Install Application to All Workspaces by GUID with Actions

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

This C# example shows how to install or upgrade a Relativity application across all workspaces using its GUID, with an option to include associated actions during the process. It utilizes the InstallApplicationAllAsync method, configured for force installation and optional unlocking, and includes logging for installation queuing and robust exception handling.

```C#
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);
    }
}
```

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

### Install Application to All Workspaces by GUID

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

This C# example demonstrates how to install or upgrade a Relativity application across all workspaces by specifying its unique GUID. It leverages the InstallApplicationAllAsync method, configured for force installation and optional unlocking, and includes logging for installation queuing and exception handling.

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

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

        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);
    }
}
```

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

### Relativity Processing API: Development Prerequisites

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/BD_Processing/v0/Get_started_with_the_Processing_API

Outlines the necessary steps and resources required to begin development with the Relativity Processing API, including SDK downloads, Relativity environment setup, and obtaining required Artifact IDs from the workspace database.

```APIDOC
Processing API Prerequisites:
  1. SDK Downloads:
    - Relativity SDK
    - Processing SDK
    - Installation/Extraction: Install or extract contents to folders on your local machine.
  2. Relativity Environment Setup:
    - Obtain access to an instance of Relativity RelativityOne used for development purposes.
    - The Processing application must be installed on this Relativity instance.
    - Enable Developer mode in your development instance of Relativity.
    - In the Relativity UI, ensure that the "Auto-publish set" field is set to "Yes" on the processing profile.
  3. Required Artifact IDs:
    - Obtain from workspace database using Microsoft SQL Server Management Studio.
    - Steps to obtain:
      1. Log in to Relativity.
      2. On the Workspace tab, locate the workspace and note the "Case Artifact ID".
      3. On your database server, open Microsoft SQL Server Management Studio.
      4. In Object Explorer, expand Databases.
      5. Use the Case Artifact ID with prefix EDDS (e.g., EDDS1014823) to find the workspace database.
      6. Expand your workspace to display tables and reference for Artifact IDs:
        - EDDSDBO.Folder: For destination folder.
        - EDDSDBO.ProcessingProfile: For processing profile.
        - EDDSDBO.RelativityTimeZone: For time zone.
        - Note: Processing application must be installed to view time zones and processing profiles tables.
```

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

### JSON Response Body for Application Installation Search

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

Example JSON response containing a list of application installation details. Each entry includes application, workspace, client, and matter identifiers, install status, version, and timestamps.

```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",
                "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": "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",
                "GetDetailsAction": {
                    "Name": "GetInstallDetails-DefaultPage",
                    "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/53801/details/1/10",
                    "Verb": "GET",
                    "IsAvailable": true,
                    "Reason": []
                }
            }
        }
    ]
}
```

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

### API Endpoint: Search Application Installations

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

POST endpoint to search for application installations by application ID or GUID, with optional query parameters for pagination (start, length) and including actions (includeActions).

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

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

### JSON Response Body for Application Installation Query

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

Example JSON response containing a list of application installation results. Each result includes details such as ApplicationInstallID, ApplicationIdentifier (Name, ArtifactID, Guids), WorkspaceIdentifier, ClientIdentifier, MatterIdentifier, RootFolderID, InstallStatus, SchemaVersion, IsOutOfDate, InstalledBy, StartedOn, and CompletedOn.

```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",
```

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

### Example JSON Response for Application Installation Status

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

This JSON snippet illustrates a typical response structure when querying for application installation details within Relativity. It includes information about individual application installations, a summary of installation statuses, and pagination links for navigating results, providing a comprehensive view of application library installations.

```JSON
{
  "Items": [
    {
      "ArtifactID": 1020470,
      "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:07:06.577",
      "CompletedOn": "2019-12-02T17:07:39.873"
    }
  ],
  "Summary": {
    "Other": 0,
    "Pending": 0,
    "InProgress": 0,
    "Failed": 0,
    "Completed": 36,
    "Canceled": 0,
    "TotalActiveInstalls": 0,
    "Total": 36
  },
  "CurrentStartIndex": 1,
  "
```

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

### GET Request URLs for Application Installation Status API

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

These URLs are used to retrieve the installation status of an application. They support specifying the application by either its ArtifactID or Guid, and can optionally include actions.

```REST
[://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{artifactID}/install/{applicationInstallID}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{artifactID}/install/{applicationInstallID}/{IncludeActions}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{applicationInstallID}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{applicationInstallID}/{IncludeActions}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/{workspaceID}/libraryapplications/{artifactID}/install?{IncludeActions}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/{workspaceID}/libraryapplications/{applicationGuid}/install?{IncludeActions}
```

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

### Relativity REST API: Get Application Installation Details Endpoints

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

Use these Relativity REST API endpoints to retrieve installation details for an application. The GetApplicationInstallDetailsAsync() method supports four variations: by Artifact ID or GUID, and with or without including actions. Send a GET request with an empty body to one of these URLs.

```APIDOC
[://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{artifactID}/install/{applicationInstallID}/details/{start}/{length}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/{start}/{length}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{artifactID}/install/{applicationInstallID}/details/{start}/{length}/{includeActions}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/{start}/{length}/{includeActions}
```

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

### API Endpoint URLs for Application Installation Query

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

Two implementations of the POST endpoint to query available workspaces for application installations. These endpoints support optional query parameters for pagination (start, length) and to include action-related properties (includeActions). The application can be identified by either its ID or GUID.

```APIDOC
[://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationID:int}/install/available-workspaces?start={start}&length={length}&includeActions={includeActions}
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid:guid}/install/available-workspaces?start={start}&length={length}&includeActions={includeActions}
```

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

### JSON Sample: Application Install Status (without actions)

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

A sample JSON response demonstrating the structure and data returned when retrieving application installation status without requesting additional actions. This example shows a 'Completed' status and details for a successful installation.

```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"
}
```

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

### Example Relativity Application Installation Status Array

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

This JSON array illustrates the typical response structure for a batch of application installation statuses. Each object in the array represents the status of an application installation in a specific workspace. The `InstallStatus` object provides the outcome and a human-readable message, while `GetDetailsAction` offers a link to retrieve more granular installation details.

```JSON
[
  {
    "Message": "Skipped the application installation because the same version of this product is already installed into the target workspace.",
    "GetDetailsAction": {
      "Name": "GetInstallDetailsFirst",
      "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/19980/details/1/10",
      "Verb": "GET",
      "IsAvailable": true,
      "Reason": []
    }
  },
  {
    "WorkspaceIdentifier": {
      "ArtifactID": 1015024,
      "Guids": [
        "01bec74e-b382-40f0-8ec5-0060fdb0ded3"
      ]
    },
    "ApplicationInstallID": 19996,
    "Messages": [],
    "InstallStatus": {
      "Code": "Completed",
      "Message": "Skipped the application installation because the same version of this product is already installed into the target workspace.",
      "GetDetailsAction": {
        "Name": "GetInstallDetailsFirst",
        "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/19996/details/1/10",
        "Verb": "GET",
        "IsAvailable": true,
        "Reason": []
      }
    }
  }
]
```

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

### Example JSON Response Fragment for Application Installation Status

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

This JSON snippet illustrates a fragment of a typical response from the Relativity API, detailing the status and metadata of application installations within a workspace. It includes information such as application identifiers, installation timestamps, and pagination links for navigating through multiple results. Note: This is a partial JSON structure.

```JSON
            "Version": "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": 1020470,
                "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/53869/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:07:06.577",
            "CompletedOn": "2019-12-02T17:07:39.873"
        }
    ],
    "Summary": {
        "Other": 0,
        "Pending": 0,
        "InProgress": 0,
        "Failed": 0,
        "Completed": 36,
        "Canceled": 0,
        "TotalActiveInstalls": 0,
        "Total": 36
    },
    "CurrentStartIndex": 1,
    "ResultCount": 3,
    "TotalCount": 36,
    "FirstPage": {
        "Name": "SearchStatus-FirstPage",
        "Verb": "POST",
        "IsAvailable": false,
        "Reason": []
    },
    "PreviousPage": {
        "Name": "SearchStatus-PreviousPage",
        "Verb": "POST",
        "IsAvailable": false,
        "Reason": []
    },
    "NextPage": {
        "Name": "SearchStatus-NextPage",
        "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/search?start=4&length=3&includeActions=true",
        "Verb": "POST",
        "IsAvailable": true,
        "Reason": []
    },
    "LastPage": {
        "Name": "SearchStatus-LastPage",
        "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1015285/install/search?start=34&length=3&includeActions=true",
        "Verb": "POST",
        "IsAvailable": true,
        "Reason": []
    }
}
```

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

### Example Relativity Static File Hosting Endpoint

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/ReviewAPI/Building_An_Extension

Provides a concrete example of a static file URL in Relativity, showing how a file named `review.sample.json` would be accessible given a specific application GUID and version. This demonstrates the resolved path for a hosted resource.

```Plaintext
https://<host>/Relativity/RelativityApplicationWebResourceFile/cd441ba7-7d47-4626-aaf2-ebbbb2843271/1.2.3.4/review.sample.json
```

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

### Example JSON Response for Relativity Library Application Status

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

This JSON snippet illustrates the typical structure of a paginated API response from the Relativity Platform, showing details for installed library applications. It includes application metadata, installation status, and navigation links for result sets.

```JSON
{
  "Applications": [
    {
      "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",
        "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:02:17.017",
      "CompletedOn": "2019-12-02T17:03:00.283"
    }
  ],
  "Summary": {
    "Other": 0,
    "Pending": 0,
    "InProgress": 0,
    "Failed": 0,
    "Completed": 37,
    "Canceled": 0,
    "TotalActiveInstalls": 0,
    "Total": 37
  },
  "CurrentStartIndex": 1,

```

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

### Retrieve Application Install Status by GUID in C#

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

This C# asynchronous method retrieves the installation status of a RelativityOne application within a specific workspace using its unique GUID. It utilizes the IApplicationInstallManager to get the status and prints the result to the console, including status code and version. Error handling is included to catch and report exceptions during the process.

```C#
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);
	}
}
```

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

### JSON Request Body for Application Installation Query

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

Example JSON payload for the POST request to query application installations. It specifies 'queryOptions' including a 'Condition' to filter results (e.g., by 'Case Artifact ID' and 'Is Installed') and 'Sorts' to define the order of results (e.g., by 'Workspace' in ascending direction).

```JSON
{
    "queryOptions": {
        "Condition": "(NOT ('Case Artifact ID' == -1)) AND ('Is Installed' == 0)",
        "Sorts": [
            {
                "FieldName": "Workspace",
                "Direction": "Ascending"
            }
        ]
    }
}
```

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

### Get Install Status with Application GUID

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

This C# method retrieves the installation status of an application using its unique Application GUID and a specific applicationInstallID. It polls the status until a terminal state is reached (completed or failed) and prints the status and version to the console, handling potential exceptions.

```C#
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);
	}
}
```

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

### JSON Sample: Application Install Status (with actions)

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

A sample JSON response illustrating the structure and data returned when retrieving application installation status with the 'includeActions' flag. This example includes the 'GetDetailsAction' within the 'InstallStatus' object, providing a link to further details.

```JSON
{
    "ApplicationInstallID": 19964,
    "ApplicationIdentifier": {
        "ArtifactID": 1015285,
        "Guids": []
    },
    "WorkspaceIdentifier": {
        "ArtifactID": -1,
        "Guids": []
    },
    "InstallStatus": {
        "Code": "Completed",
        "GetDetailsAction": {
            "Name": "GetInstallDetailsFirst",
            "Href": "relativity-environment/v1/workspace/-1/libraryapplications/1015285/install/19964/details/1/10",
            "Verb": "GET",
            "IsAvailable": true,
            "Reason": []
        }
    },
    "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": "Service Account, Relativity",
        "ArtifactID": 777,
        "Guids": []
    },
    "StartedOn": "2019-07-16T19:23:00.217",
    "CompletedOn": "2019-07-16T19:23:21.373"
}
```

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

### JSON Request Body for Application Installation Search

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

Example JSON payload for the POST request to search application installations. It includes query options to filter by workspace and sort results by field name and direction.

```JSON
{
    "queryOptions": {
        "Condition": "(NOT 'Workspace' LIKE ['Admin']) AND ('Status Code' == 4)",
        "Sorts": [
            {
                "FieldName": "Workspace",
                "Direction": "Ascending"
            }
        ]
    }
}
```

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

### Application Install API Overview

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/What_s_new/What_s_new

The Application Install API allows clients to install applications into one or more workspaces, cancel pending installations, as well as get the status of any specified application installations. Additionally, this API allows support for conflict resolution for any failed application installations.

```APIDOC
API Name: Application Install API
Purpose: Manage application installations in Relativity workspaces, including installation, cancellation, status retrieval, and conflict resolution.
```

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

### Get Library Install Status by Application GUID with Actions in C#

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

This C# code snippet illustrates how to asynchronously obtain the installation status of a library application using its Application GUID, with an option to include associated actions. It calls the ILibraryApplicationManager interface's GetLibraryInstallStatusAsync method, outputs the status and version, and includes robust error handling.

```C#
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);
	}
}
```

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

### Retrieve Application Install Status by GUID with Actions in C#

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

This C# asynchronous method retrieves the installation status of a RelativityOne application within a specific workspace using its GUID. It allows including related actions in the response. The method uses IApplicationInstallManager and prints the status and version to the console, with robust error handling for any issues encountered during the retrieval.

```C#
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);
	}
}
```

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

### Relativity REST API: Generate Application Installation Report Endpoints

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

These Relativity REST API endpoints are used to generate an installation report for an application. Two variations are available, allowing report generation by Artifact ID or GUID. Send a GET request; the response will be an IKeplerStream object, typically leading to a file download.

```APIDOC
[://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{artifactID}/install/{applicationInstallID}/details/csv
https://{host}/relativity.rest/api/Relativity.LibraryApplications/workspace/-1/libraryapplications/{applicationGuid}/install/{applicationInstallID}/details/csv
```

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

### Get Install Status with Application GUID and Actions

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

This C# method retrieves the installation status of an application using its unique Application GUID, a specific applicationInstallID, and an `includeActions` boolean. It polls the status until a terminal state is reached (completed or failed) and prints the status and version to the console, handling potential exceptions. The `includeActions` parameter allows for including additional action details.

```C#
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 by GUID

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

This C# code illustrates how to install an application from the library into multiple specified workspaces using its unique GUID. Similar to the ArtifactID method, it prepares an InstallApplicationRequest with workspace IDs and an unlock flag, then invokes the InstallApplicationAsync method asynchronously. The snippet also provides feedback on the queuing status and includes error handling for exceptions.

```C#
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);
    }
}
```

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

### JSON Sample Response for Failed Application Installation

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

This JSON snippet illustrates the structure of a response when a RelativityOne application installation fails. It includes details about the application, workspace, client, matter, and the installation status. Crucially, it provides a 'ValidationResult' section that lists 'InstallConflicts' with their descriptions, types (e.g., 'Name', 'LockedApplication'), and 'ResolutionOptions'. It also includes a 'RetryInstallAction' and 'RetryInstallRequestTemplate' to guide the user on how to resolve the conflicts and retry the installation.

```JSON
{
    "ApplicationInstallID": 19924,
    "ApplicationIdentifier": {
        "ArtifactID": 1022443,
        "Guids": []
    },
    "WorkspaceIdentifier": {
        "ArtifactID": 1022442,
        "Guids": [
            "46e1cb06-286f-4e75-be49-5098c33a67bb"
        ]
    },
    "WorkspaceName": "Example Workspace",
    "Client": {
        "Name": "Example Client",
        "ArtifactID": 97,
        "Guids": []
    },
    "Matter": {
        "Name": "Example Matter",
        "ArtifactID": 107,
        "Guids": []
    },
    "InstallStatus": {
        "Code": "Failed",
        "Message": ""
    },
    "ValidationResult": {
        "RetryInstallAction": {
            "Name": "RetryApplicationInstall",
            "Href": "Relativity.LibraryApplications/workspace/-1/libraryapplications/1022443/install",
            "Verb": "POST",
            "IsAvailable": true,
            "Reason": []
        },
        "RetryInstallRequestTemplate": {
            "WorkspaceIDs": [
                1018078
            ],
            "UnlockApplications": false,
            "ConflictResolutions": []
        },
        "InstallConflicts": [
            {
                "ConflictArtifactIdentifier": {
                    "Name": "ConflictingField",
                    "ArtifactID": 1038419,
                    "Guids": []
                },
                "Description": "A field with the name ConflictingField already exists in the target workspace. Unable to import this field.",
                "ApplicationComponentType": "Field",
                "ConflictType": "Name",
                "ResolutionOptions": [
                    {
                        "WorkspaceID": 1018078,
                        "ConflictArtifactID": 1038419,
                        "ApplicationComponentType": "Field",
                        "ResolutionType": "Rename",
                        "FieldIdentifiers": [],
                        "Value": ""
                    },
                    {
                        "WorkspaceID": 1018078,
                        "ConflictArtifactID": 1038419,
                        "ApplicationComponentType": "Field",
                        "ResolutionType": "MapField",
                        "FieldIdentifiers": [
                            "6d7a5661-b193-44b1-a2d5-a880792407df"
                        ]
                    }
                ]
            },
            {
                "ConflictArtifactIdentifier": {
                    "Name": "ConflictingField",
                    "ArtifactID": 1038419,
                    "Guids": []
                },
                "Description": "The ConflictingField field in the target workspace is used by the locked Relativity Application Field_Name_Conflict_X. You can't rename this field unless you unlock the Field_Name_Conflict_X application.",
                "ApplicationComponentType": "Field",
                "ConflictType": "LockedApplication",
                "ConflictApplicationIdentifier": {
                    "Name": "Field_Name_Conflict_X",
                    "ArtifactID": 1038426,
                    "Guids": []
                },
                "ResolutionOptions": [
                    {
                        "WorkspaceID": 1018078,
                        "ConflictArtifactID": 1038419,
                        "ApplicationComponentType": "Field",
                        "ResolutionType": "UnlockAssociatedApplications",
                        "ConflictApplicationID": 1038426,
                        "FieldIdentifiers": []
                    }
                ]
            }
        ]
    },
    "Version": "0.0.0.1",
    "IsOutOfDate": false,
    "ValidationMessages": [],
    "InstalledBy": {
        "Name": "Admin, Relativity",
        "ArtifactID": 9,
        "Guids": []
    },
    "Errors": [
        {
            "CreatedOn": "2019-12-16T15:17:10.457",
            "ArtifactTypeName": "Field",
            "Message": "The Object Type Other Conflict File Fields already has a file field, File Field 1. Object Types can only have one file field. Unable to import this field.",
            "Name": "File Field 2",
            "ArtifactID": 1038821,
            "Guids": []
        }
    ],
    "StartedOn": "2019-07-11T19:32:11.263"
}
```

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

### Relativity REST API Endpoints for Application Installation

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

These URLs are used to send POST requests to install an application library to one or more Relativity workspaces. The endpoint supports specifying the application by ArtifactID or GUID, and optionally includes actions.

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

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

### Install Application to All Workspaces by ArtifactID with Actions

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

This C# example illustrates how to install or upgrade a Relativity application across all workspaces using its ArtifactID, with an additional parameter to include associated actions. It calls the InstallApplicationAllAsync method, setting the installation mode to force and allowing applications to be unlocked, and incorporates error handling and progress reporting.

```C#
public async Task InstallApplicationAll(IApplicationInstallManager applicationInstallManager, int artifactID, bool unlockApps, bool includeActions)
{
    try
    {
        InstallApplicationAllRequest request = new InstallApplicationAllRequest
        {
            Mode = ApplicationInstallTargetOption.ForceInstall,
            UnlockApplications = unlockApps
        };

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

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

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

### Relativity.Import.Models.SDK .NET Library Details

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/Import_API/Relativity_Import_Service_API/Getting_Started/Getting_started

Details the Relativity.Import.Models.SDK, a .NET library containing contract models for API and builders. It assists users in preparing payloads consistently, targets .NET Standard 2.0 and .NET Framework 4.6.2, and can be installed directly if Kepler is not used.

```APIDOC
Relativity.Import.Models.SDK:
  - NuGet Package: https://www.nuget.org/packages/Relativity.Import.Models.SDK
  - Description: Contains contract models for API and builders which helps users prepare payloads in correct and consistent way.
  - Targets: .NET Standard 2.0, .NET Framework 4.6.2
  - Usage: Added automatically as dependency to Relativity.Import.SDK. Can be installed directly if your application does not use Kepler.
```

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

### Run Discovery Job with Processing Job Manager (C#)

Source: https://platform.relativity.com/RelativityOne/Content/Relativity_Platform/index.htm/RelativityOne/Content/BD_Processing/v0/Get_started_with_the_Processing_API

This code illustrates how to submit a discovery job by calling the SubmitDiscoveryJobsAsync() method on the IProcessingJobManager proxy. It requires a DiscoveryJob instance containing the processing set and workspace Artifact IDs. The example includes error handling for ServiceException.

```C#
public async Task<bool> ProcessingJobManager_DiscoveryAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user. For more information, see the documentation for Relativity API Helpers.
   using (IProcessingJobManager proxy = helper.GetServicesManager().CreateProxy<IProcessingJobManager>(ExecutionIdentity.User))
   {
      try
      {
         //Create a discovery job object.
         DiscoveryJob discoveryJob = new DiscoveryJob
         {
            ProcessingSetId = processingSetArtifactId,
            WorkspaceArtifactId = WorkspaceId
         };

         //Submit the job for discovery.
         await proxy.SubmitDiscoveryJobsAsync(discoveryJob);

         success = true;
      }
      catch (ServiceException exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingJobManager_DiscoveryAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.