private static async Task <GetTaskResponse> GetCaptchaTask(AntiCaptchaKey antiCaptchaKey,
CreateTaskResponse task)
{
try
{
GetTaskRequest request = new GetTaskRequest(antiCaptchaKey.ClientKey, task.TaskId);
string requestJson = JsonConvert.SerializeObject(request);
using (HttpRequestMessage httpRequest =
new HttpRequestMessage(HttpMethod.Post, AntiCaptchaEndpoints.GetTaskUrl))
{
httpRequest.Content = new StringContent(requestJson, Encoding.UTF8, "application/json");
using (HttpResponseMessage httpResponse = await AntiCaptchaGlobals.HttpClient.SendAsync(httpRequest)
)
{
httpResponse.EnsureSuccessStatusCode();
string value = await httpResponse.Content.ReadAsStringAsync();
GetTaskResponse ret = JsonConvert.DeserializeObject <GetTaskResponse>(value);
return(ret);
}
}
}
catch
{
return(null);
}
}
public void GetNotFoundTest()
{
var errorMessage = "user";
var expectedResponse = new GetTaskResponse {
Exception = new ResourceNotFoundException(errorMessage)
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.GetTask(It.IsAny <GetTaskRequest>())).Returns(expectedResponse);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new TaskController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(It.IsAny <HttpRequestMessage>(), expectedResponse))
.Returns(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(expectedResponse.Exception.Message)
});
var response = controller.Get(Guid.NewGuid());
var content = response.Content.ReadAsStringAsync().Result;
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
Assert.AreEqual(errorMessage, content);
mockService.Verify(x => x.GetTask(It.IsAny <GetTaskRequest>()), Times.Once);
}
public static void EnqueueResponse(GetTaskResponse response)
{
if (!Queue.Contains(response))
{
Queue.Enqueue(response);
}
}
public async Task <TaskModel> Get(long id)
{
GetTaskResponse getTaskResponse = await _mediator.Send(new GetTaskRequest()
{
Id = id
});
return(_mapper.Map <TaskModel>(getTaskResponse));
}
public GetTaskResponse GetTask(GetTaskRequest request, UnitOfWork context)
{
var response = new GetTaskResponse
{
Task = context.Tasks.GetItem(request.Id)
};
return(response);
}
public GetTaskResponse GetTask([Microsoft.AspNetCore.Mvc.FromBody] GetTaskRequest message)
{
var task = db.Tasks.FirstOrDefault(x => x.Id == message.Id);
var response = new GetTaskResponse();
response.Text = task.Text;
response.Date = task.Date;
response.IsCompleted = task.IsCompleted;
return(response);
}
/// <summary>
/// Builds a GetTaskResponse object
/// </summary>
public static GetTaskResponse CreateGetTaskResponse(string taskName)
{
GetTaskResponse response = new GetTaskResponse();
SetProperty(response, "StatusCode", HttpStatusCode.OK);
Azure.Batch.Protocol.Entities.Task task = new Azure.Batch.Protocol.Entities.Task();
SetProperty(task, "Name", taskName);
SetProperty(response, "Task", task);
return(response);
}
public HttpResponseMessage GetTask(GetTaskRequest request, int todolistid, int taskid)
{
var response = new GetTaskResponse();
if (_sessionManager.IsActive(request.SessionId))
{
response.Task = _taskManager.GetTask(taskid);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict, response));
}
}
public void GetTest()
{
var testGuid = Guid.NewGuid();
var expected = new GetTaskResponse {
Result = new TaskDTO {
Id = testGuid,
Name = "test",
Time = DateTime.Now,
UserId = Guid.NewGuid(),
UserFirstName = "test",
UserLastName = "test"
}
};
var mockService = new Mock <ITaskService>();
mockService.Setup(x => x.GetTask(It.IsAny <GetTaskRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new TaskController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(controller.Request, expected))
.Returns(controller.Request.CreateResponse(HttpStatusCode.OK, expected.Result));
var response = controller.Get(testGuid);
TaskDTO result;
response.TryGetContentValue(out result);
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(expected.Result.Id, result.Id);
Assert.AreEqual(expected.Result.Name, result.Name);
Assert.AreEqual(expected.Result.Time, result.Time);
Assert.AreEqual(expected.Result.UserId, result.UserId);
Assert.AreEqual(expected.Result.UserFirstName, result.UserFirstName);
Assert.AreEqual(expected.Result.UserLastName, result.UserLastName);
mockService.Verify(x => x.GetTask(It.IsAny <GetTaskRequest>()), Times.Once);
}
public static GetTaskResponse Unmarshall(UnmarshallerContext _ctx)
{
GetTaskResponse getTaskResponse = new GetTaskResponse();
getTaskResponse.HttpResponse = _ctx.HttpResponse;
getTaskResponse.Code = _ctx.StringValue("GetTask.Code");
getTaskResponse.Message = _ctx.StringValue("GetTask.Message");
getTaskResponse.RequestId = _ctx.StringValue("GetTask.RequestId");
GetTaskResponse.GetTask_Data data = new GetTaskResponse.GetTask_Data();
data.CreatedAt = _ctx.StringValue("GetTask.Data.CreatedAt");
data.Id = _ctx.StringValue("GetTask.Data.Id");
data.Status = _ctx.StringValue("GetTask.Data.Status");
data.VideoUrl = _ctx.StringValue("GetTask.Data.VideoUrl");
getTaskResponse.Data = data;
return(getTaskResponse);
}
public GetTaskResponse Get(GetTaskRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
GetTaskResponse response = new GetTaskResponse();
response.Record = _taskItemRepository.GetById(request.Id);
if (response.Record == null)
{
response.Code = ResponseCode.NotFound;
response.Message = "Record not found.";
}
return(response);
}
public void GetBatchTaskTest()
{
// Setup cmdlet to get a Task by name
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.WorkItemName = "workItem";
cmdlet.JobName = "job-0000000001";
cmdlet.Name = "task1";
cmdlet.Filter = null;
// Build a Task instead of querying the service on a GetJob call
YieldInjectionInterceptor interceptor = new YieldInjectionInterceptor((opContext, request) =>
{
if (request is GetTaskRequest)
{
GetTaskResponse response = BatchTestHelpers.CreateGetTaskResponse(cmdlet.Name);
Task <object> task = Task <object> .Factory.StartNew(() => { return(response); });
return(task);
}
return(null);
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
// Setup the cmdlet to write pipeline output to a list that can be examined later
List <PSCloudTask> pipeline = new List <PSCloudTask>();
commandRuntimeMock.Setup(r => r.WriteObject(It.IsAny <PSCloudTask>())).Callback <object>(t => pipeline.Add((PSCloudTask)t));
cmdlet.ExecuteCmdlet();
// Verify that the cmdlet wrote the Task returned from the OM to the pipeline
Assert.Equal(1, pipeline.Count);
Assert.Equal(cmdlet.Name, pipeline[0].Name);
}
protected override void ExpectResponse(GetTaskResponse response)
{
response.ShouldBeValid();
response.Task.Should().NotBeNull();
response.Completed.Should().BeTrue();
var task = response.Task;
task.Node.Should().NotBeNullOrEmpty();
task.Id.Should().BeGreaterThan(0);
task.Type.Should().Be("transport");
task.Action.Should().Be("indices:data/write/reindex");
task.Status.Should().NotBeNull();
task.StartTimeInMilliseconds.Should().BeGreaterThan(0);
task.RunningTimeInNanoseconds.Should().BeGreaterThan(0);
task.Cancellable.Should().BeTrue();
var reindexResponse = response.GetResponse <ReindexOnServerResponse>();
reindexResponse.Should().NotBeNull();
reindexResponse.Took.Should().BeGreaterThan(0);
reindexResponse.Failures.Should().BeEmpty();
}
public GetTaskResponse GetTask(GetTaskRequest request)
{
var response = new GetTaskResponse();
try
{
var task = _taskRepository.FindBy(request.Id);
if (task == null)
{
response.Exception = GetStandardTaskNotFoundException();
}
else
{
response.Result = _taskMapper.ConvertToDTO(task);
}
}
catch (Exception ex)
{
response.Exception = ex;
}
return(response);
}
/// <summary>
/// Builds a GetTaskResponse object
/// </summary>
public static GetTaskResponse CreateGetTaskResponse(string taskName)
{
GetTaskResponse response = new GetTaskResponse();
SetProperty(response, "StatusCode", HttpStatusCode.OK);
Azure.Batch.Protocol.Entities.Task task = new Azure.Batch.Protocol.Entities.Task();
SetProperty(task, "Name", taskName);
SetProperty(response, "Task", task);
return response;
}
