/// <summary>
/// Get instance of manager class by passing context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static IPatientManager CreateInstance(CallingContext context)
{
IPatientManager instance = null;
if (context == CallingContext.ContextTypeA)
{
instance = new PatientManager();
}
return(instance);
}
/// <summary>
/// Get instance of DataAccess by passing context
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static IPatientDataAccess CreateInstance(CallingContext context)
{
IPatientDataAccess instance = null;
if (context == CallingContext.ContextTypeA)
{
instance = new PatientDataAccess();
}
return(instance);
}
public int GetGetBinderEquivalenceHash()
{
int hash = CallingContext?.GetHashCode() ?? 0;
hash = HashHelpers.Combine(hash, (int)Flags);
hash = HashHelpers.Combine(hash, Name.GetHashCode());
hash = BinderHelper.AddArgHashes(hash, TypeArguments, _argumentInfo);
return(hash);
}
public static PrivateCallingContext FromContext(CallingContext context)
{
if (context == null)
{
return(null);
}
return(new PrivateCallingContext
{
Layout = new InternalLayoutDef
{
ArtifactId = context.Layout.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);
}
private async Task <ParsedCallingRequest> ProcessRequestAsync()
{
try
{
if (Request.Content == null)
{
Trace.TraceError("No content in the request");
return(CallingContext.GenerateParsedResults(HttpStatusCode.BadRequest));
}
var content = await Request.Content.ReadAsStringAsync().ConfigureAwait(false);
return(CallingContext.GenerateParsedResults(HttpStatusCode.OK, content));
}
catch (Exception e)
{
Trace.TraceError($"Failed to process the notification request, exception: {e}");
return(CallingContext.GenerateParsedResults(HttpStatusCode.InternalServerError, e.ToString()));
}
}
/// <summary>
/// Process the calling request and returns <see cref="ParsedCallingRequest"/>.
/// </summary>
/// <param name="callType"> The type of request.</param>
/// <returns> The parsed request.</returns>
public virtual async Task <ParsedCallingRequest> ProcessRequest(RealTimeMediaCallRequestType callType)
{
ParsedCallingRequest parsedRequest;
switch (callType)
{
case RealTimeMediaCallRequestType.IncomingCall:
case RealTimeMediaCallRequestType.CallingEvent:
case RealTimeMediaCallRequestType.NotificationEvent:
parsedRequest = await ProcessRequestAsync();
break;
default:
parsedRequest = CallingContext.GenerateParsedResults(HttpStatusCode.BadRequest, $"{callType} not accepted");
break;
}
parsedRequest.SkypeChainId = CallingContext.ExtractSkypeChainId(this.Request);
return(parsedRequest);
}
public Task <ObjectCreateResult> CreateAsync(int workspaceId, RelativityObject obj, CallingContext context, CancellationToken token)
{
ObjectTypeValidator.ValidateObjectTypeForCreate(obj);
return(this.CreateInternalAsync(workspaceId, obj, context, token));
}
public static RelativityObjectRestReadPrep PrepareForReadRequst(Interfaces.RelativityObject obj, CallingContext context)
{
var parser = new RestV1Parser();
var ret = new RelativityObjectRestReadPrep();
var fields = obj?.FieldValues?.Where(x => x.Field != null).Select(x => parser.Parse(x.Field)).ToList();
if (!(fields?.Any() ?? false))
{
fields = new List <RField> {
new RField.NameRestField("Artifact Id")
};
}
ret.FieldRefs = fields;
ret.CallingContext = context;
return(ret);
}
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 Task <ObjectUpdateResult> UpdateAsync(int workspaceId, RelativityObject obj, CallingContext context)
{
return(this.UpdateAsync(workspaceId, obj, context, default(CancellationToken)));
}
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 Task <RelativityObject> ReadAsync(int workspaceId, RelativityObject obj, CallingContext context)
{
return(this.ReadAsync(workspaceId, obj, context, default(CancellationToken)));
}
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);
}
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
}));
}
}
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 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.");
}
}
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 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 <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);
}
