/// <summary> /// Sends content back to the caller. /// </summary> /// <param name="response"></param> /// <param name="content"></param> /// <param name="mimeType"></param> private static void SendContent(PipelineResponse response, byte[] content, string mimeType) { response.ContentType = mimeType; response.StatusCode = (int)HttpStatusCode.OK; response.ContentLength = content.Length; response.Body.Write(content, 0, content.Length); }
public Task <PipelineResponse <CreateModelRetriever.Response> > Retrieve(ModelRequest input) { // var response = PipelineResponse<CreateModelPipeline.Response, string>.Fail("error-response"); var response = PipelineResponse.Ok <CreateModelRetriever.Response>(new CreateModelRetriever.Response("new-model-id")); return(Task.FromResult(response)); }
/// <summary> /// Creates a new object. /// </summary> public MockOwinEnvironment() { Request = new PipelineRequest(Environment); Response = new PipelineResponse(Environment); AddRequiredFields(); }
public void PipelineResponse_Constructor_Initialises_To_Known_State() { Assert.AreSame(_Environment, _Response.Environment); var defaultCtor = new PipelineResponse(); Assert.IsNotNull(defaultCtor.Environment); }
public Task <PipelineResponse <ModelResponse> > Retrieve(ModelRequest input) { _times++; return(Task.FromResult(PipelineResponse.Ok(new ModelResponse { Name = _times.ToString() }))); }
public Task <PipelineResponse <ModelResponse> > Retrieve(BodyRequest input) { var response = new ModelResponse { Name = $"Id = {input.Id}, Body = {input.Body}", }; return(Task.FromResult(PipelineResponse.Ok(response))); }
public async Task <PipelineResponse <TOut> > Run(Func <Task <PipelineResponse <TOut> > > func) { try { return(await func()); } catch (System.Exception ex) { return(PipelineResponse.Fail <TOut>(ex, "Unhandled exception")); } }
public PipelineEventArgs(Job job, PipelineEvents events, List <string> moduleCollection, HttpClient httpClient, IModel rabbitChannel) { Job = job; Events = events; ModuleCollection = moduleCollection; HttpClient = httpClient; RabbitChannel = rabbitChannel; Response = string.Empty; PipelineResponse = PipelineResponse.Ignore; Transition = Transition.New; }
public static async Task ParseResponse(HttpContext context, PipelineResponse <ModelResponse> response) { if (response.Success) { context.Response.StatusCode = (int)HttpStatusCode.OK; await context.Response.WriteAsync(response.Result.Name); } else { context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; } }
public async Task <PipelineResponse <ModelResponse> > Retrieve(ModelRequest input) { try { var response = await _dbThing.GetModel(input); return(PipelineResponse.Ok <ModelResponse>(response)); } catch (Exception ex) { return(PipelineResponse.Fail <ModelResponse>(ex, "Unhandled exception")); } }
public static async Task ParseResponse(HttpContext context, PipelineResponse <ModelResponse> response) { if (response.Success) { context.Response.StatusCode = (int)HttpStatusCode.OK; await context.Response.WriteAsync(response.Result.Name); } else { context.Response.StatusCode = (int)HttpStatusCode.BadRequest; await context.Response.WriteAsync(response.Error.ErrorMessage); } }
public static Task ParseCreateModelResponse(HttpContext context, PipelineResponse <CreateModelRetriever.Response> response) { if (response.Success) { context.Response.StatusCode = (int)HttpStatusCode.OK; context.Response.WriteAsync(response.Result.Id); } else { context.Response.StatusCode = (int)HttpStatusCode.BadRequest; context.Response.WriteAsync(response.Error.ErrorMessage); } return(Task.CompletedTask); }
public async Task Pipeline() { //Arrange var sut = GetSut(); var expectedResult = new PipelineResponse { Result = " Pipeline behaviour start PipelinePreProcessor AnotherPipelinePreProcessor HANDLER PipelinePostProcessor AnotherPipelinePostProcessor Pipeline behaviour end", Success = true }; //Act var result = await sut.Send(new PipelineRequest { Name = "" }); //Assert Assert.That(result.Success, Is.EqualTo(expectedResult.Success)); Assert.That(result.Result, Is.EqualTo(expectedResult.Result)); }
public static async Task SetGetUserResponse(HttpContext context, PipelineResponse <GetUserResponse> response) { if (response.Success) { await context.Response.WriteAsJsonAsync(response.Result); } else { if (response.Error.ErrorMessage == GetUserInteractor.ErrorsNoUser) { context.Response.StatusCode = (int)HttpStatusCode.NotFound; await context.Response.WriteAsync(response.Error.ErrorMessage); } else { context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; await context.Response.WriteAsync(response.Error.ErrorMessage); } } }
/// <summary> /// Executes pipeline handler collection one-by-one. /// </summary> /// <param name="turnContext"></param> /// <param name="requestState"></param> /// <returns></returns> public async Task <PipelineResponse> Execute(ITurnContext turnContext, RequestState requestState) { var res = new PipelineResponse(); foreach (var handler in Pipeline) { try { res.Result = await handler.Execute(turnContext, requestState); } catch (Exception e) { logger.Error(e); res.Result = ResponseType.Error; } res.Count++; if (res.Result != ResponseType.Continue) { break; } } return(res); }
internal static Task SetFromModelResponse(HttpContext arg1, PipelineResponse <ModelResponse> arg2) { throw new NotImplementedException(); }
public async Task <PipelineResponse <List <ModelResponse> > > Retrieve() { var result = await _dbThing.GetAll(); return(PipelineResponse.Ok(result)); }
public async Task <PipelineResponse <ModelResponse> > Retrieve(ModelRequest input) { var result = await _dbThing.GetModel(input); return(PipelineResponse.Ok(result)); }
/// <summary> /// Creates a new object. /// </summary> /// <param name="pipelineResponse"></param> public Response(PipelineResponse pipelineResponse) { _Response = pipelineResponse; }
public async Task <PipelineResponse <TOut> > Retrieve(TIn input) { var result = await _retriever(input); return(PipelineResponse.Ok(result)); }
public async Task <PipelineResponse <CreateUserResponse> > Retrieve(CreateUserRequest request) { var id = await _database.Create(request.Name); return(PipelineResponse.Ok(new CreateUserResponse(id))); }
public void TestInitialise() { _Environment = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); _Response = new PipelineResponse(_Environment); _Environment["owin.ResponseHeaders"] = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase); }