Workspace Manager (.NET)

• CreateAsync() method - adds a new workspace to Relativity. This method takes a WorkspaceRequest object and returns a WorkspaceResponse object. See Create a workspace.
• DeleteAsync() method - removes a workspace from Relativity. This method takes the Artifact ID of a workspace. See Delete a workspace.
• GetDefaultDownloadHandlerURLAsync() method - retrieves the URL for the default download handler. This method returns a URL. See Retrieve the URL for the default download handler.
• GetEligibleAzureCredentialsAsync() method - retrieves a list of available Azure credentials for the workspace. This method takes the Artifact ID of a resource pool and returns a list of DisplayableObjectIdentifier objects, which identify available credentials. See Retrieve Azure credentials.
• GetEligibleAzureFileSystemCredentialsAsync() method - retrieves a list of available Azure file system credentials. This method takes the Artifact ID of a resource pool and returns a list of DisplayableObjectIdentifier objects, which identify available credentials. See Retrieve Azure file system credentials.
• GetEligibleCacheLocationsAsync() method - retrieves a list of available cache locations. This method takes the Artifact ID of a resource pool and returns a list of DisplayableObjectIdentifier objects, which identify available cache locations. See Retrieve cache location servers.
• GetEligibleFileRepositoriesAsync() method - retrieves a list of available file repository servers. This method takes the Artifact ID of a resource pool and returns a list of DisplayableObjectIdentifier objects, which identify available servers. See Retrieve file repository servers.
• GetEligibleResourcePoolsAsync() method - retrieves a list of resource pools. This method returns a list of DisplayableObjectIdentifier objects, which identify available resource pools. See Retrieve resource pools.
• GetEligibleSqlFullTextLanguagesAsync() method - retrieve available languages for a workspace. This method returns a list of SqlFullTextLanguageOptions objects, which describe the available and default languages. See Retrieve full text languages for SQL Server.
• GetEligibleSqlServersAsync() method - a list of SQL servers available for the workspace. This method takes the Artifact ID of a resource pool and returns a list of DisplayableObjectIdentifier objects, which identify available SQL servers. See Retrieve SQL Servers
• GetEligibleStatusesAsync() method - retrieves a list of available statuses for a workspace. This method returns a list of DisplayableObjectIdentifier objects, which contain the Artifact ID, Name, and GUIDs identifying each status. See Retrieve available statuses for a workspace.
• GetMetaAsync() method - retrieves a list of unsupported WorkspaceRequest fields for a create operation. See Retrieve unsupported fields for a create operation.
• GetWorkspaceSummaryAsync() method - retrieves a summary of workspace statistics. This method takes the Artifact ID of the workspace as an argument and returns a WorkspaceSummary object. See Retrieve workspace statistics.
• QueryEligibleClientsAsync() method - retrieves a list of clients available for this workspace. This method takes a QueryRequest object, a start index, and the number of clients to include in the results. It returns a QueryResultSlim object with a list of available clients. See Retrieve clients.
• QueryEligibleGroupsAsync() method - retrieves a list of groups available for workspace membership. This method takes a QueryRequest object, a start index, and the number of groups to include in the results. It returns a QueryResultSlim object with a list of available groups. See Retrieve groups for workspace membership .
• QueryEligibleMattersAsync() method - retrieves a list of matters. This method takes a QueryRequest object, a start index, and the number of matters to include in the results. It returns a QueryResultSlim object with a list of available matters. See Retrieve matters.
• QueryEligibleSavedSearchesAsync() method - saved searches for use with production restrictions. This method takes a QueryRequest object, a start index, and the number of saved searches to include in the results. It returns a QueryResultSlim object with a list of available saved searches. See Retrieve saved searches for production restrictions.
• QueryEligibleTemplatesAsync() method - a list of workspaces for use as templates when creating a new workspace. This method takes a QueryRequest object, a start index, and the number of templates to include in the results. It returns a QueryResultSlim object with a list of available templates. See Retrieve workspaces for use as templates.
• QueryWorkspaceByGroupAsync() method - retrieves workspaces associated with a group. This method takes a QueryRequest object, a start index, the number of groups to include in the results, and the Artifact ID of a group. It returns a QueryResultSlim object. See Retrieve workspaces associated with a group.
• ReadAsync() method - retrieves a workspace. This method takes the Artifact ID of a workspace and returns a WorkspaceResponse object. See Retrieve a workspace.
• RetryFailedCreateEventHandlersAsync() method - retries failed create event handlers for a workspace. This method takes the Artifact ID of the workspace as an argument. See Retry failed create event handlers.
• UpdateAsync() method - modifies the properties of a workspace. This method takes the Artifact ID of the workspace and a WorkspaceRequest object. It returns a WorkspaceResponse object. See Update a workspace.

using Relativity.Environment.V1.Workspace;
 
Uri keplerEndPoint = new Uri("http://localhost/relativity.rest/api");
Services.ServiceProxy.ServiceFactory serviceFactory = new Services.ServiceProxy.ServiceFactory(new Services.ServiceProxy.ServiceFactorySettings(keplerEndPoint,
       new Services.ServiceProxy.UsernamePasswordCredentials("username", "password")));
Relativity.Environment.V1.Workspace.IWorkspaceManager workspaceManager = serviceFactory.CreateProxy<Relativity.Environment.V1.Workspace.IWorkspaceManager>();

To use this endpoint, the caller must have the following:

• Add permissions for the workspace set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task CreateWorkspaceAsync(string name, int matterID, int templateID, int statusID, int resourcePoolID, int sqlServerID, int defaultFileRepositoryID, int defaultCacheLocationId)
{
    try
    {
        string downloadHandlerUrl = await _workspaceManager.GetDefaultDownloadHandlerURLAsync();
        WorkspaceRequest request = new WorkspaceRequest()
        {
            Name = name,
            Matter = new Securable<ObjectIdentifier>(new ObjectIdentifier() {ArtifactID = matterID}),
            Template = new Securable<ObjectIdentifier>(new ObjectIdentifier() {ArtifactID = templateID}),
            Status = new ObjectIdentifier() {ArtifactID = statusID},
            ResourcePool =
                new Securable<ObjectIdentifier>(new ObjectIdentifier() {ArtifactID = resourcePoolID}),
            SqlServer = new Securable<ObjectIdentifier>(new ObjectIdentifier() {ArtifactID = sqlServerID}),
            DefaultFileRepository = new Securable<ObjectIdentifier>(new ObjectIdentifier()
                {ArtifactID = defaultFileRepositoryID}),
            DefaultCacheLocation = new Securable<ObjectIdentifier>(new ObjectIdentifier()
                {ArtifactID = defaultCacheLocationId}),
            DownloadHandlerUrl = downloadHandlerUrl
        };
 
        WorkspaceResponse response = await _workspaceManager.CreateAsync(request);
        Console.WriteLine($"Created workspace with artifact ID {response.ArtifactID} on {response.CreatedOn}");
    }
    catch (InvalidInputException ex)
    {
        Console.WriteLine("The following validation errors were found:");
        foreach (ValidationError error in ex.Errors)
        {
            Console.WriteLine($"\t{error.PropertyName}: {error.ErrorMessage}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to create workspace: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• Add permissions for the workspace set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetMetaAsync()
{
    try
    {
        Meta meta = await _workspaceManager.GetMetaAsync();
 
        if (meta.ReadOnly.Any())
        {
            Console.WriteLine($"The following fields are read-only: {string.Join(", ", meta.ReadOnly)}");
        }
        else
        {
            Console.WriteLine("No fields are read-only.");
        }
 
        if (meta.Unsupported.Any())
        {
            Console.WriteLine($"The following fields are unsupported: {string.Join(", ", meta.Unsupported)}");
        }
        else
        {
            Console.WriteLine("No fields are unsupported.");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to get meta: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for workspaces set at the workspace level. See Workspace security on the RelativityOne Documentation site.

public async Task RetryFailedCreateEventHandlersAsync(int workspaceID)
{
    try
    {
        await _workspaceManager.RetryFailedCreateEventHandlersAsync(workspaceID);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to retry failed create event handlers: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View Workspace Details permissions for the workspace set at the workspace level. See Workspace security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin. See Instance security on the RelativityOne Documentation site.

Note: This permission is required for the admin-level context workspace. Use -1 to indicate the admin-level context.

public async Task ReadWorkspaceAsync(int workspaceID, bool includeMetadata, bool includeActions)
{
    try
    {
        WorkspaceResponse response = await _workspaceManager.ReadAsync(workspaceID, includeMetadata, includeActions);
        Console.WriteLine($"Workspace {workspaceID} has the name {response.Name}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to read workspace {workspaceID}: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• Edit permissions for the workspace set at the workspace level. See Workspace security on the RelativityOne Documentation site.
• View Workspace Details permissions for the workspace set at the workspace level.

Note: To update the WorkspaceAdminGroup or Matter properties, the calling user must be a system admin or client domain admin. The admin workspace can't be updated. It resides in the admin level context indicated by -1.

public async Task UpdateWorkspaceAsync(int workspaceID)
{
    try
    {
        WorkspaceResponse originalWorkspace = await _workspaceManager.ReadAsync(workspaceID, true, true);
         
        WorkspaceRequest request = new WorkspaceRequest()
        {
            Name = "Updated Workspace",
            Matter = new Securable<ObjectIdentifier>() { Value = originalWorkspace.Matter.Value },
            Status = originalWorkspace.Status,
            ResourcePool = new Securable<ObjectIdentifier>() { Value = originalWorkspace.ResourcePool.Value },
            SqlServer = new Securable<ObjectIdentifier>() { Value = originalWorkspace.SqlServer.Value },
            DefaultFileRepository = new Securable<ObjectIdentifier>() { Value = originalWorkspace.DefaultFileRepository.Value },
            DefaultCacheLocation = new Securable<ObjectIdentifier>() { Value = originalWorkspace.DefaultCacheLocation.Value },
            DownloadHandlerUrl = originalWorkspace.DownloadHandlerUrl
        };
 
        WorkspaceResponse response = await _workspaceManager.UpdateAsync(workspaceID, request);
        Console.WriteLine($"Updated workspace with artifact ID {workspaceID} on {response.LastModifiedOn}");
    }
    catch (InvalidInputException ex)
    {
        Console.WriteLine("The following validation errors were found:");
        foreach (ValidationError error in ex.Errors)
        {
            Console.WriteLine($"\t{error.PropertyName}: {error.ErrorMessage}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to update workspace: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View and Delete permissions for the workspace set at the workspace level. See Workspace security on the RelativityOne Documentation site.

public async Task DeleteWorkspaceAsync(int workspaceId)
{
    try
    {
        await _workspaceManager.DeleteAsync(workspaceId);
    }
    catch (InvalidInputException ex)
    {
        Console.WriteLine("The following validation errors were found:");
        foreach (ValidationError error in ex.Errors)
        {
            Console.WriteLine($"\t{error.PropertyName}: {error.ErrorMessage}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to update workspace: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for workspaces set at the workspace level. See Workspace security on the RelativityOne Documentation site.

public async Task GetWorkspaceSummaryAsync(int workspaceID)
{
    try
    {
        WorkspaceSummary workspaceSummary = await _workspaceManager.GetWorkspaceSummaryAsync(workspaceID);
        Console.WriteLine($"Document Count: {workspaceSummary.DocumentCount}");
        Console.WriteLine($"File Size: {workspaceSummary.FileSize}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to get workspace summary: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for the group set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task QueryWorkspaceByGroupAsync(int groupID)
{
    try
    {
        QueryRequest workspacesRequest = new QueryRequest();
        QueryResultSlim workspacesResponse = await _workspaceManager.QueryWorkspaceByGroupAsync(workspacesRequest, 1, _QUERY_LENGTH, groupID);
 
        foreach (int workspaceID in workspacesResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine($"Workspace {workspaceID} is part of group {groupID}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query workspaces: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for matters set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task QueryEligibleMattersAsync()
{
    try
    {
        QueryRequest mattersRequest = new QueryRequest();
        QueryResultSlim mattersResponse = await _workspaceManager.QueryEligibleMattersAsync(mattersRequest, 1, _QUERY_LENGTH);
 
        Console.WriteLine("Eligible Matters:");
        foreach (int matterID in mattersResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine(matterID);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible matters: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for clients set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task QueryEligibleClientsAsync()
{
    try
    {
        QueryRequest clientsRequest = new QueryRequest();
        QueryResultSlim clientsResponse = await _workspaceManager.QueryEligibleClientsAsync(clientsRequest, 1, _QUERY_LENGTH);
 
        Console.WriteLine("Eligible Clients:");
        foreach (int clientID in clientsResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine(clientID);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible clients: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for workspaces set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task QueryEligibleTemplatesAsync()
{
    try
    {
        QueryRequest templatesRequest = new QueryRequest();
        QueryResultSlim templatesResponse = await _workspaceManager.QueryEligibleTemplatesAsync(templatesRequest, 1, _QUERY_LENGTH);
 
        Console.WriteLine("Eligible Templates:");
        foreach (int templateID in templatesResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine(templateID);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible templates: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task GetEligibleResourcePoolsAsync()
{
    try
    {
        List<DisplayableObjectIdentifier> resourcePools = await _workspaceManager.GetEligibleResourcePoolsAsync();
        Console.WriteLine("Eligible Resource Pools:");
        foreach (DisplayableObjectIdentifier resourcePool in resourcePools)
        {
            Console.WriteLine($"\t{resourcePool.Name} ({resourcePool.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible resource pools: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetEligibleSqlServersAsync(int resourcePoolID)
{
    try
    {
        List<DisplayableObjectIdentifier> sqlServers = await _workspaceManager.GetEligibleSqlServersAsync(resourcePoolID);
        Console.WriteLine("Eligible SQL Servers:");
        foreach (DisplayableObjectIdentifier sqlServer in sqlServers)
        {
            Console.WriteLine($"\t{sqlServer.Name} ({sqlServer.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible SQL servers: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetEligibleFileRepositoriesAsync(int resourcePoolID)
{
    try
    {
        List<DisplayableObjectIdentifier> fileRepositories = await _workspaceManager.GetEligibleFileRepositoriesAsync(resourcePoolID);
        Console.WriteLine("Eligible File Repositories:");
        foreach (DisplayableObjectIdentifier fileRepository in fileRepositories)
        {
            Console.WriteLine($"\t{fileRepository.Name} ({fileRepository.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible file repositories: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetEligibleCacheLocationsAsync(int resourcePoolID)
{
    try
    {
        List<DisplayableObjectIdentifier> cacheLocations = await _workspaceManager.GetEligibleCacheLocationsAsync(resourcePoolID);
        Console.WriteLine("Eligible Cache Locations:");
        foreach (DisplayableObjectIdentifier cacheLocation in cacheLocations)
        {
            Console.WriteLine($"\t{cacheLocation.Name} ({cacheLocation.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible cache locations: {ex.Message}");
        throw;
    }
}

public async Task GetDefaultDownloadHandlerURLAsync()
{
    try
    {
        string downloadHandlerUrl = await _workspaceManager.GetDefaultDownloadHandlerURLAsync();
        Console.WriteLine($"The default download handler URL is {downloadHandlerUrl}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to get download handler URL: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for the resource server set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task GetEligibleStatusesAsync()
{
    try
    {
        List<DisplayableObjectIdentifier> statuses = await _workspaceManager.GetEligibleStatusesAsync();
 
        Console.WriteLine("Eligible Statuses:");
        foreach (DisplayableObjectIdentifier status in statuses)
        {
            Console.WriteLine($"{status.Name} ({status.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to get eligible statuses: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for the resource server set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task GetEligibleSqlFullTextLanguagesAsync()
{
    try
    {
        SqlFullTextLanguageOptions sqlFullTextLanguageOptions = await _workspaceManager.GetEligibleSqlFullTextLanguagesAsync();
 
        Console.WriteLine("Eligible SQL Full Text Languages:");
        foreach (NameIDPair language in sqlFullTextLanguageOptions.Languages)
        {
            Console.WriteLine($"{language.Name} ({language.ID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to get eligible SQL full text languages: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.
• View Admin Repository permissions set for Admin Operations at the instance level. Alternatively, the user must be a system admin.

public async Task QueryEligibleGroupsAsync()
{
    try
    {
        QueryRequest groupsRequest = new QueryRequest();
        QueryResultSlim groupsResponse = await _workspaceManager.QueryEligibleGroupsAsync(groupsRequest, 1, _QUERY_LENGTH);
 
        Console.WriteLine("Eligible Groups:");
        foreach (int groupID in groupsResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine(groupID);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible groups: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for workspaces set at the workspace level. See Workspace security on the RelativityOne Documentation site.

public async Task QueryEligibleSavedSearchesAsync(int workspaceID)
{
    try
    {
        QueryRequest savedSearchRequest = new QueryRequest();
        QueryResultSlim savedSearchResponse = await _workspaceManager.QueryEligibleSavedSearchesAsync(savedSearchRequest, 1, _QUERY_LENGTH, workspaceID);
 
        Console.WriteLine("Eligible Saved Searches:");
        foreach (int savedSearchID in savedSearchResponse.Objects.Select(x => x.ArtifactID))
        {
            Console.WriteLine(savedSearchID);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible saved searches: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetEligibleAzureCredentialsAsync(int resourcePoolID)
{
    try
    {
        List<DisplayableObjectIdentifier> azureCredentials = await _workspaceManager.GetEligibleAzureCredentialsAsync(resourcePoolID);
        Console.WriteLine("Eligible Azure Credentials:");
        foreach (DisplayableObjectIdentifier azureCredential in azureCredentials)
        {
            Console.WriteLine($"\t{azureCredential.Name} ({azureCredential.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible Azure credentials: {ex.Message}");
        throw;
    }
}

To use this endpoint, the caller must have the following:

• View permissions for resource pools set at the instance level. See Instance security on the RelativityOne Documentation site.

public async Task GetEligibleAzureFileSystemCredentialsAsync(int resourcePoolID)
{
    try
    {
        List<DisplayableObjectIdentifier> azureFileSystemCredentials = await _workspaceManager.GetEligibleAzureFileSystemCredentialsAsync(resourcePoolID);
        Console.WriteLine("Eligible Azure File System Credentials:");
        foreach (DisplayableObjectIdentifier azureFileSystemCredential in azureFileSystemCredentials)
        {
            Console.WriteLine($"\t{azureFileSystemCredential.Name} ({azureFileSystemCredential.ArtifactID})");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to query eligible Azure file system credentials: {ex.Message}");
        throw;
    }
}