public void Should_Fail_On_Wrong_Priority()
{
var validator = new CreateTaskRequestValidator();
var mockRequest = new CreateTaskRequest()
{
Name = new string('*', 8),
Priority = 0,
TargetDate = DateTime.Now.AddDays(1),
AssignTo = new List <Guid>()
{
Guid.NewGuid()
}
};
var result = validator.Validate(mockRequest);
result.IsValid.Should().Be(false);
result.Errors.FirstOrDefault(e => e.ErrorMessage == "Task priority value should be greater than or equal to 1.").Should().NotBeNull();
mockRequest.Priority = 4;
result = validator.Validate(mockRequest);
result.IsValid.Should().Be(false);
result.Errors.FirstOrDefault(e => e.ErrorMessage == "Task priority value should be lesser than or equal to 3.").Should().NotBeNull();
}
public async Task <ProjectTaskResponse> ExecuteAsync(CreateTaskRequest request)
{
var task = new ProjectTask
{
ParentId = request.ParentId,
ProjectId = (int)request.ProjectId, //dirty code
Priority = (Entities.TaskPriority)request.Priority,
Title = request.Title,
DueDate = request.DueDate
};
await _context.Tasks.AddAsync(task);
await _context.SaveChangesAsync();
if (request.ParentId.HasValue)
{
var parent = await _context.Tasks.FindAsync(request.ParentId.Value);
if (parent != null)
{
parent.Childrens.Add(task);
}
}
//TODO: add automapper
return(new ProjectTaskResponse
{
DueDate = task.DueDate,
Id = task.Id,
ParentId = task.ParentId,
Priority = (ViewModels.Tasks.TaskPriority)task.Priority,
Title = task.Title
});
}
public IActionResult CreateTasks(IFormCollection form)
{
string baseUrl = configuration.GetSection("Api").GetSection("apiUrl").Value;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(baseUrl);
var contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Session.GetString("token"));
client.DefaultRequestHeaders.Accept.Add(contentType);
CreateTaskRequest request = new CreateTaskRequest();
request.Name = Convert.ToString(form["name"]);
string stringData = JsonConvert.SerializeObject(request);
var contentData = new StringContent(stringData, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync("/create-task", contentData).Result;
string resposne = response.Content.ReadAsStringAsync().Result;
DataTasksResponse jwt = JsonConvert.DeserializeObject <DataTasksResponse>(resposne);
if (jwt != null && jwt.data.status_code == 200)
{
return(RedirectToAction("TasksList", "Home"));
}
return(View());
}
/// <summary>
/// Tasks / Create Task
/// </summary>
public async Task <CreateTaskResponse> CreateTaskAsync(CreateTaskRequest request)
{
if (request == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(request));
}
if (string.IsNullOrEmpty(request.ProjectId))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(request.ProjectId));
}
if (string.IsNullOrEmpty(request.Name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(request.Name));
}
if (request.Status == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(request.Status));
}
if (request.Position <= 0)
{
throw new ArgumentOutOfRangeException("Value must be positive and non zero.", nameof(request.Position));
}
if (request.DueAt == DateTime.MinValue)
{
throw new ArgumentException("Value cannot unspecified.", nameof(request.DueAt));
}
if (request.Section <= 0)
{
throw new ArgumentOutOfRangeException("Value must be positive and non zero.", nameof(request.Section));
}
return(await ExecuteAsync <CreateTaskResponse>(CreateRequest <CreateTaskRequest>(PROJECTS_PATH, request.ProjectId, TASKS_PATH, request)).ConfigureAwait(false));
}
public ActionResult Post([FromBody] CreateTaskRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
else
{
var itemExists = _taskService.Tasks.Any(i => i.Title == request.TaskTitle && i.TaskListId == request.TaskListId && i.IsDeleted != true);
if (itemExists && IsUserOrTaskListInactive(request.TaskListId))
{
return(BadRequest());
}
Models.Task item = new Models.Task();
item.TaskListId = request.TaskListId;
item.TaskId = Guid.NewGuid().ToString().Replace("-", "");;
item.CreatedOnUtc = DateTime.UtcNow;
item.UpdatedOnUtc = DateTime.UtcNow;
item.Title = request.TaskTitle;
_taskService.AddTask(item);
var tasks = _taskService.Tasks.Where(i => i.TaskListId == request.TaskListId && i.IsDeleted != true).Select(p => new { Title = p.Title }).ToList();
var getTaskList = _taskService.TaskLists.Where(i => i.TaskListId == request.TaskListId).SingleOrDefault();
var user = _taskService.Users.Where(u => u.userId == getTaskList.UserId).SingleOrDefault();
return(Json(new { User = user.EmailAddress, Tasks = tasks, TaskList = getTaskList.Title }));
}
}
public async Task <IHttpActionResult> Post([FromBody] CreateTaskRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
else
{
var itemExists = await _context.Tasks.AnyAsync(i => i.Title == request.TaskTitle && i.TaskListId == request.TaskListId && i.IsDeleted != true);
if (itemExists)
{
return(BadRequest());
}
Models.Task item = new Models.Task();
item.TaskListId = request.TaskListId;
item.TaskId = Guid.NewGuid().ToString().Replace("-", "");;
item.CreatedOnUtc = DateTime.UtcNow;
item.UpdatedOnUtc = DateTime.UtcNow;
item.Title = request.TaskTitle;
_context.Tasks.Add(item);
await _context.SaveChangesAsync();
var tasks = await _context.Tasks.Where(i => i.TaskListId == request.TaskListId && i.IsDeleted != true).Select(p => new { Title = p.Title }).ToListAsync();
var getTaskList = await _context.TaskLists.Where(i => i.TaskListId == request.TaskListId).SingleOrDefaultAsync();
var user = await _context.Users.Where(u => u.UserId == getTaskList.UserId).SingleOrDefaultAsync();
return(Json(new { User = user.EmailAddress, Tasks = tasks, TaskList = getTaskList.Title }));
}
}
public static async Task <Guid> CreateTaskAsync(this HttpClient client, CreateTaskRequest request)
{
return
((await
(await client.PostAsync("api/v1/task/new", request.ToJsonContent()))
.GetJsonAsync <CreateTaskResponse>()).TaskId);
}
public void Create_Task()
{
var employees = new List <Employee>();
var createTest = new CreateTaskRequest
{
Name = "CreateName",
Work = 4,
Status = "TestStatus",
StartDate = DateTime.Parse("5/22/2020 1:01:00 AM"),
EndDate = DateTime.Parse("3/5/2021 1:01:00 AM"),
ProjectId = 1,
Employees = employees
};
var id = _service.CreateTask(createTest, UnitOfWork).Id;
var expected = _service.GetTask(new GetTaskRequest {
Id = id
}, UnitOfWork).Task;
TestUtil.AreEqual(expected, new Task
{
Id = id,
Name = createTest.Name,
StartDate = createTest.StartDate,
EndDate = createTest.EndDate,
ProjectId = createTest.ProjectId,
Status = createTest.Status,
Work = createTest.Work,
Employees = employees
});
}
public async Task <TaskierTask> CreateTaskAsync(CreateTaskRequest task)
{
var model = mapper.Map <TaskSm>(task);
var result = await taskRepo.CreateTaskAsync(model);
return(mapper.Map <TaskierTask>(result));
}
public async Task OneTimeSetUp()
{
var factory = new LocalWebApplicationFactory();
var client = factory.CreateClient();
await AuthenticateAdminAsync(client);
var taskRequest = new CreateTaskRequest
{
Answer = "42",
Question = "Meaning of life",
Weight = 2,
Variants = new List <string> {
"foo", "bar", "42"
}
};
_firstTask = await client.CreateTaskAsync(taskRequest);
_secondTask = await client.CreateTaskAsync(taskRequest);
var quizRequest = new CreateQuizRequest
{
QuizName = QuizName,
Tasks = new List <Guid> {
_firstTask, _secondTask
}
};
_firstQuiz = await client.CreateQuizAsync(quizRequest);
_secondQuiz = await client.CreateQuizAsync(quizRequest);
}
public ActionResult <string> Post(
[FromBody] CreateTaskRequest taskRequest)
{
var taskId = createTaskFunc.Invoke(taskRequest);
return(Created(".", taskId));
}
public async Task <long> Post([FromBody] TaskModel taskModel)
{
CreateTaskRequest createTaskRequest = _mapper.Map <CreateTaskRequest>(taskModel);
long newId = await _mediator.Send(createTaskRequest);
return(newId);
}
public IHttpActionResult CreateTask(CreateTaskRequest request)
{
_mapper.Map(request, _taskRepository.Create());
_taskRepository.SaveChanges();
return(Ok());
}
public void CreateTask(int notepadId, CreateTaskRequest request)
{
_mediator.Send(new AddTaskToNotepadCommand()
{
NotepadId = notepadId,
TaskTitle = request.Title
});
}
public async Task <IActionResult> CreateTaskAsync([FromBody] CreateTaskRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
throw new NotImplementedException();
}
/// <inheritdoc />
/// Create a TASK
public async Task <HttpResponseMessage> CreateTask(CreateTaskRequest req)
{
this.client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Constants.Token);
var jsonToSend = JsonConvert.SerializeObject(req);
var content = new StringContent(jsonToSend, Encoding.UTF8, Constants.Headers.ContentType);
var result = await this.API.CreateTask(Constants.Headers.ContentType, content);
return(result);
}
public bool Validate(CreateTaskRequest requestToValidate)
{
return(string.IsNullOrEmpty(requestToValidate.TaskName) ||
string.IsNullOrEmpty(requestToValidate.Comment) ||
string.IsNullOrEmpty(requestToValidate.NumberOfPeopleNeed.ToString()) ||
string.IsNullOrEmpty(requestToValidate.NumberOfPeopleSignUp.ToString()) ||
string.IsNullOrEmpty(requestToValidate.EventId.ToString())
);
}
public CreateTaskResponse CreateTask(CreateTaskRequest task, UnitOfWork context)
{
var response = new CreateTaskResponse
{
Id = context.Tasks.AddItem(_mapper.Map <Task>(task))
};
return(response);
}
/// <summary>
/// Instructs one or more devices to start a task, such as unlocking or rebooting.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateTask service method.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the CreateTask service method, as returned by SnowDeviceManagement.</returns>
/// <exception cref="Amazon.SnowDeviceManagement.Model.AccessDeniedException">
/// You don't have sufficient access to perform this action.
/// </exception>
/// <exception cref="Amazon.SnowDeviceManagement.Model.InternalServerException">
/// An unexpected error occurred while processing the request.
/// </exception>
/// <exception cref="Amazon.SnowDeviceManagement.Model.ResourceNotFoundException">
/// The request references a resource that doesn't exist.
/// </exception>
/// <exception cref="Amazon.SnowDeviceManagement.Model.ServiceQuotaExceededException">
/// The request would cause a service quota to be exceeded.
/// </exception>
/// <exception cref="Amazon.SnowDeviceManagement.Model.ThrottlingException">
/// The request was denied due to request throttling.
/// </exception>
/// <exception cref="Amazon.SnowDeviceManagement.Model.ValidationException">
/// The input fails to satisfy the constraints specified by an Amazon Web Services service.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/snow-device-management-2021-08-04/CreateTask">REST API Reference for CreateTask Operation</seealso>
public virtual Task <CreateTaskResponse> CreateTaskAsync(CreateTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateTaskRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateTaskResponseUnmarshaller.Instance;
return(InvokeAsync <CreateTaskResponse>(request, options, cancellationToken));
}
internal virtual CreateTaskResponse CreateTask(CreateTaskRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateTaskRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateTaskResponseUnmarshaller.Instance;
return(Invoke <CreateTaskResponse>(request, options));
}
public async Task <IActionResult> Create([FromBody] CreateTaskRequest request)
{
await this.tasksService.Create(
request.Description,
request.Title,
request.Estimate,
request.UserId);
return(this.StatusCode((int)HttpStatusCode.Created));
}
public async Task <IActionResult> Post([FromBody] CreateTaskRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _taskService.CreateTaskAsync(model);
return(Created($"/api/task/{result.Id}", result));
}
public string Invoke(CreateTaskRequest task)
{
var objectId = taskRepository.Insert(new TaskEntity
{
Description = task.Description,
Title = task.Title
});
return(objectId.ToString());
}
public async Task <IActionResult> Post([FromBody] CreateTaskRequest request)
{
var taskId = Guid.NewGuid();
var document = BsonSerializer.Deserialize <BsonDocument>(JsonConvert.SerializeObject(request))
.Set("_id", taskId)
.Set("UserId", UserId);
await _tasks.InsertOneAsync(document);
return(Ok(new { Id = taskId }));
}
public ActionResult AddTasks(CreateTaskRequest createRequest)
{
if (_validator.Validate(createRequest))
{
return(BadRequest(new { error = "please enter all fields" }));
}
var newTask = _repository.AddTask(createRequest.TaskName, createRequest.Comment, createRequest.StartDate, createRequest.StartTime, createRequest.EndTime, createRequest.NumberOfPeopleNeed, createRequest.NumberOfPeopleSignUp, createRequest.EventId);
return(Created($"api/task/{newTask.Id}", newTask));
}
public async Task <IActionResult> Create([FromBody] CreateTaskRequest resource, CancellationToken cancellationToken)
{
if (resource == null)
{
return(BadRequest());
}
await _taskService.AddAsync(resource, cancellationToken);
return(Ok(resource));
}
public IActionResult UpdateTaskAdmin([FromBody] CreateTaskRequest request)
{
var task = _taskLogic.AssignTask(request);
if (task)
{
return(Ok());
}
return(NotFound());
}
public IActionResult CreateTask([FromBody] CreateTaskRequest request)
{
var task = _taskLogic.CreateTask(request);
if (task == true)
{
return(Ok());
}
return(NotFound());
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskRequest request, [FromServices] ICreateTaskCommand command, Guid id = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TaskResponse response = await command.ExecuteAsync(request);
return(CreatedAtAction(nameof(CreateTask), response.Id, response));
}
public IActionResult CreateTask([FromBody] CreateTaskRequest request)
{
request.UserName = "******";
try
{
TaskAPI.CreateTask($"http://{Request.Host}", request);
return(Ok(request));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
