RSAPI migration strategy

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Relativity.Services.Objects;
using Relativity.Services.Objects.DataContracts;
using Relativity.Services.ServiceProxy;

namespace Services_API_Samples
{
    class ObjectManagerServiceSamples
    {
        static async void Main()
        {
            ServiceFactory _serviceFactory = GetNewServiceFactory();

            using (IObjectManager objectManager = _serviceFactory.CreateProxy<IObjectManager>())
            {
                await SampleQuery(objectManager, 1234567);
                await SampleMassCreate(objectManager, 1234567);
                await SampleSingleCreate(objectManager, 1234567);
            }
        }
        private static readonly Guid _myObjectGuid = new Guid("5e61283e-34ca-4903-8c04-dfd3553aeaec");
        private static readonly Guid _myNameFieldGuid = new Guid("9427DDDB-1096-4192-8085-302B3268AB22");
        private static readonly Guid _mySampleWholeNumberFieldGuid = new Guid("123e4567-e89b-12d3-a456-426614174000");
        private static readonly Guid _mySampleSingleObjectFieldGuid = new Guid("f684e5f3-250b-4d91-8114-261da7e535d1");
        private static readonly Guid _myDateFieldGuid = new Guid("0D4C634A-20C8-4201-9EDB-587534D00582");

        // Create ObjectTypeRef for the Object Type to target with operations, see "Major Contract Differences"
        static ObjectTypeRef myArtifactType = new ObjectTypeRef { Guid = _myObjectGuid};

        // Create FieldRefs for the fields to utilize, see "Major Contract Differences"
        static FieldRef myNameFieldRef = new FieldRef { Guid = _myNameFieldGuid };
        static FieldRef myWholeNumberFieldRef = new FieldRef { Guid = _mySampleWholeNumberFieldGuid };
        static FieldRef mySingleObjectRef = new FieldRef { Guid = _mySampleSingleObjectFieldGuid };
        static FieldRef myDateFieldRef = new FieldRef { Guid = _myDateFieldGuid };

        // Helper function to return a new Service Factory
        public static ServiceFactory GetNewServiceFactory()
        {
            String restServerAddress = "{my_company_name}/Relativity.Rest/Api";
            string servicesAddress = "{my_company_name}/Relativity.Services";
            Uri keplerUri = new Uri(restServerAddress);
            Uri servicesUri = new Uri(servicesAddress);
            ServiceFactorySettings settings = new ServiceFactorySettings(
                servicesUri, keplerUri, new Relativity.Services.ServiceProxy.UsernamePasswordCredentials("username", "password"));
            Relativity.Services.ServiceProxy.ServiceFactory serviceFactory = new ServiceFactory(settings);
            return serviceFactory;
        }
        public static async Task<bool> SampleQuery(IObjectManager objectManager, int workspaceId)
        {
            //Set up the primary parameters of the search    
            const int indexOfFirstDocumentInResult = 1;
            const int lengthOfResults = 100;
            string condition = "('Name' LIKE 'SampleString' AND 'SampleWholeNumberField' == 4) OR ('UserField' LIKE USER 'Last, First')";
            var sort = new Relativity.Services.Objects.DataContracts.Sort()
            {
                Direction = Relativity.Services.Objects.DataContracts.SortEnum.Descending,
                FieldIdentifier = myNameFieldRef
            };

            // Create a request object
            var queryRequest = new QueryRequest()
            {
                Condition = condition,
                // Use FieldRef objects to identify which fields to return 
                Fields = new List<FieldRef> {
                        myNameFieldRef, myWholeNumberFieldRef, mySingleObjectRef
            },
                ObjectType = myArtifactType,
                Sorts = new List<Relativity.Services.Objects.DataContracts.Sort> { sort }
            };
            // Pass the QueryRequest to the Object Manager in the data access layer
            try
            {
                Relativity.Services.Objects.DataContracts.QueryResult results = await objectManager.QueryAsync(workspaceId, queryRequest, indexOfFirstDocumentInResult, lengthOfResults);
                Console.Write(String.Format("{0} result(s) returned, beginning at index {1}:\n", results.TotalCount.ToString(), results.CurrentStartIndex.ToString()) + String.Concat(results.Objects.Select(o => o.ArtifactID.ToString() + "\n")));
                return true;
            }
            catch (Exception e)
            {
                Console.Write(e);
                return false;
            }
        }
        public static async Task<bool> SampleMassCreate(IObjectManager objectManager, int workspaceId)
        {
            // Instantiate new mass create request 
            MassCreateRequest massCreateRequest = new MassCreateRequest();
            // Specify Object Type to create
            massCreateRequest.ObjectType = myArtifactType;
            // Create list of fields to populate on create 
            List<FieldRef> massCreateRequestFieldList = new List<FieldRef>()
            {
                        myNameFieldRef, myWholeNumberFieldRef, myDateFieldRef
            };
            // Set the values for the new RDOs' fields, the helper function below creates your List 
            List<List<Object>> massCreateRequestValueList = generateMassCreateRequestValueList();
            massCreateRequest.Fields = massCreateRequestFieldList;
            massCreateRequest.ValueLists = massCreateRequestValueList;
            // Pass your massCreateRequest to the Object Manager in the data access layer
            try
            {
                MassCreateResult results = await objectManager.CreateAsync(workspaceId, massCreateRequest);
                Console.Write(results.Message + "\n" + String.Concat(results.Objects.Select(o => o.ArtifactID.ToString() + "\n")));
                return true;
            }
            catch (Exception e)
            {
                Console.Write(e);
                return false;
            }
        }

        public static async Task<bool> SampleSingleCreate(IObjectManager objectManager, int workspaceId)
        {
            // Instantiate Field Values for Create
            var myDateFieldRefValuePair = new FieldRefValuePair
            {
                Field = myDateFieldRef,
                Value = DateTime.Now
            };
            var myNameFieldRefValuePair = new FieldRefValuePair
            {
                Field = myNameFieldRef,
                Value = "Object Name"
            };
            // Instantiate a CreateRequest 
            var createRequest = new CreateRequest();

            // Populate the CreateRequest with Object Type and FieldRefValuePairs
            createRequest.ObjectType = myArtifactType;
            createRequest.FieldValues = new List<FieldRefValuePair> { myDateFieldRefValuePair, myNameFieldRefValuePair };

            // Pass your CreateRequest to the Object Manager in the data access layer
            try
            {
                CreateResult result = await objectManager.CreateAsync(workspaceId, createRequest);
                Console.Write(String.Format("Object successfully created: Artifact ID: {0}",
                result.Object.ArtifactID.ToString()));
            }
            catch (Exception e)
            {
                Console.Write(e);
                return false;
            }
            return true;
        }
        public static List<List<Object>> generateMassCreateRequestValueList()
        {
            //Assign number of RDOs to create 
            int numberOfRdosToCreate = 50;
            // Instantiate Value List
            List<List<Object>> ValueListToReturn = new List<List<Object>> { };
            // Populate each row for passing to the mass create request 
            for (int i = 0; i < numberOfRdosToCreate; i++)
            {
                List<Object> rdoValueList = new List<object> { };
                rdoValueList.Add($"Name {((char)i).ToString()}");
                rdoValueList.Add(i);
                rdoValueList.Add(DateTime.UtcNow);
                //Append list to mass create request value list, note that the order of field values in this list to create is the same as in the massCreateRequestFieldList above
                ValueListToReturn.Add(rdoValueList);
            }
            return ValueListToReturn;
        }
    }
}