Object Type Manager (.NET)

The Object Type Manager API contains the following methods and classes.

Methods

The Object Type Manager API exposes the following methods on the IObjectTypeManager interface in the Relativity.Services.Interfaces.ObjectType namespace:

• CreateAsync() method - adds a new object type to the specified workspace. Its parameters include the Artifact ID of the workspace, and an ObjectTypeRequest object. This method returns the Artifact ID of the object type. See Create an object type.
• DeleteAsync() method - removes an object type from a specified workspace. Its parameters include the Artifact IDs of the workspace and object type. This method returns the Artifact ID of the deleted object type. See Delete an object type.
• GetAvailableParentObjectTypesAsync() method - retrieves a list of parent object types available in a workspace. It takes the Artifact ID of the workspace, and returns a list of ObjectTypeIdentifier objects. You can call this helper method before creating an object type to get the Artifact ID of the parent type. See Retrieve a parent object types.

  Note: The ObjectTypeIdentifier class contains the Artifact ID, Name, and other identifiers for an object. It is available in the Relativity.Services.Interfaces.Shared.Models namespace. For more information, see this class in the Services API.

• GetDependencyList() method - retrieves a list of objects in a workspace that are dependent on a specific object type. It takes the Artifact IDs of the workspace and object type, and returns a list of Dependency objects. You can call this helper method before deleting an object type to determine how to handle dependent objects. See Retrieve a list of dependent objects.

• ReadAsync() method - retrieves information about an object, including its parent object type, whether it is a dynamic object or its view is enabled, 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 object, such as update or delete. This method takes the Artifact IDs of the workspace and object type, and two optional Boolean values for extended metadata. It returns an ObjectTypeResponse object. See Read an object type for C# code sample, and Read an object type in REST for brief field descriptions.

• UpdateAsync() method - modifies the properties of an object type, such as its user-friendly name, whether pivot or copy instances on workspace creation is enabled, and others. You can use also this overloaded method to restrict the update of an object type based on the date that it was last modified. This method takes the Artifact IDs of the workspace and object type, an ObjectTypeRequest object, and an optional DateTime object to restrict the update to the date last modified. It returns a Task. See Update an object type.

Classes

The Object Type Manager API includes the following classes available in the Relativity.Services.Interfaces.ObjectType.Models namespace:

• ObjectTypeRequest class - represents the data used to create or update an object type. The CreateAsync() and UpdateAsync() methods take an object of this type. Its properties include name, parent object type, and others. See this class in the Services API.
• ObjectTypeResponse class - represents the results of a read operation. Its properties include name, parent object type, and others. See this class in the Services API.

Additionally, this API includes the following class in the Relativity.Services.Interfaces.ObjectType namespace:

• ObjectTypeConstants class - provides routing information about URLs used by the Object Type Manager service. See this class in the Services API.

The Event Handler Manager API contains the following methods and classes.

Methods

The Event Handler Manager API exposes the following methods on the IEventHandlerManager interface in the Relativity.Services.Interfaces.EventHandler namespace:

• AttachAsync() method - adds an event handler to the specified object type. This method takes the Artifact IDs of the workspace, the object type to attach the event handler to, and the event handler. It returns a Task. See Attach an event handler to an object type.
• DetachAsync() method - removes an event handler from the specified object type. This method takes the Artifact IDs of the workspace, the object type to detached the event handler from, and the event handler. It returns a Task. See Detach an event handler to an object type.
• GetAttachedAsync() method - retrieves a list of event handlers attached to the specified object type. This method takes the Artifact IDs of the workspace and object type, and returns a list of EventHandlerResponse objects. See Retrieve event handlers attached to an object type.
• GetAvailableEventHandlersAsync() method - retrieves a list of event handlers available in a workspace for association with a specific object type. This method takes the Artifact IDs of the workspace and object type, and returns a list of EventHandlerResponse objects. See Retrieve available event handlers for an object type.

Classes and enumerations

The Event Handler Manager API includes the following classes and enumeration available in the Relativity.Services.Interfaces.EventHandler.Models namespace:

• EventHandlerExecution enumeration - provides a list of execution types for event handlers, such as Console, PageInteraction, and others. See Develop object type event handlers for general information about these event handler types, and EventHandlerExecution Enumeration in the Services API for a complete list of members.
• EventHandlerResponse class - represents the results of a get operation for attached or available event handlers in a workspace. The GetAttachedAsync() and GetAvailableEventHandlersAsync() methods return an object of this type. Its properties include class name, assembly name, and others. See this class in the Services API.

The Object Rule Manager API contains the following methods and classes.

Methods

The Object Rule Manager API exposes the following methods on the IObjectRuleManager interface in the Relativity.Services.Interfaces.ObjectRules namespace:

• Create method for each object rule type - adds a new object rule to the specified object type. The parameters for the create methods include the Artifact ID of the workspace, and a request object for the rule type. These methods return the Artifact ID of the new object rule.

  Note: Each type of object rule has its own create method, and request class. For a complete list of create methods, see Create an object rule.

• DeleteAsync() method - removes an object rule from an object type in the specified workspace. Its parameters include the Artifact IDs of the workspace and the object rule. This method returns a Task. See Delete an object rule.
• GetAvailableAssociatedObjectsAsync() method - retrieves a list of associated objects that can be used with an object rule on a specific object type. This overloaded method supports retrieving associated objects by Artifact ID or by name. Its parameters include the Artifact ID of a workspace, and the Artifact ID or ObjectTypeIdentifier object for the associated object. It returns a list of SubListObjectIdentifier objects. See Retrieve choices, choice fields, layouts, or associated objects.

  Note: The SubListObjectIdentifier class contains the Artifact ID, Name, ListType, and other identifiers for an object. It is available in the Relativity.Services.Interfaces.Shared.Models namespace. For more information, see this class in the Services API.

• GetAvailableChoiceFieldsAsync() method - retrieves a list of choice fields that can be associated with an object rule on a specific object type. This overloaded method supports retrieving choice fields by Artifact ID or by name. Its parameters include the Artifact ID of a workspace, and the Artifact ID or ObjectTypeIdentifier object for the object type. It returns an DisplayableObjectIdentifier object. See Retrieve choices, choice fields, layouts, or associated objects.

  Note: The DisplayableObjectIdentifier class contains the Artifact ID, Guids, and Name properties. It is available in the Relativity.Services.Interfaces.Shared.Models namespace. For more information, see this class in the Services API.

• GetAvailableChoicesAsync() method - retrieves a list of choices that can be associated with an object rule on a specific object type. Its parameters include the Artifact IDs of the workspace and the choice field. It returns an DisplayableObjectIdentifier object. See Retrieve choices, choice fields, layouts, or associated objects.
• GetAvailableLayoutsAsync() method - retrieves a list of layouts that can be associated with an object rule on a specific object type. This overloaded method supports retrieving layouts by Artifact ID or by name. Its parameters include the Artifact ID of a workspace, and the Artifact ID or ObjectTypeIdentifier object for the object type. It returns an DisplayableObjectIdentifier object. See Retrieve choices, choice fields, layouts, or associated objects.
• GetAvailableSingleChoiceFieldsAsync() method - retrieves a list of single choices fields that can be associated with an object rule on a specific object type. This overloaded method supports retrieving layouts by Artifact ID or by name. Its parameters include the Artifact ID of a workspace, and the Artifact ID or ObjectTypeIdentifier object for the object type. It returns an DisplayableObjectIdentifier object. See Retrieve choices, choice fields, layouts, or associated objects.
• MassDeleteAsync() method - removes multiple object rules across different object types. Its parameters include the Artifact ID of a workspace and a list containing the Artifact ID for each rule that you want to delete. This method returns a Task. See Delete multiple object rules.
• ReadAsync() method - retrieves information about an object rule, including its name, the object type associated with the rule, 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 object, such as update or delete. This method takes the Artifact IDs of the workspace and object rule, and two optional Boolean values for extended metadata. It returns an ObjectRuleResponse object. See Read an object rule for C# code sample, and Read an object rule in REST for brief field descriptions.
• Update method for each object rule type - modifies the properties of an object rule, such as its name, associated object type, and others. The parameters for the update methods include the Artifact IDs of the workspace and the object rule, and a request object for the rule type. These methods return a Task.

  Note: Each type of object rule has its own update method, and request class. For a complete list of update methods, see Update an object rule.

Classes

The Object Rule Manager API includes the following classes and enumeration available in the Relativity.Services.Interfaces.ObjectRules.Models namespace:

• Request class for each object rule type - represents the data used to create or update an object type. Each create and update method takes an object of this type. For more information, see a specific request class in the Services API.
• ObjectRuleBehavior enumeration - provides a list of object rule types, such as DefaultLayout, CustomSingleObjectAddLinkVisibility, and others. See Adding an object rule for general information about these rule types, and ObjectRuleBehavior Enumeration in the Services API for a complete list of members.
• ObjectRuleResponse class - represents the results of a read operation. Its properties include name, the object type associated with the rule, and others. See this class in the Services API.

Additionally, this API includes the following class in the Relativity.Services.Interfaces.ObjectType namespace:

• ObjectRuleConstants class - provides routing information about URLs used by the Object Rule Manager service. See this class in the Services API.

The Mass Operation Manager API contains the following methods and classes.

Methods

The Mass Operation Manager API exposes the following methods on the IMassOperationManager interface in the Relativity.Services.Interfaces.MassOperation namespace:

• CreateAsync() method - adds a new mass operation to an object type in a specified workspace. This overloaded method creates custom page or event handler mass operations. Its parameters include the Artifact ID of a workspace, and either a EventHandlerMassOperationRequest or CustomPageMassOperationRequest object. It returns the Artifact ID of the new mass operation. See Create a mass operation.
• DeleteAsync() method - removes a mass operation from an object type in the specified workspace. Its parameters include the Artifact IDs of the workspace and the mass operation. See Delete a mass operation.
• GetAvailableEventHandlersAsync() method - retrieves a list of event handlers in a specified workspace. It takes the Artifact ID of the workspace, and returns a list of MassOperationEventHandlerResponse objects. You can all this helper method before creating a mass operation to get the ID of an event handler. See Retrieve available event handlers for a mass operation.
• GetAvailableLayoutsAsync() method - retrieves a list of layouts for an object type, which are available in the specified workspace. It takes the Artifact IDs of the workspace and an ObjectTypeIdentifier instance, and returns a list of MassOperationLayoutResponse objects. You can all this helper method before creating a event handler mass operation to get the Artifact ID of a layout. See Retrieve available layouts for a mass operation.

  Note: The ObjectTypeIdentifier class contains the Artifact ID, Name, and other identifiers for an object. It is available in the Relativity.Services.Interfaces.Shared.Models namespace. For more information, see this class in the Services API.

• GetAvailableObjectTypeAsync() method - retrieves a list of ObjectTypeIdentifier instances, which represent the available object types in the specified workspace. It takes the Artifact ID of a workspace. This method returns ObjectTypeIdentifier instances, which contain the user-friendly name, Artifact ID, Artifact Type ID, and GUIDs for each object type. See Retrieve available object types for a mass operation.
• ReadMassOperationAsync() method - retrieves information about a mass operation, such as its name, associated object type and applications, 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 object, such as update or delete. This method takes the Artifact IDs of the workspace and mass operation, and two optional Boolean values for extended metadata. It returns an MassOperationResponse object. See Read a mass operation.
• UpdateAsync() method - modifies the properties of a mass operation. This overloaded method updates custom page or event handler mass operations. Its parameters include the Artifact IDs of a workspace and a mass operation, and either a EventHandlerMassOperationRequest or CustomPageMassOperationRequest object. See Update a mass operation.

Classes

The Mass Operation Manager API includes the following classes and enumeration available in the Relativity.Services.Interfaces.ObjectRules.Models namespace:

• CustomPageMassOperationRequest class - represents the data used to create or update a mass operation that displays a custom page as a pop-up window. The CreateAsync() and UpdateAsync() methods take an object of this type. Its properties include the URL for the custom page, the width and height of the window, and others. See this class in the Services API.
• EventHandlerMassOperationRequest class - represents the data used to create or update a mass operation that executes a custom event handler. The CreateAsync() and UpdateAsync() methods take an object of this type. It properties include the ID of the event handler, object type and layout associate with operation, and others. See this class in the Services API.
• MassOperationEventHandlerResponse class - contains information about an event handler, such as the class, assembly, and application associated with it, and other properties. The GetAvailableEventHandlersAsync() method returns an object of this type. See this class in the Services API.
• MassOperationLayoutResponse class - contains information about a layout, such as its user-friendly name, Artifact ID, associated object type, and other information. The GetAvailableLayoutsAsync() method returns an object of this type. See this class in the Services API.
• MassOperationResponse class - represents information about a mass operation, such its name, object type and application associated with it, and other properties. The ReadMassOperationAsync() method returns an object of this type. See this class in the Services API.
• MassOperationType enumeration - provides a list of mass operation types, including CustomPageMassOperation and EventHandlerMassOperation. These enums indicate whether the mass operation displays a custom page or executes a custom event handler.

Additionally, this API includes the following class in the Relativity.Services.Interfaces.MassOperation namespace:

• MassOperationConstants class - provides routing information about URLs used by the Mass Operation Manager service. See this class in the Services API.

public static async Task Create_Async()
{
    int workspaceId = 1018486;
    int parentArtifactTypeId = 10;
    int parentArtifactId = 1035231;
    int applicationId = 1035699; 
                    
    ObjectTypeRequest request = new ObjectTypeRequest
    {
        Name = "Test Object",
        CopyInstancesOnCaseCreation = false,
        CopyInstancesOnParentCopy = false,
        EnableSnapshotAuditingOnDelete = true,
        PersistentListsEnabled = false,
        PivotEnabled = true,
        SamplingEnabled = false,
        Keywords = "",
        Notes = "",
        ParentObjectType = new Securable<ObjectTypeIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier
            { ArtifactID = parentArtifactId, ArtifactTypeID = parentArtifactTypeId }
        },
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.ObjectType.IObjectTypeManager objectTypeManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectType.IObjectTypeManager>())
    {
        try
        {
            int newObjectTypeArtifactId = await objectTypeManager.CreateAsync(workspaceId, request);
            string info = string.Format("Created object type with Artifact ID {0}", newObjectTypeArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }            
}

public static async Task Update_Async()
{
    int workspaceId = 1018486;
    int parentArtifactTypeId = 10;
    int parentArtifactId = 1035231;
    int applicationId = 1035699; 
    int objectTypeArtifactId = 1035231;

    ObjectTypeRequest request = new ObjectTypeRequest
    {
        Name = "Test Object Update",
        CopyInstancesOnCaseCreation = false,
        CopyInstancesOnParentCopy = false,
        EnableSnapshotAuditingOnDelete = true,
        PersistentListsEnabled = false,
        PivotEnabled = true,
        SamplingEnabled = false,
        Keywords = "updated keywords",
        Notes = "updated notes",
        ParentObjectType = new Securable<ObjectTypeIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier
            { ArtifactID = parentArtifactId, ArtifactTypeID = parentArtifactTypeId }
        },
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.ObjectType.IObjectTypeManager objectTypeManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectType.IObjectTypeManager>())
    {
        try
        {
            await objectTypeManager.UpdateAsync(workspaceId, objectTypeArtifactId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

• Choice behavior

  Task<int> CreateChoiceBehaviorAsync(int workspaceID, ChoiceBehaviorRuleRequest objectRuleRequest)
  

• Custom single object add link visibility

  Task<int> CreateCustomSingleObjectAddLinkVisibilityAsync(int workspaceID, CustomSingleObjectAddLinkVisibilityRuleRequest objectRuleRequest)
  

• Default layout

  Task<int> CreateDefaultLayoutAsync(int workspaceID, DefaultLayoutRuleRequest objectRuleRequest)
  

• Default layout on new

  Task<int> CreateDefaultLayoutOnNewAsync(int workspaceID, DefaultLayoutOnNewRuleRequest objectRuleRequest)
  

• Global button visibility

  Task<int> CreateGlobalButtonVisibilityAsync(int workspaceID, GlobalButtonVisibilityRuleRequest objectRuleRequest)
  

• Mass action visibility

  Task<int> CreateMassActionVisibilityAsync(int workspaceID, MassActionVisibilityRuleRequest objectRuleRequest)
  

• New button override

  Task<int> CreateNewButtonOverrideAsync(int workspaceID, NewButtonOverrideRuleRequest objectRuleRequest);

• Sub-list button visibility

  Task<int> CreateSubListButtonVisibilityAsync(int workspaceID, SubListButtonVisibilityRuleRequest objectRuleRequest)
  

• Override edit link URL

  Task<int> CreateOverrideEditLinkAsync(int workspaceID, OverrideEditLinkRuleRequest objectRuleRequest)
  

• Override view link URL

  Task<int> CreateOverrideViewLinkAsync(int workspaceID, OverrideViewLinkRuleRequest objectRuleRequest)
  

The following code sample illustrates how to instantiate a SubListButtonVisibilityRuleRequest object with properties specified for the new object rule. To create the rule, call the CreateSubListButtonVisibilityAsync() method by passing the Artifact ID of workspace where you want to add the rule, and the SubListButtonVisibilityRuleRequest instance.

public static async Task CreateSublistButtonVisibilityRule_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 101456834
    int fieldId = 1035231;
    int choiceId = 1938203; 
    int sublistObjectId = 1832739;
    int applicationId = 1035699; 
                    
    SubListButtonVisibilityRuleRequest request = new SubListButtonVisibilityRuleRequest
    {
        Name = "Test Object Rule Request",
        ShowNew = false,
        ShowDelete = false,
        ShowLink = false,
        ShowUnlink = true,
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        Field = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        Choice = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = choiceId }
        },
        SubListObject = new Securable<ObjectTypeIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = sublistObjectId }
        },
        RelativityApplications = new List<ObjectIdentifier>
        {
            new ObjectIdentifier { ArtifactID = applicationId }
        }        
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            int newRuleArtifactId = await objectRuleManager.CreateSubListButtonVisibilityAsync(workspaceId, request);
            string info = string.Format("Created object rule with Artifact ID {0}", newRuleArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }            
}

The following code sample illustrates how to instantiate a ChoiceBehaviorRuleRequest object with properties specified for the new object rule. To create the rule, call the CreateChoiceBehaviorAsync() method by passing the Artifact ID of workspace where you want to add the rule, and the ChoiceBehaviorRuleRequest instance.

public static async Task CreateChoiceBehavior_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int fieldId = 1035231;
    int applicationId = 1035699; 
                    
    ChoiceBehaviorRuleRequest request = new ChoiceBehaviorRuleRequest
    {
        Name = "Test Choice Behavior Rule",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        Field = new Securable<ObjectIdentifier> {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        ShowAdd = true,
        ShowDelete = false,
        ShowRename = false,
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            int newRuleArtifactId = await objectRuleManager.CreateChoiceBehaviorAsync(workspaceId, request);
            string info = string.Format("Created object rule with Artifact ID {0}", newRuleArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

The following code sample illustrates how to instantiate a DefaultLayoutRuleRequest object with properties specified for the new object rule. To create the rule, call the CreateDefaultLayoutAsync() method by passing the Artifact ID of workspace where you want to add the rule, and the DefaultLayoutRuleRequest instance.

public static async Task CreateDefaultLayout_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int fieldId = 1035231;
    int choiceId = 1938203; 
    int layoutId = 1837293;
    int applicationId = 1035699; 
                    
    DefaultLayoutRuleRequest request = new DefaultLayoutRuleRequest
    {
        Name = "Test Object Rule Request",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        AllowLayoutChange = true,
        Field = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        Choice = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = choiceId }
        },
        Layout = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = layoutId }
        },
        RelativityApplications = new List<ObjectIdentifier>
        {
            new ObjectIdentifier { ArtifactID = applicationId }
        }                
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            int newRuleArtifactId = await objectRuleManager.CreateDefaultLayoutAsync(workspaceId, request);
            string info = string.Format("Created object rule with Artifact ID {0}", newRuleArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }            
}

You can find general information about available object rules in Adding an object rule.

• Choice behavior

  Task UpdateChoiceBehaviorAsync(
      int workspaceID,
      int objectRuleID,
      ChoiceBehaviorRuleRequest objectRuleRequest
  )
  

  Task UpdateChoiceBehaviorAsync(
      int workspaceID,
      int objectRuleID,
      ChoiceBehaviorRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )
  

• Custom single object add link visibility

  Task UpdateCustomSingleObjectAddLinkVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      CustomSingleObjectAddLinkVisibilityRuleRequest objectRuleRequest
  )
  

  Task UpdateCustomSingleObjectAddLinkVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      CustomSingleObjectAddLinkVisibilityRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Default layout

  Task UpdateDefaultLayoutAsync(
      int workspaceID,
      int objectRuleID,
      DefaultLayoutRuleRequest objectRuleRequest
  )
  

  Task UpdateDefaultLayoutAsync(
      int workspaceID,
      int objectRuleID,
      DefaultLayoutRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Default layout on new

  Task UpdateDefaultLayoutOnNewAsync(
      int workspaceID,
      int objectRuleID,
      DefaultLayoutOnNewRuleRequest objectRuleRequest
  )
  

  Task UpdateDefaultLayoutOnNewAsync(
      int workspaceID,
      int objectRuleID,
      DefaultLayoutOnNewRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Global button visibility

  Task UpdateGlobalButtonVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      GlobalButtonVisibilityRuleRequest objectRuleRequest
  )
  

  Task UpdateGlobalButtonVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      GlobalButtonVisibilityRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )
  

• Mass action visibility

  Task UpdateMassActionVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      MassActionVisibilityRuleRequest objectRuleRequest
  )
  

  Task UpdateMassActionVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      MassActionVisibilityRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• New button override

  Task UpdateNewButtonOverrideAsync(
      int workspaceID,
      int objectRuleID,
      NewButtonOverrideRuleRequest objectRuleRequest
  )
  

  Task UpdateNewButtonOverrideAsync(
      int workspaceID,
      int objectRuleID,
      NewButtonOverrideRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Sub-list button visibility

  Task UpdateSubListButtonVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      SubListButtonVisibilityRuleRequest objectRuleRequest
  )
  

  Task UpdateSubListButtonVisibilityAsync(
      int workspaceID,
      int objectRuleID,
      SubListButtonVisibilityRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Override edit link URL

  Task UpdateOverrideEditLinkAsync(
      int workspaceID,
      int objectRuleID,
      OverrideEditLinkRuleRequest objectRuleRequest
  )
  

  Task UpdateOverrideEditLinkAsync(
      int workspaceID,
      int objectRuleID,
      OverrideEditLinkRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

• Override view link URL

  Task UpdateOverrideViewLinkAsync(
      int workspaceID,
      int objectRuleID,
      OverrideViewLinkRuleRequest objectRuleRequest
  )
  

  Task UpdateOverrideViewLinkAsync(
      int workspaceID,
      int objectRuleID,
      OverrideViewLinkRuleRequest objectRuleRequest,
      DateTime lastModifiedOn
  )

The following code sample illustrates how to instantiate a SubListButtonVisibilityRuleRequest object with properties used for updating the object rule. To update the rule, call the UpdateSubListButtonVisibilityAsync() method by passing Artifact IDs of the workspace and object rule, and the SubListButtonVisibilityRuleRequest instance.

public static async Task UpdateSubListButtonVisibility_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int fieldId = 1035231;
    int choiceId = 1938203; 
    int layoutId = 1837293;
    int applicationId = 1035699; 
    int objectRuleId = 1383730;
                
    SubListButtonVisibilityRuleRequest request = new SubListButtonVisibilityRuleRequest
    {
        Name = "Test Object Rule Request",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        AllowLayoutChange = true,
        Field = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        Choice = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = choiceId }
        },
        Layout = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = layoutId }
        },
        RelativityApplications = new List<ObjectIdentifier>
        {
            new ObjectIdentifier { ArtifactID = applicationId }
        }                    
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            await objectRuleManager.UpdateSubListButtonVisibilityAsync(workspaceId, objectRuleId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

The following code sample illustrates how to instantiate a ChoiceBehaviorRuleRequest object with properties used for updating the object rule. To update the rule, call the UpdateChoiceBehaviorAsync() method by passing Artifact IDs of the workspace and object rule, and the ChoiceBehaviorRuleRequest instance.

public static async Task UpdateChoiceBehavior_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int fieldId = 1035231;
    int applicationId = 1035699;                     
    int objectRuleId = 1383730;

    ChoiceBehaviorRuleRequest request = new ChoiceBehaviorRuleRequest
    {
        Name = "Test Choice Behavior Rule Update",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        Field = new Securable<ObjectIdentifier> {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        ShowAdd = false,
        ShowDelete = true,
        ShowRename = true,
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            await objectRuleManager.UpdateChoiceBehaviorAsync(workspaceId, objectRuleId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

The following code sample illustrates how to instantiate a DefaultLayoutRuleRequest object with properties used for updating the object rule. To update the rule, call the UpdateDefaultLayoutAsync method by passing Artifact IDs of the workspace and object rule, and the DefaultLayoutRuleRequest instance.

public static async Task UpdateLayoutBehavior_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int fieldId = 1035231;
    int choiceId = 1938203; 
    int layoutId = 1837293;
    int applicationId = 1035699; 
    int objectRuleId = 1383730;
                    
    DefaultLayoutRuleRequest request = new DefaultLayoutRuleRequest
    {
        Name = "Test Object Rule Request",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId },
        AllowLayoutChange = true,
        Field = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = fieldId }
        },
        Choice = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = choiceId }
        },
        Layout = new Securable<ObjectIdentifier>
        {
            Secured = false,
            Value = new ObjectTypeIdentifier { ArtifactID = layoutId }
        },
        RelativityApplications = new List<ObjectIdentifier>
        {
            new ObjectIdentifier { ArtifactID = applicationId }
        }                
    };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            await objectRuleManager.UpdateDefaultLayoutAsync(workspaceId, objectRuleId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID

If you have the Artifact ID of the object type, use the following method to retrieve associated objects for it:

Task<List<SubListObjectIdentifier>> GetAvailableAssociatedObjectsAsync(int workspaceID, int objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableAssociatedObjects_Async()
{
    int workspaceId = 1018486;
    int objectTypeId = 1039509;

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<SubListObjectIdentifier> response = await objectRuleManager.GetAvailableAssociatedObjectsAsync(workspaceId, objectTypeId);
            foreach (SubListObjectIdentifier subListIdentifier in response)
            {
                string info = string.Format("Read {0} '{1}' with Artifact ID '{2}'",
                    subListIdentifier.ListType, subListIdentifier.Name, subListIdentifier.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID or name

If you have the user-friendly name of the object type, use the following method to retrieve associated objects for it:

Task<List<SubListObjectIdentifier>> GetAvailableAssociatedObjectsAsync(int workspaceID, ObjectTypeIdentifier objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableAssociatedObjects_Async()
{
    int workspaceId = 1018486;
    int objectTypeArtifactId = 1039509;

    ObjectTypeIdentifier objectTypeIdentifier = new ObjectTypeIdentifier { ArtifactID = objectTypeArtifactId };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<SubListObjectIdentifier> response = await objectRuleManager.GetAvailableAssociatedObjectsAsync(workspaceId, objectTypeIdentifier);
            foreach (SubListObjectIdentifier subListIdentifier in response)
            {
                string info = string.Format("Read {0} '{1}' with Artifact ID '{2}'",
                    subListIdentifier.ListType, subListIdentifier.Name, subListIdentifier.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID

If you have the Artifact ID of the object type, use the following method to retrieve single choice fields for it:

Task<List<DisplayableObjectIdentifier>> GetAvailableSingleChoiceFieldsAsync(int workspaceID, int objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableSingleChoiceFields_Async()
{
    int workspaceId = 1018486;
    int objectTypeId = 1039509;

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableSingleChoiceFieldsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier singleChoiceField in response)
            {
                string info = string.Format("Read single choice field {0} with Artifact ID {1}", singleChoiceField.Name, singleChoiceField.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }

Retrieve with Artifact ID or name

If you have the user-friendly name of the object type, use the following method to retrieve single choice fields for it:

CopyTask<List<DisplayableObjectIdentifier>> GetAvailableSingleChoiceFieldsAsync(int workspaceID, ObjectTypeIdentifier objectTypeID)

The following code sample illustrates how to use this method:

{
    int workspaceId = 1018486;
    int objectTypeArtifactId = 1039509;
    
    ObjectTypeIdentifier objectTypeId = new ObjectTypeIdentifier { ArtifactID = objectTypeArtifactId };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableSingleChoiceFieldsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier singleChoiceField in response)
            {
                string info = string.Format("Read single choice field {0} with Artifact ID {1}", singleChoiceField.Name, singleChoiceField.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID

If you have the Artifact ID of the object type, use the following method to retrieve choice fields for it:

Task<List<DisplayableObjectIdentifier>> GetAvailableChoiceFieldsAsync(int workspaceID, int objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableChoiceFields_Async()
{
    int workspaceId = 1018486;
    int objectTypeId = 1039509;

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableChoiceFieldsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier choiceField in response)
            {
                string info = string.Format("Read choice field {0} with Artifact ID {1}", choiceField.Name, choiceField.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID or name

If you have the user-friendly name of the object type, use the following method to retrieve choice fields for it:

Task<List<DisplayableObjectIdentifier>> GetAvailableChoiceFieldsAsync(int workspaceID, ObjectTypeIdentifier objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableChoiceFields_Async()
{
    int workspaceId = 1018486;
    int objectTypeArtifactId = 1039509;
    
    ObjectTypeIdentifier objectTypeId = new ObjectTypeIdentifier { ArtifactID = objectTypeArtifactId };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableChoiceFieldsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier choiceField in response)
            {
                string info = string.Format("Read choice field {0} with Artifact ID {1}", choiceField.Name, choiceField.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

To retrieve a list of choices for an object type, use the following method:

Task<List<DisplayableObjectIdentifier>> GetAvailableChoicesAsync(int workspaceID, int fieldID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableChoices_Async()
{
    int workspaceId = 1018486;
    int fieldId = 1039509;

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableChoicesAsync(workspaceId, fieldId);
            foreach (DisplayableObjectIdentifier choice in response)
            {
                string info = string.Format("Read choice {0} with Artifact ID {1}", choice.Name, choice.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID

If you have the Artifact ID of the object type, use the following method to retrieve layouts for it:

Task<List<DisplayableObjectIdentifier>> GetAvailableLayoutsAsync(int workspaceID, int objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableLayouts_Async()
{
    int workspaceId = 1018486;
    int objectTypeId = 1039509;

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableLayoutsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier layout in response)
            {
                string info = string.Format("Read layout {0} with Artifact ID {1}", layout.Name, layout.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

Retrieve with Artifact ID or name

If you have the user-friendly name of the object type, use the following method to retrieve layouts for it:

Task<List<DisplayableObjectIdentifier>> GetAvailableLayoutsAsync(int workspaceID, ObjectTypeIdentifier objectTypeID)

The following code sample illustrates how to use this method:

public static async Task GetAvailableLayouts_Async()
{
    int workspaceId = 1018486;
    int objectTypeArtifactId = 1039509;
    
    ObjectTypeIdentifier objectTypeId = new ObjectTypeIdentifier { ArtifactID = objectTypeArtifactId };

    using (Services.Interfaces.ObjectRules.IObjectRuleManager objectRuleManager = serviceFactory.CreateProxy<Services.Interfaces.ObjectRules.IObjectRuleManager>())
    {
        try
        {
            List<DisplayableObjectIdentifier> response = await objectRuleManager.GetAvailableLayoutsAsync(workspaceId, objectTypeId);
            foreach (DisplayableObjectIdentifier layout in response)
            {
                string info = string.Format("Read layout {0} with Artifact ID {1}", layout.Name, layout.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

The following code sample illustrates how to instantiate a MassOperationRequest object containing properties used to create the mass operation. Next, it shows how to call the CreateAsync() method by passing the Artifact ID of the workspace and the MassOperationRequest object.

public static async Task Create_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
                    
    MassOperationRequest request = new MassOperationRequest
    {
        Name = "Test Custom Page Mass Operation",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId},
        Url = "www.url.com",
        PopupHeight = 50,
        PopupWidth = 50,
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.MassOperation.IMassOperationManager massOperationManager = serviceFactory.CreateProxy<Services.Interfaces.MassOperation.IMassOperationManager>())
    {
        try
        {
            int newMassOperationArtifactId = await massOperationManager.CreateAsync(workspaceId, request);
            string info = string.Format("Created mass operation with Artifact ID {0}", newMassOperationArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }            
}

The following code sample illustrates how to instantiate a MassOperationRequest object containing properties used to create the mass operation. Next, it shows how to call the CreateAsync() method by passing the Artifact ID of the workspace and the MassOperationRequest object.

public static async Task Create_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
    int eventHandlerId = 1937493;
    int layoutId = 1035699; 
                    
    MassOperationRequest request = new MassOperationRequest
    {
        Name = "Test Event Handler Mass Operation",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId},
        EventHandlerID = eventHandlerId,
        Layout = new Securable<ObjectIdentifier>(new ObjectIdentifier { ArtifactID = layoutId }),
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.MassOperation.IMassOperationManager massOperationManager = serviceFactory.CreateProxy<Services.Interfaces.MassOperation.IMassOperationManager>())
    {
        try
        {
            int newMassOperationArtifactId = await massOperationManager.CreateAsync(workspaceId, request);
            string info = string.Format("Created mass operation with Artifact ID {0}", newMassOperationArtifactId);
            Console.Write(info);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }            
}

You can use these overloaded UpdateAsync() methods to modify custom page mass operations:

• Update the mass operation without any date restrictions

  Task UpdateAsync(
      int workspaceID,
      int massOperationID,
      CustomPageMassOperationRequest massOperationRequest
  )

• Restrict the update of the mass operation to the last modified date:

  Task UpdateAsync(
      int workspaceID,
      int massOperationID,
      CustomPageMassOperationRequest massOperationRequest,
      DateTime lastModifiedOn
  )
  

The following code sample illustrates how to instantiate a MassOperationRequest object containing the updates to the mass operation. Next, it shows how to call the UpdateAsync() method by passing the Artifact IDs of the workspace and mass operation, and the MassOperationRequest object.

public static async Task Update_Async()
{
    int workspaceId = 1018486;
    int parentArtifactId = 1456834;
                    
    MassOperationRequest request = new MassOperationRequest
    {
        Name = "Test Custom Page Mass Operation Updated",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = parentArtifactId},
        Url = "www.url.com",
        PopupHeight = 50,
        PopupWidth = 50,
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.MassOperation.IMassOperationManager massOperationManager = serviceFactory.CreateProxy<Services.Interfaces.MassOperation.IMassOperationManager>())
    {
        try
        {
            await massOperationManager.UpdateAsync(workspaceId, massOperationId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

You can use these overloaded UpdateAsync() methods to modify event handler mass operations:

• Update the mass operation without any date restrictions

  Task UpdateAsync(
      int workspaceID,
      int massOperationID,
      EventHandlerMassOperationRequest massOperationRequest
  )

• Restrict the update of the mass operation to the last modified date:

  Task UpdateAsync(
      int workspaceID,
      int massOperationID,
      EventHandlerMassOperationRequest massOperationRequest,
      DateTime lastModifiedOn
  )
  

The following code sample illustrates how to instantiate a MassOperationRequest object containing the updates to the mass operation. Next, it shows how to call the UpdateAsync() method by passing the Artifact IDs of the workspace and mass operation, and the MassOperationRequest object.

public static async Task Update_Async()
{
    int workspaceId = 1018486;
    int objectTypeArtifactId = 1456834;
    int eventHandlerId = 1937493;
    int layoutId = 1035699; 
    int massOperationId = 1830283;
                    
    MassOperationRequest request = new MassOperationRequest
    {
        Name = "Test Event Handler Mass Operation Updated",
        ObjectType = new ObjectTypeIdentifier { ArtifactID = 1456385},
        EventHandlerID = eventHandlerId,
        Layout = new Securable<ObjectIdentifier>(new ObjectIdentifier { ArtifactID = objectTypeArtifactId }),
        RelativityApplications = new List<Securable<ObjectIdentifier>>
        {
            new ObjectIdentifier {ArtifactID = applicationId}
        }
    };

    using (Services.Interfaces.MassOperation.IMassOperationManager massOperationManager = serviceFactory.CreateProxy<Services.Interfaces.MassOperation.IMassOperationManager>())
    {
        try
        {
            await massOperationManager.UpdateAsync(workspaceId, massOperationId, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}