Object Manager (REST)

To get started with Postman, complete these steps:

1. Obtain access to a Relativity environment. You need a username and password to make calls to your environment.
2. Install Postman.
3. Import the Postman sample file for the service. For more information, see Working with data files on the Postman web site.
4. Select an endpoint. Update the URL with the domain for your Relativity environment and any other variables.
5. In the Authorization tab, set the Type to Basic Auth, enter your Relativity credentials, and click Update Request.
6. See the following sections on this page for more information on setting required fields for a request.
7. Click Send to make a request.

This sample code illustrates how to perform the following tasks for an update operation:

• Instantiate an HttpClient object for sending requests using the URL for the Object Manager service.
• Set the required headers for the request. For information on setting headers, see HTTP headers.
• Initialize variables with values required for updating a field.
• Set the url variable to the URL for the update operation.
• Set the JSON input required for the update operation.
• Use the PostAsync() method to send a post request.
• Return the results of the request and deserialize it.

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
public async Task<UpdateResult> UpdateExample()
{
    UpdateResult result = null;
    using (HttpClient client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("X-CSRF-Header", "-");
        client.DefaultRequestHeaders.Add("Authorization",
            "Basic " + Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes("test@test.com:SomePassword")));
        client.DefaultRequestHeaders.Add("X-Kepler-Version", "2.0");
        client.BaseAddress = new Uri("https://localhost/Relativity.Rest/api/Relativity.ObjectManager/{versionNumber}/");
 
        var workspaceId = 1016847;
        var objectArtifactID = 1039331;
        var fieldArtifactID = 1039320;
        var valueToUpdate = "New Value";
 
        string inputJSON = $"{{\"request\":{{\"Object\":{\"{artifactId\":{objectArtifactID}}},\"FieldValues\":[{{\"Field\":{{\"ArtifactID\":{fieldArtifactID}}},\"Value\":\"{valueToUpdate}\"}}]}}}}}}";
         
        var url = $"workspace/{workspaceId}/object/update";
        var response = await client.PostAsync(url, new StringContent(inputJSON, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        var content = await response.Content.ReadAsStringAsync();
        result = JsonConvert.DeserializeObject<UpdateResult>(content);
    }
    return result;
}

The body of the request for creating an RDO must contain the following fields:

• request - a request object for the create operation with the required fields set.
• ObjectType - an integer value used as an identifier for an object type supported by Relativity. For example, the Artifact Type ID for a Document object is 10.
• FieldValues - an array of field value pairs, which contain an identifier for the required field, and a value for it. This field contains the following:
  • Field - the Artifact ID, GUID, or name of the required field.
  • Value - a value for the field. The type of field determines the requirements for the value that you can assign to it.
• ParentObject - the Artifact ID of the parent object of the for the new RelativityObject.

  Note: If you do not specify a parent object, Relativity defaults to the System object as the parent.

The response contains the following fields:

• Object - an instance of a RelatvityObject containing the fields and their values that were created.
• ParentObject - the Artifact ID of the parent object of the newly created RelativityObject. If you did not specify a parent object, Relativity defaults to the System object as the parent.
• FieldValues - an array containing FieldValuePair objects.
  • Field - a field associated with a specific value. The Field object contains the following:
    • ArtifactID - a unique identifier for the field, which is represented as an integer.
    • FieldCategory - indicates the specific functionality assigned to a field, such as stores descriptive text, acts as a relational field, represents grouping for batching, and others. For more information, see the FieldCategory enumeration in Relativity.Services.Objects.DataContracts namespace in the Class library reference.
    • FieldType - the type of a Relativity field, such as fixed-length text, date, single object, or others. For more information, see the FieldType enumeration in Relativity.Services.Objects.DataContracts namespace in the Class library reference.
    • Guids - an array of GUIDs used to identify the field.
    • Name - a user-friendly name for the field.
    • ViewFieldID - a unique identifier used to reference a view field.
  • Value - the data assigned to a field, represented as an Object type. It contains the following:
    • ArtifactID - a unique identifier for the object, which is represented as an integer.
    • Guids - an array of GUIDs used to identify the object.
    • Name - a user-friendly name for the object.
• ArtifactID - a unique identifier for the RelativityObject instance, which is represented as an integer.
• Guids - an array of GUIDs used to identify the RelativityObject.
• EventHandlerStatuses - an array of EventHandlerStatus objects if any were executed. Each object contains a Boolean value indicating whether the execution was successful, and a string with a related message.

The request must include the following fields:

• massRequest - a request to create multiple RDOs.
• ParentObject - the parent of the RelativityObject instances that you want to create. It contains an ArtifactID field, which uniquely identifies the parent object.

  Note: If you do not specify a parent object, Relativity defaults to the System object as the parent.

• ObjectType - indicates the type of objects that you want to create. It contains an ArtifactTypeID field, which contains the Artifact ID used to uniquely identify the object type.
• Fields - an array of Artifact IDs for the Field objects that you want set when the new RelativityObject instances are created. It contains an ArtifactID field for each Field object.
• ValueLists - an array of objects that contain the values used to update the fields on the RelativityObject instances. The order of the values corresponds to the order of the Field objects. In addition to the specified values, each object contains an Artifact ID used to identify it.

The response contains the following fields:

• Success - a Boolean value indicating whether the operation completed without any errors.
• Message - explanatory information provided when an error occurs.

• Objects - an array of RelativityObjectRef instances constructed by a mass create operation.
• ArtifactID - the unique identifier for a RelativityObject instance.

The request must contain the following fields unless specifically identified as optional:

• Request - a request object for the read operation with the required fields set.
• Object - represents minimal information needed to identify a RelativityObject. It contains the following:
  • ArtifactID - the unique identifier for the RelativityObject instance, which contains the fields that you want to retrieve.
• Fields - an array of identifiers for the group of fields that you want to read. It contains the following:
  • ArtifactID - a unique identifier for a field, which is represented as an integer. This field is optional if you identify the field by name or GUID.
  • Name - the user-friendly name of the field. This field is optional if you identify the field by Artifact ID or GUID.
  • Guids - a unique identifier for a field. This field is optional if you identify the field by Artifact ID or name.
• ReadOptions - an optional field that may specify the calling context, the behavior and number of characters for long text fields, and other settings. For information, see the ReadOptions class in the Relativity.Services.Objects.DataContracts namespace in the Class library reference.
  • FieldTypesToReturnAsString - a list of object type values which should be returned as strings.
  • LongTextBehavior - indicates whether the default or tokenized behavior is used for long text fields that exceed the maximum number of characters set in the MaxCharactersForLongTextValues property. To avoid inadvertently truncating of long text fields, we recommend setting this property to 1 for tokenized behavior when you are reading or querying on long text fields, and then later performing an update operation on the returned values. You can use the default behavior for other operations, such as displaying data in a grid.
    Note: Before implementing the query operation on a long text field, review the following best practices in Use tokens with long text fields.

The response contains the following fields:

• Message - a string returned by a Pre Load event handler.
• Object - an instance of a RelatvityObject containing fields and their values that were read. It contains the following:
  • ParentObject - contains the Artifact ID of the parent object associated with the RelativityObject specified by the read operation.
    • ArtifactID - a unique identifier for the object, which is represented as an integer.
    • Guid - a unique identifier for the object, which is represented as a GUID.
• Name - the user-friendly name of the RelativityObject.
• FieldValues - an array containing FieldValuePair objects. See Object Manager (.NET). It contains the following:
  • Field - a field associated with a specific value. The Field object includes:
    • ArtifactID - a unique identifier for the field, which is represented as an integer.
    • FieldCategory - indicates the specific functionality assigned to a field, such as stores descriptive text, acts as a relational field, represents grouping for batching, and others. For more information, see the FieldCategory enumeration in Class library reference on the Relativity API reference page.
    • FieldType - the type of a Relativity field, such as fixed-length text, date, single object, or others. For more information, see the FieldType enumeration in Relativity.Services.Objects.DataContracts namespace in the Class library reference.
    • Guids - an array of GUIDs used to identify the field.
    • Name - a user-friendly name for the field.
    • ViewFieldID - a unique identifier used to reference a view field.
  • Value - the data assigned to a field, represented as an Object type. It may contain one or more of the following:
    • ArtifactID - a unique identifier for the object, which is represented as an integer.
    • Guids - an array of GUIDs used to identify the object.
    • Name - a user-friendly name for the object.
• ArtifactID - a unique identifier for the RelativityObject instance, which is represented as an integer.
• Guids - an array of GUIDs used to identify the RelativityObject instance.
• ObjectType - contains information about the type of object returned from the read operation. It contains the following fields:
  • ArtifactID - a unique identifier for the ObjectType instance, which is represented as an integer.
  • Name - a user-friendly name for the object type, such as Document, Field, and others.
  • Guids - an array of GUIDs used to identify the object type.
  • ArtifactTypeID - an integer value used as an identifier for an object type supported by Relativity. For example, the Artifact Type ID for a Document object is 10.
• ObjectVersionToken - the version token of the RelativityObject. You can pass this value to an update request to enable record overwrite protection.

The request must contain the following fields unless specifically identified as optional:

The body of the request for updating field values on a Document object or RDO must contain the following fields:

• request - a request object for the update operation with the required fields set.
• Object - contains an identifier for the object with fields that you want to update. It contains the following:
  • artifactId - a unique identifier for the object, which is represented as an integer.
• FieldValues - an array containing FieldValuePair objects. See Object Manager (.NET). It contains the following:
  • Field - contains an identifier for the field that you want to update.
    • ArtifactID - a unique identifier for the Field object, which is represented as an integer.
  • Value - a value for the field. The type of field determines the requirements for the value that you can assign to it.
• OperationOptions - contains information about how the update operation for this request is being called. It includes the following:
  • UpdateBehavior - indicates whether you want to replace or merge a choice or object. These options are available for only multiple choice and multiple object fields. See the following sample JSON for these fields.
  • CallingContext - information about the web context from which the event handler is being called, such as the originator of the call, the page mode, and the related layout. See Object Manager (.NET).

    Note: You can set the callingContext field to null if your event handlers do not need any context information, but you must include it in the JSON request. Your event handlers must then implement the ICanExecuteWithLimitedContext interface available in the Event Handlers API.

    • Layout - contains an identifier for the layout where the update call originates.
      • ArtifactID - a unique identifier for the layout, which is represented as an integer.

For currency fields, the value may contain commas and two decimal places. Currently, the currency field supports only the culture English (United States).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1039465
            },
            "Value":"5,025.30"
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For date fields, the values must contain dates in the ISO 8601 format listed in the following JSON sample. When you do not explicitly provide an offset, date fields are saved in the database with an offset relative to server location.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1039477
            },
            "Value":"2017-01-22T18:00:00-07:00"
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For decimal fields, the values are rounded to the nearest hundredth of a number. Currently, the decimal field supports only the culture English (United States).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1039489
            },
            "Value":1.05
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

The request must include following fields:

• field - a reference to the field that you want associated with the uploaded file. It contains this field:
  • ArtifactID - the Artifact ID of the field.
• objectRef - a reference to the object that contains the uploaded file. It contains this field:
  • ArtifactID - the Artifact ID of the object.
• fileName - the name of the uploaded file.

1
2
3
4
5
6
7
8
9
{
   "field":{
      "ArtifactID":1098145
   },
   "objectRef":{
      "ArtifactID":1001637
   },
   "fileName":"Sample File"
},

Note: If you need to update a long text field that exceeds the length limits of an HTTP request, use the updatelongtextfromstream endpoint. For more information, see Update a long text field using an input stream.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
    "request": {
        "Object": {
            "artifactId": 1037989
        },
        "FieldValues": [{
            "Field": {
                "ArtifactID": 1039519
            },
            "Value": "Hello World!"
        }]
    },
    "OperationOptions": {
        "CallingContext": {
            "Layout": { "ArtifactID": 1042963 }
        }
    }
}

When you update a child choice field, its ancestors are also updated. The Behavior field indicates whether you are merging or replacing choices as follows:

• Merge - adds the values that you pass into the service to the current values for the choice field.
• Replace - overwrites the current values for the choice field with those that you pass into the service.

If you do not set the Behavior field, the service throws a ValidationException when attempting an update operation.

Note: The update operation for field values on a multiple object works the same way on a multiple choice field.

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
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1039527
            },
            "Value":[
               {
                  "ArtifactID":1068132
               },
               {
                  "ArtifactID":1068137
               }
            ]
         }
      ]
   },
   "OperationOptions":{
      "UpdateBehavior":"Replace",
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

You can either merge or replace multiple objects. The Behavior field indicates whether you are merging or replacing the object field as follows:

• Merge - adds the values that you pass into the service to the current values for the object field.
• Replace - overwrites the current values for the object field with those that you pass into the service.

If you do not set the Behavior field, the service throws a ValidationException when attempting an update operation.

Note: The update operation for field values on a multiple object works the same way on a multiple choice field.

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
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1042109
            },
            "Value":[
               {
                  "ArtifactID":1041033
               },
               {
                  "ArtifactID":1041034
               }
            ]
         }
      ]
   },
   "OperationOptions":{
      "UpdateBehavior":"Replace",
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For a single choice field, the value may be defined by an Artifact ID or GUID. It may also be null.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041044
            },
            "Value":{
               "ArtifactID":1041033
            }
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For a single object field, the value may be defined by an Artifact ID or GUID. It may also be null.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041044
            },
            "Value":{
               "ArtifactID":1041033
            }
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For a whole number field, the value cannot contain decimal places.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041044
            },
            "Value":1
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

For a Yes/No field, the value may be true, false, or null.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
   "request":{
      "Object":{
         "artifactId":1037989
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041044
            },
            "Value":true
         }
      ]
   },
   "OperationOptions":{
      "CallingContext":{
         "Layout":{
            "ArtifactID":1042963
         }
      }
   }
}

The response contains the following fields:

• EventHandlerStatuses - contains information about the execution of event handlers during the update operation. It includes a status and an optional string with a related message.
  • Success - a Boolean value indicating whether the event handler execution was successful.

The request must contain the following fields unless specifically identified as optional:

• updateLongTextFromStreamRequest - a request object for the updating a long text field with a stream. It contains the following fields:
  • Object - a RelativityObjectRef to be updated. It contains the following:
    • ArtifactID - the Artifact ID of an RelativityObjectRef.
  • Field - a field to be updated. The Field object contains the following:
    • ArtifactID - a unique identifier for the Field object, which is represented as an integer.
    • Guid - a GUID used to identify the object.
    • Name - the user-friendly name of the field.
    • ViewFieldID - a unique identifier used to reference a view field.

The request must contain the following fields:

• massRequestByCriteria - a request to update multiple objects, which match the conditions specified in a query.
• ObjectIdentificationCriteria - contains query conditions and other information used to identify the objects to update:
  • ObjectType - contains the Artifact Type ID of an ObjectType. For example, the Artifact Type ID for a Document object is 10.

    Note: For a mass update operation, all the objects must be the same type.

  • Condition - the search criteria used in the query for items to be updated. For more information, see Query for resources.

• FieldValues - an array of field value pairs, which contain an identifier for the required field, and a value for it. This field contains the following:
  • Field - the Artifact ID, GUID, or name of a required field.
  • Value - a value for the field. The type of field determines the requirements for the value that you can assign to it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
   "massRequestByCriteria":{
      "ObjectIdentificationCriteria":{
         "ObjectType":{
            "ArtifactTypeID":1000043
         },
         "Condition":"'ArtifactID' >= 1041396 And 'ArtifactID' < 1041496 "
      },
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041227
            },
            "Value":23
         }
      ]
   }
}

The request must contain the following fields:

• massRequestByObjects - a request to update multiple objects. The request updates the objects based on the identifier that you provide in the Objects field.
• Objects - an array containing the Artifact IDs of Document objects or RDOs for update. The ArtifactID field contains the identifier of an object that you want to update. You can also use GUIDs for this purpose.

  Note: For a mass update operation, all the objects must be the same type.

• FieldValues - an array of field value pairs, which contain an identifier for the required field, and a value for it. This field contains the following:
  • Field - the Artifact ID, GUID, or name of a required field.
  • Value - a value for the field. The type of field determines the requirements for the value that you can assign to it.

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
{
   "massRequestByObjectIdentifiers":{
      "Objects":[
         {
            "ArtifactID":1043610
         },
         {
            "ArtifactID":1043611
         },
         {
            "ArtifactID":1043612
         },
         {
            "ArtifactID":1043613
         },
         {
            "ArtifactID":1043614
         }
      ],
      "FieldValues":[
         {
            "Field":{
               "ArtifactID":1041596
            },
            "Value":"Text field update"
         },
         {
            "Field":{
               "ArtifactID":1041597
            },
            "Value":23
         },
         {
            "Field":{
               "ArtifactID":1041598
            },
            "Value":{
               "ArtifactID":1052345
            }
         }
      ]
   }
}

The request must contain the following fields:

• massRequestPerObjects - a request to update multiple objects. The request updates the objects based on the list of common fields that you identify in the request.
• Fields - an array containing the Artifact IDs of Field objects that you want to update.
• ObjectValues - an array containing the Artifact IDs of objects for updating and the respective values specified in the same order as the Field objects. It contains the following:
  • object - the Artifact ID of an object to update.
  • values - the values to set on the object's fields.

    Note: For a mass update operation, all the objects must be the same type. Make sure that you specify the values in the same order as the Field objects listed in the Fields array.

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
{
   "massRequestPerObjects":{
      "Fields":[
         {
            "ArtifactID":1041596
         },
         {
            "ArtifactID":1041597
         },
         {
            "ArtifactID":1041598
         }
      ],
      "ObjectValues":[
         {
            "object":{
               "ArtifactID":1043610
            },
            "values":[
               "This is Responsive.",
               14,
               {
                  "ArtifactID":1234678
               }
            ]
         },
         {
            "object":{
               "ArtifactID":1043611
            },
            "values":[
               "Witness statement",
               91,
               {
                  "ArtifactID":1234672
               }
            ]
         },
         {
            "object":{
               "ArtifactID":1043612
            },
            "values":[
               "Smoking gun",
               75,
               {
                  "ArtifactID":1234670
               }
            ]
         },
         {
            "object":{
               "ArtifactID":1043613
            },
            "values":[
               "Further review",
               13,
               {
                  "ArtifactID":1234668
               }
            ]
         },
         {
            "object":{
               "ArtifactID":1043614
            },
            "values":[
               "This is Responsive.",
               2,
               {
                  "ArtifactID":1234655
               }
            ]
         }
      ]
   }
}

The response contains the following fields:

• TotalObjectsUpdated - the total number of objects successfully updated.

• Success - a Boolean value indicating whether the operation completed without any errors.
• Message - explanatory information provided when an error occurs.

The following .NET code sample illustrates how to make a call to the dependencylist endpoint. Also ,see Client code sample.

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<List<Relativity.Shared.{versionNumber}.Models.Dependency>> GetDependencies()
{
    List<Relativity.Shared.{versionNumber}.Models.Dependency> result = null;
 
    int workspaceArtifactId = 1234567;
    List<Relativity.ObjectManager.{versionNumber}.Models.RelativityObjectRef> objectsToCheck = new List<Relativity.ObjectManager.{versionNumber}.Models.RelativityObjectRef>
    {
        new Relativity.ObjectManager.{versionNumber}.Models.RelativityObjectRef { ArtifactID = 2345678 },
        new Relativity.ObjectManager.{versionNumber}.Models.RelativityObjectRef { ArtifactID = 3456789 },
        new Relativity.ObjectManager.{versionNumber}.Models.RelativityObjectRef { ArtifactID = 4567890 }
    };
 
    using (HttpClient httpClient = new HttpClient())
    {
        httpClient.BaseAddress = new Uri($"https://localhost/Relativity.Rest/api/Relativity.ObjectManager/{versionNumber}/workspace/{workspaceArtifactId}/object/");
 
        // Set the required headers.
        httpClient.DefaultRequestHeaders.Add("X-CSRF-Header", "-");
        httpClient.DefaultRequestHeaders.Add("Authorization", "Basic c2FtcGxlYWRtaW5AcmVsYXRpdml0eS5yZXN0OlMwbTNwQHNzdzByZA==");
 
        string url = "dependencylist";
 
        var dependencyListRequest = new Relativity.ObjectManager.{versionNumber}.Models.DependencyListByObjectIdentifiersRequest { Objects = objectsToCheck };
        string serializedDependencyListRequestt = Newtonsoft.Json.JsonConvert.SerializeObject(dependencyListRequest);
        string payload = $"{{ \"request\" : {serializedRequest} }}";
 
        result = await httpClient.PostAsJsonAsync(url, payload);
    }
 
    return result;
}

The request must include the following fields:

• request - a request for a list of objects dependent on the specified Document objects or RDOs.
• Objects - an array of objects identified by their Artifact IDs.
• ArtifactID -the Artifact ID of an object.

The response contains the following fields:

• ObjectType - the type of the Relativity object dependent on the object selected for deletion.
  • Secured - indicates whether the current user has permissions to view the setting in the Value field.
  • Value - represents a securable value, which is the object type.
• Action - indicates whether a dependent object is deleted or unlinked when a specific object is deleted.
• Count - indicates the number of objects with a dependency on a specific object selected for deletion.
  • Secured - indicates whether the current user has permission to view the setting in the Value field.
  • Value - represents a securable value, which is the number of dependent objects.
• Connection - indicates whether the object for deletion is a parent, or a field on a single or multiple object field.
  • Secured - indicates whether the current user has permission to view the setting in the Value field.
  • Value - represents a securable value, which is the type of relationship between the objects. For example, the value is Parent when the dependent object is a child, and Field: {field name} when the dependent object is a field on a single or multiple object field.
• HierarchicLevel - indicates the degree of dependency between object types. For example, you might select an object type for deletion that has a child object type. The fields and views associated with the child object type have a dependency with a hierarchical level of 1.

The request must contain the following fields:

• Request - a request object for the delete operation with the required fields set.
• Object - represents minimal information needed to identify a RelativityObject that you want to delete. It contains the following:
  • ArtifactID - the unique identifier for a RelativityObject instance.

The response contains the following fields:

• Report - contains a list of one or more DeleteItems objects.
• DeleteItems - information about the items that were removed. The DeleteItems object includes:
  • ObjectTypeName - identifies the child or associative object that has a dependency on the object selected for deletion.
  • Action - the operation performed to remove the object. Delete is the action for child objects and Unlink is the action for associative objects.
  • Count - the number of items removed.
  • Connection - indicates a relationship to the object selected for deletion, such as parent, child, and associative object.

The JSON request requires the following fields:

• massRequestByCriteria - a request to update multiple objects, which match the specified query conditions.
• ObjectIdentificationCriteria - contains query conditions and other information used to identify the objects to mass delete:
  • ObjectType - contains the Artifact Type ID of an ObjectType. For example, the Artifact Type ID for a Document object is 10.

    Note: For a mass delete operation, all the objects must be the same type.

  • Condition - the search criteria used in the query for items to be deleted.

1
2
3
4
5
6
7
8
9
10
{
   "massRequestByCriteria":{
      "ObjectIdentificationCriteria":{
         "ObjectType":{
            "ArtifactTypeID":1000043
         },
         "Condition":"'ArtifactID' >= 1041396 And 'ArtifactID' < 1041496"
      }
   }
}

The JSON request requires the following fields:

• massRequestByObjectIdentifiers - a request to delete multiple objects, which are specified by their Artifact IDs.

• Objects - an array containing the Artifact IDs of Document objects or RDOs for deletion. The ArtifactID field contains the identifier of an object that you want to delete. You can also use GUIDs for this purpose.

  Note: For a mass delete operation, all the objects must be the same type.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
   "massRequestByObjectIdentifiers":{
      "Objects":[
         {
            "ArtifactID":1042610
         },
         {
            "ArtifactID":1042611
         },
         {
            "ArtifactID":1042612
         },
         {
            "ArtifactID":1042613
         },
         {
            "ArtifactID":1042614
         }
      ]
   }
}

The response contains the following fields:

• Success - a Boolean value indicating whether the operation completed without any errors.
• Message - explanatory information provided when an error occurs.

• Report - contains a list of the DeleteItems objects.
• DeletedItems - see the field descriptions provided in Delete a Document object or RDO.

The request must contain the following fields unless specifically identified as optional:

• Request - a request object for the query operation with the required fields set.
  • ObjectType - contains information about the type of object that you want to query on. You can identify an object type by its name, Artifact ID, or GUID. It may contain any one of the following fields:
    • Guid - a unique identifier for the object type. This field is listed in the sample JSON.
    • Name - the user-friendly name of the object type.
    • ArtifactTypeID - an integer value used as an identifier for an object type supported by Relativity. For example, the Artifact Type ID for a Document object is 10.
  • fields - a collection of fields used like a SELECT statement in an SQL query. For a query request, you can identify fields by name, Artifact ID, or GUID. This field is optional.
    • Guid - a unique identifier for a field.
    • ArtifactID - a unique identifier for the field, which is represented as an integer.

    • Name - a user-friendly name for the field.

    See the following example:

    Copy

    1
    2
    3
    "fields":
    
    {"Name":"*"}

  • condition - the search criteria used in the query. This field is optional.
  • LongTextBehavior - indicates whether the default or tokenized behavior is used for long text fields that exceed the maximum number of characters set in the MaxCharactersForLongTextValues property. To avoid inadvertently truncating of long text fields, we recommend setting this property to 1 for tokenized behavior when you are reading or querying on long text fields, and then later performing an update operation on the returned values. You can use the default behavior for other operations, such as displaying data in a grid.
    Note: Before implementing the query operation on a long text field, review the following best practices in Use tokens with long text fields.
  • sorts - a collection of Sort objects. This field indicates whether the results are sorted in ascending or descending order, and identifies the field used to sort the results by name. This field is optional.
  • QueryHint - set a QueryHint field to optimize the view. For example, you can use the hashjoin setting with the value of true or false, or you can use the waitfor setting with a value, such as waitfor:5. This field is optional.
• start - the one-based index of the first artifact in the result set.
• length - the number of items to return in the query result, starting with index in the start field.
  Note: If you pass in a Length value that is less than or equal to 0, the parameter is set to the PDVDefaultQueryCacheSize instance setting (set to 10,000 by default) for performance reasons. If you need to retrieve a larger result set but do not know the upper bounds of the result set, you can pass in a large integer size as the value for the Length parameter, but be aware that this approach can have significant negative performance impacts, especially when using a very large integer like int.MaxValue. A better approach is to use the InitializeExportAsync, RetrieveNextResultBlockAsync/RetrieveNextBlockAsync, and StreamLongTextAsync sequence of operations to retrieve large result sets.

The information in the response depends on whether you executed the search using the Query or QuerySlim endpoint. It includes information about the number of results returned, the start index in the result set, and the object type that was queried.

The response contains the following fields for Query and QuerySlim endpoints:

• TotalCount - the total number of objects in Relativity that meet the criteria of the query. For example, you may request 100 objects, but 115 objects satisfy the query. The ResultCount is 100, while the TotalCount is 115.
• Objects - an array RelatvityObject containing fields and their values that are returned by the query operation. It contains the following:
  • ParentObject - contains the Artifact ID of the parent object associated with RelativityObject returned by the query operation.
    • ArtifactID - a unique identifier for the object, which is represented as an integer.
  • FieldValues - an array containing FieldValuePair objects. See Object Manager (.NET). It contains the following:
    • Field - a field associated with a specific value. The Field object contains the following:
      • ArtifactID - a unique identifier for the field, which is represented as an integer.
      • FieldCategory - indicates the specific functionality assigned to a field, such as stores descriptive text, acts as a relational field, represents grouping for batching, and others. For more information, see the FieldCategory enumeration in Class library reference on the Relativity API reference page.
      • FieldType - the type of a Relativity field, such as fixed-length text, date, single object, or others. For more information, see the FieldType enumeration in Relativity.Services.Objects.DataContracts namespace in the Class library reference.
      • Guids - an array of GUIDs used to identify the field.
      • Name - a user-friendly name for the field.
      • ViewFieldID - a unique identifier used to reference a view field.
    • Value - the data assigned to a field, represented as an Object type. It contains the following:
      • ArtifactID - a unique identifier for the object, which is represented as an integer.
      • Guids - an array of GUIDs used to identify the object.
      • Name - a user-friendly name for the object.
  • ArtifactID - a unique identifier for the object returned by the query.
  • Guids - an array of GUIDs used to identify the object returned by the query.
• CurrentStartIndex - the index of the first artifact in the result set.
• ResultCount - the number of objects returned by the current query. Also, see the description of TotalCount in this list.
• ObjectType - contains information about the type of object returned from the query operation. It contains the following fields:
  • ArtifactID - a unique identifier for the ObjectType instance, which is represented as an integer.
  • Name - a user-friendly name for the object type, such as Document, Field, and others.
  • Guids - an array of GUIDs used to identify the object type.
  • ArtifactTypeID - an integer value used as an identifier for an object type supported by Relativity. For example, the Artifact Type ID for a Document object is 10.

The request must contain the following fields:

• workspaceID - the Artifact ID of the workspace containing the data to export.
• queryRequest - a query that specifies the data set to export. It includes the following fields:
  • ObjectType - an integer value used as an identifier for an object type supported by Relativity. For example, the Artifact Type ID for a Document object is 10.
  • fields - an array containing the Artifact IDs of the fields for export.
  • condition - the query used to determine the set of objects for export. The maximum length of text to export can be optionally specified inline. For information about constructing queries, see Query for Relativity objects.

    Note: You can use the MaxCharactersForLongTextValues field of the queryRequest object to override the number limit set by the MaximumLongTextSizeForExportInCell instance setting. For more information, see Set up the export job in .NET, and Instance setting descriptions on the Relativity Server 2023 Documentation site.

• start - the zero-based index of a record indicating where to begin the export operation.

The response contains the following fields:

• RunID - a unique identifier for the export job.
• RecordCount - the number of records that were exported.

1
2
3
4
5

{
    "RunID": "60b6d8c2-9475-4fda-80bb-339f4dcad504",
    "RecordCount": 100000
}

The body of the request must include the following fields:

• workspaceID - the Artifact ID of the workspace containing the data to export.
• runID - the unique identifier for the in-progress export job.
• batchSize - the maximum number of results to return in a single call.

The response contains a collection of objects with the following fields:

• ArtifactID - the Artifact ID of an object.
• Values - the text from the fields included in the export job.

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
[
  {
    "ArtifactID": 1048512,
    "Values": [
      "Test CHINA CLEANS UP FISCAL & TAXATION PREFERENTIAL POLICIES from AsiaInfo Services\r\n\r\nBEIJING, Jun 26, 2002 (AsiaPort via COMTEX) -- Chinese government continues theefforts to clean up completely all kinds of fiscal and taxationpreferential policies and fiscal subsidy policies, abolish fiscaland taxation preferential policies for a few enterprises and areas,and abolish fiscal subsidy styles that do not accord with Chinesegovernment' s commitment and the WTO regulations.\r\n\r\nOn the basis of seriously cleaning up fiscal and taxation laws, rules and systems, Chinese government will continue to revise the contents that do not in accordance with Chinese\r\n"
    ]
  },
  {
    "ArtifactID": 1048513,
    "Values": [
      "Sally International affairs\r\nOvertaxed.\r\n\r\nWorkout Chinese rural taxation in the context of government regulation.\r\nSharing and Collaboration Policies within Government Agencies.\r\nCorporate Sector: Surtax\r\n\r\n"
    ]
  },
  {
    "ArtifactID": 1048519,
    "Values": [
      "Are Government Policies More Important Than Taxation in Attracting FDI?\r\n\r\nThis paper attempts to broaden the existing empirical literature on foreign direct investment by incorporating government expenditure policies, such as investment in infrastructure, and institutional factors that may impact business investment, such as corruption, along with other conventional determinants such as taxes, location factors, and agglomeration effects. We do so in an unbalanced panel data setting, where we use fixed effects to control for country specific idiosyncrasies and also year dummies in some specifications. Our data include both developing and developed countries in different regions of the world. The regression results indicate that better infrastructure and lower taxes attract FDI, with weaker evidence suggesting lower corruption also increases FDI. These results are robust and hold after controlling for fixed country effects, common year effects of FDI, and agglomeration effects. The magnitude of the response of FDI to infrastructure changes is similar to that of taxes in elasticity terms. The results add evidence to previous cross-sectional results and emphasize the importance of a range of government policies in addition to taxation in attracting foreign direct investment."
    ]
  },
  {
    "ArtifactID": 1048520,
    "Values": [
      "Foreign Affairs:\r\n\r\nInternational relations (IR) represents the study of foreign affairs and global issues among states within the international system, including the roles of states, inter-governmental organizations (IGOs), non-governmental organizations (NGOs), and multinational corporations (MNCs). It is both an academic and public policy field, and can be either positive or normative as it both seeks to analyze as well as formulate the foreign policy of particular states. It is often considered a branch of political science.\r\n\r\nApart from political science, IR draws upon such diverse fields as economics, history, law, philosophy, geography, sociology, anthropology, psychology, and cultural studies. It involves a diverse range of issues including but not limited to: globalization, state sovereignty, ecological sustainability, nuclear proliferation, nationalism, economic development, terrorism, organized crime, human security, foreign interventionism and human rights.\r\n"
    ]
  }
]

The following JSON response contains the #KCURA99DF2F0FEB88420388879F1282A55760# token instead of the text.

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
[
  {
    "ArtifactID": 1048512,
    "Values": [
      "#KCURA99DF2F0FEB88420388879F1282A55760#"
    ]
  },
  {
    "ArtifactID": 1048513,
    "Values": [
      "#KCURA99DF2F0FEB88420388879F1282A55760#"
    ]
  },
  {
    "ArtifactID": 1048515,
    "Values": [
      "#KCURA99DF2F0FEB88420388879F1282A55760#"
    ]
  },
  {
    "ArtifactID": 1048517,
    "Values": [
      "#KCURA99DF2F0FEB88420388879F1282A55760#"
    ]
  },
  {
    "ArtifactID": 1048518,
    "Values": [
      "#KCURA99DF2F0FEB88420388879F1282A55760#"
    ]
  }
]

The request must contain the following fields:

• runID - the unique identifier for the in-progress export job.
• resultsBlockSize - the maximum number of results to return in one call.

  Note: The actual number of results returned may be less than the maximum number requested.

• exportIndexID - the export block index ID of a batch.

The response contains a collection of objects with the following fields:

• ArtifactID - the Artifact ID of an object.
• Values - the text from the fields included in the export job.

The body of the request must include the following fields:

• workspaceID - the Artifact ID of the workspace containing the object to be retrieved.
• exportObject - a RelativityObjectRef of the document that contains the text to be streamed.
• longTextField - a FieldRef of the long text field that contains the text to be streamed.