/// <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); }