public void TODTODocument_FieldTypeIsPassedinValue_ReturnsCorrectValue(string type, kCura.Relativity.Client.FieldType expected)
{
//ARRANGE
var doc = new RelativityObject();
var cGuid = Guid.NewGuid();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(123)
{
FieldType = type
},
Value = new List <ChoiceRef> {
new ChoiceRef("choice name")
}
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.Equal(expected, result.Fields.First().FieldType);
}
public void ToDTODocument_FieldValueIsMultiChoiceSerializedWithName_ResturnsValueAsRelativityChoice()
{
//ARRANGE
var doc = new RelativityObject();
var cGuid = Guid.NewGuid();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(123)
{
FieldType = "MultipleChoice"
},
Value = Newtonsoft.Json.JsonConvert.SerializeObject(new List <ChoiceRef> {
new ChoiceRef("choice name")
})
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.IsType <MultiChoiceFieldValueList>(result.Fields.First().Value);
Assert.Equal("choice name", result.Fields.First().ValueAsMultipleChoice.First().Name);
}
public static async Task UpdateAsync_UpdateSingleObjectByArtifactId_ReturnsSuccess(this IObjectManager manager, IHelper helper, int workspaceId, int docId)
{
//ARRANGE
var fieldGuid = Guid.Parse(DocumentFieldDefinitions.SingleObject);
var client = helper.GetServicesManager().CreateProxy <IRSAPIClient>(Relativity.API.ExecutionIdentity.System);
client.APIOptions.WorkspaceID = workspaceId;
var obj = client.Repositories.RDO.CreateSingle(new RDO
{
ArtifactTypeGuids = new List <Guid> {
Guid.Parse(ObjectTypeGuids.SingleObject)
},
TextIdentifier = Guid.NewGuid().ToString()
});
//ACT
var value = new RelativityObject()
{
ArtifactId = obj
};
var(uResult, result) = await SharedTestCases.RunUpdateTestAsync(manager,
workspaceId,
docId,
new FieldRef(fieldGuid),
value);
//ASSERT
Assert.True(uResult.EventHandlerStatuses.All(x => x.Success));
Assert.Equal(docId, result.ArtifactId);
Assert.Contains(result.FieldValues, (f) => f.Field.Guids.Contains(fieldGuid));
Assert.Equal(obj, result[fieldGuid].ValueAsSingleObject().ArtifactId);
}
public Task <RelativityObject> ReadAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var objectTypeId = this.GetObjectTypeFromObject(workspaceId, obj);
this.CheckObjectTypeSupported(objectTypeId);
using (var client = _helper.GetClient(workspaceId))
{
client.APIOptions.WorkspaceID = workspaceId;
if (objectTypeId == 10)
{
var dto = obj.ToDTODocument();
var result = client.Repositories.Document.Read(dto).EnsureSuccess();
var resultObject = result.First().ToRelativityObject();
return(Task.FromResult(resultObject));
}
else if (objectTypeId >= 1_000_000)
{
obj.ObjectType = new ObjectType(objectTypeId);
var dto = obj.ToRDO();
var result = client.Repositories.RDO.Read(dto).EnsureSuccess();
var resultObject = result.First().ToRelativityObject();
return(Task.FromResult(resultObject));
}
throw new NotSupportedException($"Object Type {objectTypeId} is not supported for Read.");
}
}
public void ToDTODocument_FieldValueIsChoiceRefSerializedWithArtifactId_ResturnsValueAsRelativityChoice()
{
//ARRANGE
var doc = new RelativityObject();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(123)
{
FieldType = "SingleChoice"
},
Value = Newtonsoft.Json.JsonConvert.SerializeObject(new ChoiceRef(456))
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.Equal(123, result.Fields.First().ArtifactID);
Assert.Equal(456, result.Fields.First().ValueAsSingleChoice.ArtifactID);
}
private async Task <ObjectCreateResult> CreateInternalAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectCreateRestPrep.Prep(obj);
var result = await _request.PostAsJsonAsync($"{BASE_PATH}/{workspaceId}/objects/create", new
{
RelativityObject = request,
CallingContext = context
}, token);
var error = await result.EnsureSuccessAsync();
try
{
error.ThrowIfNotNull();
}
catch (EventHandlerFailedException ehfe)
{
return(new ObjectCreateResult(ehfe.Message));
}
var ret = await result.Content.ReadAsAsync <ReadResult>();
return(new ObjectCreateResult
{
Object = ret.RelativityObject.ToCoreModel(),
EventHandlerStatuses = ret.EventHandlerStatuses
});
}
public static RelativityObjectV1 FromCoreModel(RelativityObject obj)
{
var ret = new RelativityObjectV1();
ret.ArtifactId = obj.ArtifactId;
ret.FieldValuePairs = obj.FieldValues.ToList();
return(ret);
}
public static void ValidateObjectTypeForCreate(RelativityObject obj)
{
if (obj.ObjectType == null || obj.ObjectType.ArtifactTypeId == 0)
{
throw new ArgumentException(ObjectManager.Rest.Properties.Messages.Object_Type_Missing);
}
if (obj.ObjectType.ArtifactTypeId == 10)
{
throw new NotSupportedException(ObjectManager.Rest.Properties.Messages.Document_Type_Not_Supported_For_Create);
}
}
public static Document ToDTODocument(this RelativityObject doc)
{
var retDoc = new Document();
if (doc.ArtifactId > 0)
{
retDoc = new Document(doc.ArtifactId);
}
retDoc.Fields = doc.FieldValues.Select(x => ToFieldValue(x)).ToList();
return(retDoc);
}
private async Task <ObjectCreateResult> CreateInternalAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectRestCreatePrep.Prep(obj, context);
var result = await _request.PostAsJsonAsync($"/Relativity.REST/api/Relativity.Objects/workspace/{workspaceId}/object/create", request);
var error = await result.EnsureSuccessAsync();
error.ThrowIfNotNull();
var ret = await result.Content.ReadAsAsync <ObjectCreateResult>();
return(ret);
}
public static RelativityObject ToRelativityObject(this Artifact doc)
{
var obj = new RelativityObject();
obj.ArtifactId = doc.ArtifactID;
if (doc.ArtifactTypeID.HasValue)
{
obj.ObjectType = new Interfaces.ObjectType(doc.ArtifactTypeID.Value);
}
obj.FieldValues = doc.Fields.Select(x => ToFieldPair(x)).ToList();
return(obj);
}
public async Task <RelativityObject> ReadAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectRestReadPrep.PrepareForReadRequst(obj, context);
var result = await _request.PostAsJsonAsync($"{BASE_PATH}/{workspaceId}/objects/{obj.ArtifactId}/read", request, token);
var error = await result.EnsureSuccessAsync();
error.ThrowIfNotNull();
var ret = await result.Content.ReadAsAsync <ReadResult>();
return(ret.RelativityObject.ToCoreModel());
}
public async Task <RelativityObject> ReadAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectRestReadPrep.Prep(obj, context);
var result = await _request.PostAsJsonAsync($"/Relativity.REST/api/Relativity.Objects/workspace/{workspaceId}/object/read", request, token);
var error = await result.EnsureSuccessAsync();
error.ThrowIfNotNull();
var ret = await result.Content.ReadAsAsync <ReadResult>();
return(ret.Object);
}
public void ToDTODocument_ObjectArtifactIdSet_ReturnsArtifactIdSet()
{
//ARRANGE
var doc = new RelativityObject();
doc.ArtifactId = 123;
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.Equal(123, result.ArtifactID);
}
public static RelativityObjectUpdateRestPrep Prep(RelativityObject obj, CallingContext context)
{
var parser = new RestFieldParser();
var ret = new RelativityObjectUpdateRestPrep();
ret.Request = new RestRequest();
ret.Request.Object = new RestObject(obj.ArtifactId);
var fields = obj?.FieldValues?.Where(x => x.Field != null).Select(x => RestField.FromFieldRef(x.Field, x.Value, parser)).ToList();
ret.Request.FieldValues = fields;
ret.OperationOptions = new OperationOptionsRequest {
CallingContext = PrivateCallingContext.FromContext(context)
};
return(ret);
}
public void ParseValue_ValueIsSingleObject_ReturnsCorrectValue()
{
//ARRANGE
var value = new RelativityObject
{
ArtifactId = 123
};
//ACT
var result = _parser.ParseValue(value);
//ASSERT
Assert.IsType <RField.ArtifactIdRestField>(result);
Assert.Equal(123, ((RField.ArtifactIdRestField)result).ArtifactID);
}
public static RDO ToRDO(this RelativityObject obj)
{
var retDoc = new RDO();
if (obj.ArtifactId > 0)
{
retDoc = new RDO(obj.ArtifactId);
}
if (obj.ObjectType == null)
{
throw new ArgumentNullException("Object type property cannot be null.");
}
retDoc.ArtifactTypeID = obj.ObjectType.ArtifactTypeId;
retDoc.Fields = obj.FieldValues.Select(x => ToFieldValue(x)).ToList();
return(retDoc);
}
private async Task <DocProperty> GetDocProperty(int workspaceArtifactID, int documentArtifactID)
{
DocProperty doc = new DocProperty();
const string fileNameFieldName = "File Name";
try
{
using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.System))
{
var fieldsToRead = new List <FieldRef>();
fieldsToRead.Add(new FieldRef()
{
Name = fileNameFieldName
});
var readRequest = new ReadRequest()
{
Object = new RelativityObjectRef {
ArtifactID = documentArtifactID
},
Fields = fieldsToRead
};
RelativityObject document = (await manager.ReadAsync(workspaceArtifactID, readRequest)).Object;
if (document != null)
{
doc.Begdoc = document.Name;
doc.Filename = document.FieldValues.First(f => f.Field.Name == fileNameFieldName).Value.ToString();
string sql = @"
SELECT [Location]
FROM [EDDSDBO].[File]
WHERE [Type] = 0
AND [DocumentArtifactID] = @documentArtifactIDParam" ;
SqlParameter documentArtifactIDParam = new SqlParameter("@documentArtifactIDParam", SqlDbType.Int);
documentArtifactIDParam.Value = documentArtifactID;
doc.Path = Helper.GetDBContext(workspaceArtifactID).ExecuteSqlStatementAsScalar(sql, new SqlParameter[] { documentArtifactIDParam }).ToString() ?? string.Empty;
}
doc.Success = !string.IsNullOrEmpty(doc.Path) && !string.IsNullOrEmpty(doc.Filename);
}
}
catch (Exception ex)
{
LogError(ex);
}
return(doc);
}
public static async Task UpdateAsync_UpdateUserByArtifactId_ReturnsSuccess(this IObjectManager manager, IHelper helper, int workspaceId, int docId, string userName)
{
//ARRANGE
var fieldGuid = Guid.Parse(DocumentFieldDefinitions.User);
var client = helper.GetServicesManager().CreateProxy <IRSAPIClient>(Relativity.API.ExecutionIdentity.System);
client.APIOptions.WorkspaceID = -1;
var q = new Query <Group>();
q.ArtifactTypeID = (int)kCura.Relativity.Client.ArtifactType.Group;
q.Condition = new kCura.Relativity.Client.CompositeCondition(new kCura.Relativity.Client.WholeNumberCondition(GroupFieldNames.GroupType, kCura.Relativity.Client.NumericConditionEnum.EqualTo, 2),
kCura.Relativity.Client.CompositeConditionEnum.And,
new kCura.Relativity.Client.ObjectsCondition(GroupFieldNames.Workspaces, kCura.Relativity.Client.ObjectsConditionEnum.AnyOfThese, new int[] { workspaceId }));
var res = client.Repositories.Group.Query(q);
var userQ = new Query <kCura.Relativity.Client.DTOs.User>();
userQ.Condition = new ObjectsCondition(UserFieldNames.Groups, ObjectsConditionEnum.AnyOfThese, res.Results.Select(x => x.Artifact.ArtifactID).ToList());
var userRes = client.Repositories.User.Query(userQ);
if (userRes.TotalCount < 1)
{
//ideally you'd create a user in this but that's too much for the scope of this work
throw new NotSupportedException("No user to run this test, please create a non system admin and ensure the group is assigned to the workspace.");
}
var userId = userRes.Results.First().Artifact.ArtifactID;
//ACT
var value = new RelativityObject()
{
ArtifactId = userId
};
var(uResult, result) = await SharedTestCases.RunUpdateTestAsync(manager,
workspaceId,
docId,
new FieldRef(fieldGuid),
value);
//ASSERT
Assert.True(uResult.EventHandlerStatuses.All(x => x.Success));
Assert.Equal(docId, result.ArtifactId);
Assert.Contains(result.FieldValues, (f) => f.Field.Guids.Contains(fieldGuid));
Assert.Equal(userId, result[fieldGuid].ValueAsSingleObject().ArtifactId);
}
public async Task <ObjectUpdateResult> UpdateAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectUpdateRestPrep.Prep(obj, context);
var result = await _request.PostAsJsonAsync($"/Relativity.REST/api/Relativity.Objects/workspace/{workspaceId}/object/update", request, token);
var error = await result.EnsureSuccessAsync();
try
{
error.ThrowIfNotNull();
}
catch (EventHandlerFailedException ehfe)
{
return(new ObjectUpdateResult(ehfe.Message));
}
var ret = await result.Content.ReadAsAsync <ObjectUpdateResult>();
return(ret);
}
public void ToDTODocument_FieldValueHasName_ReturnsNameSet()
{
//ARRANGE
var doc = new RelativityObject();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef("field Name")
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.Equal("field Name", result.Fields.First().Name);
}
public void ToDTODocument_FieldValueHasArtifactId_ReturnsArtifactIdSet()
{
//ARRANGE
var doc = new RelativityObject();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(123)
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.Equal(123, result.Fields.First().ArtifactID);
}
public Task <ObjectUpdateResult> UpdateAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var objectTypeId = this.GetObjectTypeFromObject(workspaceId, obj);
this.CheckObjectTypeSupported(objectTypeId);
using (var client = _helper.GetClient(workspaceId))
{
client.APIOptions.WorkspaceID = workspaceId;
if (objectTypeId == 10)
{
var dto = obj.ToDTODocument();
client.Repositories.Document.UpdateSingle(dto);
}
else if (objectTypeId >= 1_000_000)
{
obj.ObjectType = new ObjectType(objectTypeId);
var dto = obj.ToRDO();
client.Repositories.RDO.UpdateSingle(dto);
}
return(Task.FromResult(new ObjectUpdateResult()));
}
}
public void ToDTODocument_FieldValueHasGuid_ReturnsGuidSet()
{
//ARRANGE
var fieldGuid = Guid.NewGuid();
var doc = new RelativityObject();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(fieldGuid)
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.Equal(fieldGuid, result.Fields.First().Guids.Single());
}
public void ToDTODocument_FieldValueIsChoiceWithName_ResturnsValueAsRelativityChoice()
{
//ARRANGE
var doc = new RelativityObject();
var cGuid = Guid.NewGuid();
doc.FieldValues = new List <FieldValuePair>()
{
new FieldValuePair
{
Field = new FieldRef(123),
Value = new ChoiceRef("choice name")
}
};
//ACT
var result = doc.ToDTODocument();
//ASSERT
Assert.NotEmpty(result.Fields);
Assert.NotNull(result.Fields.FirstOrDefault());
Assert.Equal("choice name", result.Fields.First().ValueAsSingleChoice.Name);
}
public async Task <ObjectUpdateResult> UpdateAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var request = RelativityObjectUpdateRestPrep.PrepareForUpdateRequst(obj);
var result = await _request.PostAsJsonAsync($"{BASE_PATH}/{workspaceId}/objects/{obj.ArtifactId}", new
{
RelativityObject = request,
CallingContext = context
}, token);
var error = await result.EnsureSuccessAsync();
try
{
error.ThrowIfNotNull();
}
catch (EventHandlerFailedException ehfe)
{
return(new ObjectUpdateResult(ehfe.Message));
}
var ret = await result.Content.ReadAsAsync <ObjectUpdateResult>();
return(ret);
}
private int GetObjectTypeFromObject(int workspaceId, RelativityObject obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (obj.ObjectType != null && obj.ObjectType.ArtifactTypeId > 0)
{
return(obj.ObjectType.ArtifactTypeId);
}
else if (obj.ArtifactId > 0)
{
var dbContext = _helper.GetDBContext(workspaceId);
var sql = @"SELECT ArtifactTypeId from [EDDSDBO].[Artifact] a with (nolock)
WHERE a.ArtifactID = @aId";
var objectTypeId = dbContext.ExecuteSqlStatementAsScalar <int?>(sql, new[] { new SqlParameter("@aId", obj.ArtifactId) });
if (!objectTypeId.HasValue)
{
throw new NotSupportedException($"Could not find objectType for artifact Id {obj.ArtifactId}");
}
return(objectTypeId.Value);
}
throw new NotSupportedException("Object type cannot be determined on object by either ArtifactId or ObjectType properties, please ensure one of those are loaded");
}
private Task <ObjectCreateResult> CreateInternalAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
var objectTypeId = this.GetObjectTypeFromObject(workspaceId, obj);
this.CheckObjectTypeSupported(objectTypeId);
using (var client = _helper.GetClient(workspaceId))
{
client.APIOptions.WorkspaceID = workspaceId;
if (objectTypeId >= 1_000_000)
{
var dto = obj.ToRDO();
var resultId = client.Repositories.RDO.CreateSingle(dto);
obj.ArtifactId = resultId;
}
else
{
throw new NotSupportedException($"Object Type Id {objectTypeId} is not supported for create.");
}
return(Task.FromResult(new ObjectCreateResult
{
Object = obj
}));
}
}
internal int GetAuditId(RelativityObject obj)
{
return int.Parse(obj.Name);
}
public Task <ObjectUpdateResult> UpdateAsync(int workspaceId, RelativityObject obj, CallingContext context)
{
return(this.UpdateAsync(workspaceId, obj, context, default(CancellationToken)));
}
