Mass Operation Manager (.NET)

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.Extensibility.{versionNumber}.MassOperations namespace:

• CreateAsync() method - adds a new mass operation to an object type in a specified workspace. See Create a mass operation.
• ReadMassOperationAsync() method - retrieves information about a mass operation, such as its name, associated object type and applications, and other properties. See Read a mass operation.
• UpdateAsync() method - modifies the properties of a mass operation. See Update a mass operation.
• DeleteAsync() method - removes a mass operation from an object type in the specified workspace. See Delete a mass operation.
• GetAvailableEventHandlersAsync() method - retrieves a list of all event handlers in a specified workspace. See Retrieve available event handlers for a mass operation.
• GetAvailableLayoutsAsync() method - retrieves a list of layouts for an object type available in a given workspace with the specified object type. See Retrieve available layouts for a mass operation.
• GetAvailableObjectTypeAsync() method - retrieves a list of the available object types in the specified workspace. See Retrieve available object types for a mass operation.

Classes

The Mass Operation Manager API includes the following classes and enumeration available in the Relativity.Extensibility.{versionNumber}.MassOperations.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.
• 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.
• 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.
• 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.
• 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.

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.

The value returned is the artifact identifier of the newly created mass operation.

public async Task CreateCustomPageMassOpAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            // use helper method to find available object types in workspace
            List<DisplayableObjectTypeIdentifier> objectTypes = await massOperationManager.GetAvailableObjectTypeAsync(workspaceID);
            CustomPageMassOperationRequest request = new CustomPageMassOperationRequest()
            {
                Name = "My custom page mass operation",
                ObjectType = objectTypes.Find(ot => ot.Name == "My RDO"),
                OpenInModa = true,
                PopupHeight = 250,
                PopupWidth = 250,
                Url = "www.mycustompage.com"
            };
         
            int massOpID = await massOperationManager.CreateAsync(workspaceID, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

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.

The value returned is the artifact identifier of the newly created mass operation.

public async Task CreateEventHandlerMassOpAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            // Use helper method to find mass operation event handler previously loaded into environment via a resource file.
            List<MassOperationEventHandlerResponse> availableEventHandlers = await massOperationManager.GetAvailableEventHandlersAsync(workspaceID);
            MassOperationEventHandlerResponse eventHandler = availableEventHandlers.Find(eh => eh.ClassName.Contains("MyCustomEventHandler"));
 
            EventHandlerMassOperationRequest request = new EventHandlerMassOperationRequest()
            {
                Name = "My event handler mass operation",
                EventHandlerID = eventHandler.EventHandlerID,
                ObjectType = new DisplayableObjectTypeIdentifier() {Name = "My RDO"}
            };
            int massOpID = await massOperationManager.CreateAsync(workspaceID, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

The following code sample illustrates how to call the ReadAsync() method by passing the Artifact IDs of the workspace and the mass operation.

It returns an object containing information about the specified mass operation.

public async Task ReadMassOperationAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            int massOpID = 1104614;
            MassOperationResponse massOperation = await massOperationManager.ReadMassOperationAsync(workspaceID, massOpID);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

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 massOpID,
      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.

It returns a status code.

public async Task UpdateCustomPageMassOperationAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            int massOpID = 1104615;
            // read existing mass operation
            MassOperationResponse massOperation = await massOperationManager.ReadMassOperationAsync(workspaceID, massOpID);
            // create update request from read response
            CustomPageMassOperationRequest request = new CustomPageMassOperationRequest(massOperation);
            // update property and send request
            request.Name = "Updated name";
            await massOperationManager.UpdateAsync(workspaceID, massOpID, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

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 massOpID,
      EventHandlerMassOperationRequest massOperationRequest
  )

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

  Task UpdateAsync(
      int workspaceID,
      int massOpID,
      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.

It returns a status code.

public async Task UpdateEventHandlerMassOperationAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            int massOpID = 1104614;
            // read existing mass operation
            MassOperationResponse massOperation = await massOperationManager.ReadMassOperationAsync(workspaceID, massOpID);
            // create update request from read response
            EventHandlerMassOperationRequest request = new EventHandlerMassOperationRequest(massOperation);
            // use helper method to find a specific layout
            DisplayableObjectTypeIdentifier objectTypeIdentifier = new DisplayableObjectTypeIdentifier() {Name = "My RDO"};
            List<MassOperationLayoutResponse> layouts = await massOperationManager.GetAvailableLayoutsAsync(workspaceID, objectTypeIdentifier);
            // update mass operation to use this layout
            request.Layout = layouts.Find(layout => layout.Name == "Specific Layout");
            await massOperationManager.UpdateAsync(workspaceID, massOpID, request);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

public async Task DeleteMassOperationAsync()
{
    using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            int workspaceID = 1022092;
            int massOpID = 1104615;
            await massOperationManager.DeleteAsync(workspaceID, massOpID);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            throw;
        }
    }
}

The following code sample illustrates how to call the GetAvailableEventHandlersAsync() method by passing the passing the Artifact ID of the workspace containing the event handlers to retrieve.

public static async Task GetAvailableEventHandlersAsync()
{
    int workspaceId = 1018486;

     using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            List<MassOperationLayoutResponse > response = await massOperationManager.GetAvailableEventHandlersAsync(workspaceId);
            foreach (MassOperationEventHandlerResponse eventHandler in response)
            {
                string info = string.Format("Read event handler {0} with Artifact ID {1}", eventHandler.Name, eventHandler.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}

The following code sample illustrates how to call the GetAvailableLayoutsAsync() by passing the Artifact ID of the workspace containing the layouts to retrieve, and the Artifact ID of the object type associated with the layouts.

Note: The ObjectTypeIdentifier class contains the Artifact ID, Name, and other identifiers for an object.

public static async Task GetAvailableLayoutsAsync()
{
    int workspaceId = 1018486;
    ObjectTypeIdentifier objectType = new ObjectTypeIdentifier{ ArtifactID = 1246375 }

     using (IMassOperationManager massOperationManager = _serviceFactory.CreateProxy<IMassOperationManager>())
    {
        try
        {
            List<MassOperationLayoutResponse > response = await massOperationManager.GetAvailableLayoutsAsync(workspaceId, objectType);
            foreach (MassOperationLayoutResponse layout in response)
            {
                string info = string.Format("Read layout {0} with Artifact ID {1}", eventHandler.Name, eventHandler.ArtifactID);
                Console.Write(info);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
        }
    }
}