Tab Manager (.NET)

The Tab Manager API includes the following methods available on the ITabManager interface in the Relativity.Services.Interfaces.DataVisualization.<VersionNumber>.Tab namespace.

Note: The <VersionNumber> variable in the namespace indicates the version number of the API. The version number uses the format uppercase V and an integer version number, such as V1 in .NET.

• CreateAsync() method - adds a new tab to Relativity. This method takes the Artifact ID of a workspace and a TabRequest object as arguments. It returns a TabResponse object representing the new Tab. See Create a tab.
• DeleteAsync() method - removes a tab from Relativity. This method takes the Artifact IDs of a workspace and a tab as arguments. See Delete a tab.
• GetAllNavigationTabs() method - retrieves a list of all tabs in a specified workspace that the calling user can navigate to. It returns a list of NavigationTabResponse objects. See Retrieve all tabs for navigation.
• GetEligibleObjectTypesAsync() method - retrieves a list of object types that can be associated with a tab when you are creating it. It takes the Artifact ID of a workspace. The method returns a list of all available object types. See Retrieve object types for a tab.
• GetEligibleParentTabsAsync() method - retrieves a list of all available parent tabs in a workspace, which you can associate with a new tab. See Retrieve eligible parent tabs.
• GetMetaAsync() method - retrieves workspace-level metadata about admin and system tabs. This method takes a workspace ID of -1 to indicate the admin-level context for system and admin tabs. See Retrieve workspace-level metadata for admin and system tabs.
• GetViewOrderListAsync() method - retrieves a list of all tabs and the order assigned to them in a specific workspace. The order determines the position of a tab in the Relativity UI. This method returns a list of TabViewOrder objects. See Retrieve tab orders.
• ReadAsync() method - retrieves metadata for a tab, including its name, order, link type, and other properties. You can also use this overloaded method to return extended metadata, including information about the operations that you have permissions to perform on the tab, such as update or delete. This method returns a TabResponse object. See Retrieve tab metadata.
• UpdateAsync()method - modifies the properties of a tab, such as its name, order, and others. You can also use this overloaded method to restrict the update of a tab based on the date that it was last modified. See Update a tab.

The Tab Manager API uses the following classes and enumerations:

• TabRequest class - represents the data used to create or update a tab, including its name, order, visibility, and other properties. The CreateAsync() and UpdateAsync() methods take an object of this type as an argument.
• TabResponse class - represents information about a tab, including its name, order, visibility, and other properties. The ReadAsync(), CreateAsync() and UpdateAsync() methods return an object of this type.
• TabViewOrder class - contains information about the location of the tab in the Relativity UI. Its properties include the tab name, parent tab, order, and others. The Order property is a numerical value indicating the position of the tab relative to other tabs in the UI. The GetViewOrderListAsync() method returns an object of this type. See Retrieve tab orders.
• TabLinkTypeEnum enumeration - indicates type of link associated with the tab. For example, a parent type indicates that the tab can have child tabs, an external type indicates the tab links to a URL, and an object type indicates the tab links to a Relativity object.
• ParentTabResponse class - contains information about a parent tab with a list of possible child link types.
• NavigationTabResponse class - represents navigation information about a tab, including its URL as well as its name, order, visibility, parent, and other properties. The GetAllNavigationTabsAsync() method returns a list of objects of this type.

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.DataVisualization.V1.Tab.ITabManager proxy = serviceFactory.CreateProxy<Relativity.DataVisualization.V1.Tab.ITabManager>();

List<TabViewOrder> tabViewOrder = tabManager.GetViewOrderListAsync(WorkspaceID).GetAwaiter().GetResult();
  
List<ParentTabResponse> allParentTabs = tabManager.GetEligibleParentTabsAsync(WorkspaceID).GetAwaiter().GetResult();
  
TabResponse entitiesTabResponse = tabManager.ReadAsync(WorkspaceID, entitiesTabArtifactID).GetAwaiter().GetResult();

int systemArtifactID = artifactHelper.RetrieveSystemArtifactId();
  
return new TabRequest()
{
    Name = Constants.ENTITIES_PARENT_TAB_NAME,
    Order = newEntitiesParentTabOrder,
    LinkType = TabLinkTypeEnum.Parent,
    IsVisible = true,
    Parent = new ObjectIdentifier { ArtifactID = systemArtifactID }
};

TabResponse entitiesTabResponse = tabManager.ReadAsync(WorkspaceID, entitiesTabArtifactID).GetAwaiter().GetResult();
    
TabRequest entitiesTabRequest = TranslateTabResponseToTabRequest(entitiesTabResponse);
    
private TabRequest TranslateTabResponseToTabRequest(TabResponse tabResponse)
{
    TabRequest tabRequest = null;
    
    if (tabResponse != null)
    {
        tabRequest = new TabRequest
        {
            Name = tabResponse.ObjectIdentifier.Name,
            Order = tabResponse.Order,
            Link = tabResponse.Link,
            IsDefault = tabResponse.IsDefault,
            IsVisible = tabResponse.IsVisible,
            IsShownInSidebar = tabResponse.IsShownInSidebar,
            RelativityApplications = tabResponse.RelativityApplications.ViewableItems.Select(x => new ObjectIdentifier { ArtifactID = x.ArtifactID }).ToList(),
            LinkType = tabResponse.LinkType,
            IconIdentifier = tabResponse.IconIdentifier,
            Parent = new ObjectIdentifier { ArtifactID = tabResponse.Parent.Value.ArtifactID },
            ObjectType = tabResponse.ObjectType
        };
    }
    
    return tabRequest;
}

The following table lists the available values for the IconIdentifier property:

public bool Create(IHelper helper)
{
    bool success = false;
    
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            string tabName = "Sample_Tab";
            TabRequest request = new TabRequest
            {
                Name = tabName,
                Order = 100,
                LinkType = TabLinkTypeEnum.Object,
                IsVisible = true,
                Parent = new ObjectIdentifier { ArtifactID = 1003663 }
            };
    
            TabResponse response = proxy.CreateAsync(SampleWorkspace_ID, request).GetAwaiter().GetResult();
            _logger.LogDebug("{TabID} - {TabName}", response.ObjectIdentifier.ArtifactID, response.ObjectIdentifier.Name);
        }
        catch (Exception ex)
        {
            _logger.LogError("Create failed - {message}", ex.Message);
            throw;
        }
    }
    
    return success;
}

public bool Read(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            TabResponse response = proxy.ReadAsync(SampleWorkspace_ID, SampleTab_ID).GetAwaiter().GetResult();
            _logger.LogDebug("{TabID} - {TabName}", response.ObjectIdentifier.ArtifactID, response.ObjectIdentifier.Name);
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Read failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool Update(IHelper helper)
{
    bool success = false;
    
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            string tabName = "Sample_Tab";
            TabRequest request = new TabRequest
            {
                Name = tabName,
                Order = 100,
                LinkType = TabLinkTypeEnum.Object,
                IsVisible = true,
                Parent = new ObjectIdentifier { ArtifactID = 1003663 },
                ObjectType = new DisplayableObjectTypeIdentifier { ArtifactTypeID = 10 }
            };
    
            proxy.UpdateAsync(SampleWorkspace_ID, request).GetAwaiter().GetResult();
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Update failed - {message}", ex.Message);
            throw;
        }
    
    }
    
    return success;
}

public bool Delete(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            proxy.DeleteAsync(SampleWorkspace_ID, SampleTab_ID).GetAwaiter().GetResult();
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Delete failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool GetAvailableObjectTypes(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            List<DisplayableObjectTypeIdentifier> response = proxy.GetEligibleObjectTypesAsync(SampleWorkspace_ID).GetAwaiter().GetResult();
            _logger.LogDebug("All available object types for workspace {WorkspaceID}", SampleWorkspace_ID);
  
            foreach (DisplayableObjectTypeIdentifier identifier in response)
            {
                _logger.LogDebug("{Name} - {ArtifactTypeID} - {ArtifactID}", identifier.Name, identifier.ArtifactTypeID, identifier.ArtifactID);
            }
  
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Get all available object types failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool GetAvailableParents(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            List<ParentTabResponse> response = proxy.GetEligibleParentTabsAsync(SampleWorkspace_ID).GetAwaiter().GetResult();
            _logger.LogDebug("All available parent tabs for workspace {WorkspaceID}", SampleWorkspace_ID);
  
            foreach (ParentTabResponse tab in response)
            {
                _logger.LogDebug("{Name} - {ArtifactID}", tab.ObjectIdentifier.Name, tab.ObjectIdentifier.ArtifactID);
            }
  
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Get all available parents failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool GetMeta(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            Meta response = proxy.GetMetaAsync(SampleWorkspace_ID).GetAwaiter().GetResult();
            _logger.LogDebug("Tab Meta for workspace {WorkspaceID}", SampleWorkspace_ID);
  
            foreach (String unsupportedMeta in response.Unsupported)
            {
                _logger.LogDebug("Unsupported - {UnsupportedMeta}", unsupportedMeta);
            }
  
            foreach (String readOnlyMeta in response.ReadOnly)
            {
                _logger.LogDebug("ReadOnly - {ReadOnlyMeta}", readOnlyMeta);
            }
  
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Get workspace level metadata failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool GetViewOrderList(IHelper helper)
{
    bool success = false;
  
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            List<TabViewOrder> response = proxy.GetViewOrderListAsync(SampleWorkspace_ID).GetAwaiter().GetResult();
            _logger.LogDebug("List of all tabs and their view order for workspace {WorkspaceID}", SampleWorkspace_ID);
  
            foreach (TabViewOrder viewOrder in response)
            {
                _logger.LogDebug("{Name} - {ArtifactID} - {Order}", viewOrder.ObjectIdentifier.Name, viewOrder.ObjectIdentifier.ArtifactID, viewOrder.Order);
            }
  
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("Get view order list failed - {message}", ex.Message);
            throw;
        }
    }
  
    return success;
}

public bool GetAllNavigationTabs(IHelper helper)
{
    bool success = false;
   
    using (ITabManager proxy = helper.GetServicesManager().CreateProxy<ITabManager>(ExecutionIdentity.System))
    {
        try
        {
            List<NavigationTabResponse> response = proxy.GetAllNavigationTabsAsync(SampleWorkspace_ID).GetAwaiter().GetResult();
                  
            foreach (NavigationTabResponse navigationTabResponse in response)
            {
                _logger.LogDebug("{Name} - {Order} - {URL}", navigationTabResponse.ObjectIdentifier.Name, navigationTabResponse.Order, navigationTabResponse.Url);
            }
  
            success = true;
        }
        catch (Exception ex)
        {
            _logger.LogError("GetAllNavigationTabs failed - {message}", ex.Message);
            throw;
        }
    }
   
    return success;
}