Get started with the Processing API (v0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public async Task<bool> ProcessingCustodianManager_Create_SaveAsync(IHelper helper)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingCustodianManager proxy = helper.GetServicesManager().CreateProxy<IProcessingCustodianManager>(ExecutionIdentity.User))
   {
      try
      {
         //Build the ProcessingCustodian object.
         ProcessingCustodian processingCustodian = new ProcessingCustodian
         {
            ArtifactID = 0, // Indicates a new ProcessingCustodian object.
            DocumentNumberingPrefix = "REL",
            FirstName = "John",
            LastName = "Smith"
         };

         //Create the ProcessingCustodian object. The service returns the Artifact ID of the object.
         int artifactId = await proxy.SaveAsync(processingCustodian, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingCustodianManager_Create_SaveAsync), "Create failed", this.GetType().Name);
         }
      }
      catch (Exception exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingCustodianManager_Create_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public async Task<bool> ProcessingCustodianManager_ReadAsync(IHelper helper, int processingCustodianArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingCustodianManager proxy = helper.GetServicesManager().CreateProxy<IProcessingCustodianManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingCustodian object.
         ProcessingCustodian processingCustodian = await proxy.ReadAsync(processingCustodianArtifactId, WorkspaceId);

         //Display the last and first name of the custodian.
         string fullName = $"{processingCustodian.LastName}, {processingCustodian.FirstName}";
         Logger.LogMessage(LogLevel.Debug, nameof(ProcessingCustodianManager_ReadAsync), fullName, this.GetType().Name);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public async Task<bool> ProcessingCustodianManager_Update_SaveAsync(IHelper helper, int processingCustodianArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user. 
   using (IProcessingCustodianManager proxy = helper.GetServicesManager().CreateProxy<IProcessingCustodianManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingCustodian object.
         ProcessingCustodian processingCustodian = await proxy.ReadAsync(processingCustodianArtifactId, WorkspaceId);

         //Modify the document numbering prefix and first name.
         processingCustodian.DocumentNumberingPrefix = "ECA";
         processingCustodian.FirstName = "Sam";
         processingCustodian.Name = $"{processingCustodian.LastName}, {processingCustodian.FirstName}";

         //Update the ProcessingCustodian object. The service returns the Artifact ID of the object.
         int artifactId = await proxy.SaveAsync(processingCustodian, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingCustodianManager_Update_SaveAsync), "Update failed", this.GetType().Name);
         }
      }
      catch (Exception exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingCustodianManager_Update_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public async Task<bool> ProcessingDataSourceManager_Create_SaveAsync(IHelper helper, int custodianArtifactId, int destinationFolderArtifactId, int timeZoneArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingDataSourceManager proxy = helper.GetServicesManager().CreateProxy<IProcessingDataSourceManager>(ExecutionIdentity.User))
   {
      try
      {
         //Build the processing ProcessingDataSource object.
         ProcessingDataSource processingDataSource = new ProcessingDataSource
         {
            ArtifactID = 0, // Indicates a new ProcessingDataSource object.
            ProcessingSet = new ProcessingSetRef { ArtifactID = ProcessingSetId },
            Custodian = custodianArtifactId,
            DestinationFolder = destinationFolderArtifactId,
            DocumentNumberingPrefix = "REL",
            InputPath = "@Some/Path",
            Name = "Data Source 1",
            OcrLanguages = new[] { OcrLanguage.English },
            Order = 200,
            TimeZone = timeZoneArtifactId,
            StartNumber = 8,
            IsStartNumberVisible = true,
         };

         //Create the ProcessingDataSource object. The service returns the Artifact ID for the object.
         int artifactId = await proxy.SaveAsync(processingDataSource, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingDataSourceManager_Create_SaveAsync), "Create failed", this.GetType().Name);
         }
      }
      catch (ServiceException exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingDataSourceManager_Create_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public async Task<bool> ProcessingDataSourceManager_ReadAsync(IHelper helper, int processingDataSourceArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingDataSourceManager proxy = helper.GetServicesManager().CreateProxy<IProcessingDataSourceManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingSet object.
         ProcessingDataSource processingDataSource = await proxy.ReadAsync(processingDataSourceArtifactId, WorkspaceId);

         //Display the input path.
         Logger.LogMessage(LogLevel.Debug, nameof(ProcessingDataSourceManager_ReadAsync), processingDataSource.InputPath, this.GetType().Name);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public async Task<bool> ProcessingDataSourceManager_Update_SaveAsync(IHelper helper, int processingDataSourceArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingDataSourceManager proxy = helper.GetServicesManager().CreateProxy<IProcessingDataSourceManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingDataSource object.
         ProcessingDataSource processingDataSource = await proxy.ReadAsync(processingDataSourceArtifactId, WorkspaceId);

         //Modify the input path and destination folder.
         processingDataSource.InputPath = "@Some/Other/Path";
         processingDataSource.DestinationFolder = 99; // Artifact Id of the destination folder

         //Update the processing data source object. The service returns the Artifact ID of the object.
         int artifactId = await proxy.SaveAsync(processingDataSource, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingDataSourceManager_Update_SaveAsync), "Update failed", this.GetType().Name);
         }
      }
      catch (ServiceException exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingDataSourceManager_Update_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public async Task<bool> ProcessingSetManager_Create_SaveAsync(IHelper helper, int processingProfileArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingSetManager proxy = helper.GetServicesManager().CreateProxy<IProcessingSetManager>(ExecutionIdentity.User))
   {
      try
      {
         //Build the ProcessingSet object.
         ProcessingSet processingSet = new ProcessingSet
         {
            ArtifactID = 0, // Indicates a new ProcessingSet object.
            EmailNotificationRecipients = new[] { "johnSmith@domain.com", "adamJohnson@domain.com" },
            Name = "Test Set",
            Profile = new ProcessingProfileRef(processingProfileArtifactId)  // The Artifact ID of the processing profile.
         };

         //Create the ProcessingSet object. The service returns the Artifact ID of the object.
         int artifactId = await proxy.SaveAsync(processingSet, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingSetManager_Create_SaveAsync), "Create failed", this.GetType().Name);
         }
      }
      catch (ServiceException exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingSetManager_Create_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public async Task<bool> ProcessingSetManager_ReadAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingSetManager proxy = helper.GetServicesManager().CreateProxy<IProcessingSetManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingSet object.
         ProcessingSet processingSet = await proxy.ReadAsync(processingSetArtifactId, WorkspaceId);

         //Display the Artifact ID of the processing profile.
         string profileId = $"{processingSet.Profile.ArtifactID}";
         Logger.LogMessage(LogLevel.Debug, nameof(ProcessingSetManager_ReadAsync), profileId, this.GetType().Name);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public async Task<bool> ProcessingSetManager_Update_SaveAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

   //Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   //agents, and custom Pages. They are mocked in these samples.
   //This sample code executes under the context of the current user.
   using (IProcessingSetManager proxy = helper.GetServicesManager().CreateProxy<IProcessingSetManager>(ExecutionIdentity.User))
   {
      try
      {
         //Read the ProcessingSet object.
         ProcessingSet processingSet = await proxy.ReadAsync(processingSetArtifactId, WorkspaceId);

         //Modify the list of email recipients list and the name of the processing set.
         processingSet.EmailNotificationRecipients = new[] { "johnSmith@domain.com" };
         processingSet.Name = "Test Set";

         //Update the ProcessingSet object. The service returns the Artifact ID of the object.
         int artifactId = await proxy.SaveAsync(processingSet, WorkspaceId);
         if (artifactId != 0)
         {
            success = true;
         }
         else
         {
            Logger.LogMessage(LogLevel.Error, nameof(ProcessingSetManager_Update_SaveAsync), "Update failed", this.GetType().Name);
         }
      }
      catch (ServiceException exception)
      {
         //The service returns exceptions of type ServiceException.
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingSetManager_Update_SaveAsync), exception.Message, this.GetType().Name);
      }
   }
   return success;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public async Task<ProcessingSetDocumentInfoSummary> ProcessingSetManager_GetDocumentAggregatesAsync(IHelper helper, int workspaceArtifactId)
{
   // Get a connection to the API using the Relativity API Helper classes, available on event handlers,
   // agents, and custom Pages. They are mocked in these samples.
   // This sample code executes under the context of the current user.
   using (IProcessingSetManager proxy = helper.GetServicesManager().CreateProxy<IProcessingSetManager>(ExecutionIdentity.User))
   {
      try
      {
         // Build the GetDocumentAggregatesRequest object.
         GetDocumentAggregatesRequest request = new GetDocumentAggregatesRequest
         {
            Page = 0,
            PageSize = 15,
            SortColumnName = "ProcessingSetName",
            SortDescending = true,
            WorkspaceArtifactId = workspaceArtifactId
         };

         // Submit the request. The service returns information for all 'Completed' and 'Completed with Errors'
         // Processing Sets in the given workspace.
         ProcessingSetDocumentInfoSummary processingSetDocumentInfoSummary = await proxy.GetDocumentAggregates(request);
         return processingSetDocumentInfoSummary;
      }
      catch (ServiceException serviceException)
      {
         Logger.LogMessage(LogLevel.Error, nameof(ProcessingSetManager_GetDocumentAggregatesAsync), serviceException.Message, this.GetType().Name);
         throw;
      }
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public async Task<bool> ProcessingJobManager_InventoryAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

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

         //Submit the job for inventory.
         await proxy.SubmitInventoryJobsAsync(inventoryJob);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public async Task<bool> ProcessingJobManager_DiscoveryAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public async Task<bool> ProcessingJobManager_PublishAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

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

         //Submit the job for discovery.
         await proxy.SubmitPublishJobsAsync(publishJob);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public async Task<bool> ProcessingJobManager_CancelAsync(IHelper helper, int processingSetArtifactId)
{
   bool success = false;

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

         //Submit a job to cancel a processing set.
         await proxy.SubmitCancelJobAsync(cancelJob);

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