public async Task <IActionResult> PutTasksDetails([FromRoute] int id, [FromBody] TasksDetails tasksDetails) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != tasksDetails.id) { return(BadRequest()); } _context.Entry(tasksDetails).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TasksDetailsExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutTaskEntity(int id, TaskEntity taskEntity) { if (id != taskEntity.ID) { return(BadRequest()); } _context.Entry(taskEntity).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TaskEntityExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult> New(TaskItem task) { _tasksContext.Tasks.Add(task); await _tasksContext.SaveChangesAsync(); return(RedirectToAction("Index", await _tasksContext.Tasks.ToListAsync())); }
public async Task <ActionResult <DataAccess.Models.Task> > Update(int userId, int id, PutTaskParam task) { try { if (id != task.Id) { return(BadRequest()); } DataAccess.Models.Task t = await _context.Tasks.FindAsync(task.Id); if (t != null) { t.UserId = userId; t.Description = task.Description; t.State = task.State; _context.Entry(t).State = EntityState.Modified; await _context.SaveChangesAsync(); } else { return(NotFound($"Could not find Task {id}")); } return(Ok(t)); } catch (Exception) { return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure")); } }
public async Task <Itam> AddAsync(Itam i) { await _context.Tasks.AddAsync(i); await _context.SaveChangesAsync(); return(i); }
public async Task <IActionResult> Delete(int id) { var task = await _tasksContext.Tasks.FindAsync(id); _tasksContext.Tasks.Remove(task); await _tasksContext.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); }
public async Task <IActionResult> Create([Bind("Id,Title,Description")] Project project) { if (ModelState.IsValid) { _context.Add(project); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(project)); }
public async Task <IActionResult> Create([Bind("Id,Name,IsDone")] TableTasks tableTasks) { if (ModelState.IsValid) { _context.Add(tableTasks); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(tableTasks)); }
public async Task <IActionResult> Create([Bind("Id,Name,Description")] Models.Task task) { if (ModelState.IsValid) { _context.Add(task); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(task)); }
//Status後で追加 public async Task <IActionResult> Create([Bind("ID,Category,ProjectName,StartDate,CompletionDate,Status,Priority,Comment")] Project project) { if (ModelState.IsValid) { _context.Add(project); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(project)); }
public async ThreadingTasks.Task <IActionResult> Create([Bind("TaskID,TaskTitle")] Task task) { if (ModelState.IsValid) { _context.Add(task); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(task)); }
public async Task <IActionResult> Create([Bind("Id,JavascriptCode")] Tasks tasks) { if (ModelState.IsValid) { tasks.Id = Guid.NewGuid(); _context.Add(tasks); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(tasks)); }
public async Task <IActionResult> Create([Bind("Id,InputParams,Finished,Resoult")] TaskInstance taskInstance) { if (ModelState.IsValid) { taskInstance.Id = Guid.NewGuid(); _context.Add(taskInstance); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(taskInstance)); }
public async Task <IActionResult> Create([Bind("ID,ProjectID,Process,TaskName,Start,End,Status,Progress,Memo")] Thing thing) { if (ModelState.IsValid) { _context.Add(thing); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["ProjectID"] = new SelectList(_context.Projects, "ID", "ProjectName", thing.ProjectID); return(View(thing)); }
public async Task <IActionResult> Create([Bind("Id,Title,Priority,Deadline,IsCompleted,ProjectId")] Models.Task task) { if (ModelState.IsValid) { _context.Add(task); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["ProjectId"] = new SelectList(_context.Projects, "Id", "Title", task.ProjectId); return(View(task)); }
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 async Task Projects_AddNewProject_ShouldOk() { // Create new project var created = new Context.Models.Project { Name = "At work activities", Start = DateTime.Now, Completion = DateTime.Now.AddDays(5), Priority = 1, Status = Context.Models.ProjectStatus.NotStarted }; // Assign as global var _project = created; // Add new project into DB context await _context.Projects.AddAsync(created); // Update DB (InMemory) Assert.DoesNotThrowAsync(async() => await _context.SaveChangesAsync()); // Check that project was created Assert.NotNull(created); // Check that project was added in DB context var projectName = (await _context.Projects.FirstOrDefaultAsync()).Name; Assert.AreEqual(projectName, created.Name); }
public async Task ExecuteAsync(ArchiveProjectRequest request) { //TODO: check if user allowed to archive this project var project = await _context.Projects.FindAsync(request.ProjectId); if (project != null && !project.Archived) { project.Archived = true; await _context.SaveChangesAsync(); } }
public async Task ExecuteAsync(int taskId) { //TODO: use one query instead of two var task = await _context.Tasks.FindAsync(taskId); if (task != null) { await removeTaskWithChildren(task); await _context.SaveChangesAsync(); } }
public async Task <ActionResult <TaskDtoToReturn> > AddTask(TaskDtoForCreate taskDto) { var userId = HttpContext.User?.Claims?.FirstOrDefault(c => c.Type == "userid")?.Value; if (string.IsNullOrEmpty(userId)) { return(StatusCode(StatusCodes.Status400BadRequest, new Response { Status = "Error", Message = "Invalid token" })); } var task = mapper.Map <TaskC>(taskDto); await context.Tasks.AddAsync(task); task.UserId = userId; task.TaskTags = new List <TaskTag>(); if (taskDto.TagIds != null) { foreach (var tagId in taskDto.TagIds) { var tag = await context.Tags.FindAsync(tagId); if (tag == null) { return(StatusCode(StatusCodes.Status400BadRequest, new Response { Status = "Error", Message = "Failed to find tag" })); } if (tag.UserId != userId) { return(StatusCode(StatusCodes.Status400BadRequest, new Response { Status = "Error", Message = "Unauthorized tag id" })); } var taskTag = new TaskTag() { Tag = tag, Task = task }; task.TaskTags.Add(taskTag); } } if (await context.SaveChangesAsync() == 0) { return(StatusCode(StatusCodes.Status400BadRequest, new Response { Status = "Error", Message = "Failed to create task" })); } return(mapper.Map <TaskDtoToReturn>(task)); }
public async Task <ProjectResponse> ExecuteAsync(CreateProjectRequest request, string userId) { var project = new Project { Title = request.Title, Description = request.Description, OwnerId = Guid.Parse(userId) }; await _context.Projects.AddAsync(project); await _context.SaveChangesAsync(); return(new ProjectResponse { Title = project.Title, Description = project.Description, Id = project.Id }); }
public async Task <bool> ExecuteAsync(int projectId) { var project = await _context.Projects.FindAsync(projectId); //TODO: check if user is owner of project before trying to restore it from archive if (project != null) { project.Archived = false; await _context.SaveChangesAsync(); return(true); } else { //project not found return(false); } }
public async Task <ProjectTaskResponse> ExecuteAsync(int taskId, UpdateTaskRequest request) { var foundTask = await _context.Tasks.FindAsync(taskId); if (foundTask != null) { //TODO: check if user is owner of project if (request.DueDate.HasValue) { if (request.DueDate.Value < DateTime.Now) { //throw exception? } foundTask.DueDate = request.DueDate.Value; } if (request.Completed.HasValue) { foundTask.Completed = request.Completed.Value; } if (!string.IsNullOrEmpty(request.Title)) { foundTask.Title = request.Title; } if (request.Priority.HasValue) { foundTask.Priority = (Entities.TaskPriority)request.Priority.Value; } } await _context.SaveChangesAsync(); //TODO: add automapper return(foundTask == null ? null : new ProjectTaskResponse { Title = foundTask.Title, Id = foundTask.Id, DueDate = foundTask.DueDate, Completed = foundTask.Completed, ParentId = foundTask.ParentId, Priority = (TaskPriority)foundTask.Priority }); }
public async Task <ProjectResponse> ExecuteAsync(ImportProjectRequest request, string owner) { var project = new Project { OwnerId = Guid.Parse(owner), Title = request.Title, Tasks = new List <ProjectTask>(), Description = request.Description }; foreach (var t in request.Items) { project.Tasks.Add(buildTree(t, project)); } await _context.Projects.AddAsync(project); await _context.SaveChangesAsync(); return(new ProjectResponse { Title = project.Title, Description = project.Description }); }
public async Task <TodoViewModel> Create(string description) { TodoViewModel result; using (_context) { var todo = _context.Todos.Add(new Todo() { Description = description }); await _context.SaveChangesAsync(); result = new TodoViewModel() { ID = todo.Entity.ID, Description = todo.Entity.Description, Completed = todo.Entity.Completed }; } return(result); }
public async Task <ProjectResponse> ExecuteAsync(UpdateProjectRequest request) { Project foundProject = await _context.Projects.FindAsync(request.Id); //TODO: check if user is owner of project before editing it //TODO: check if project not archived //TODO: add automapper if (foundProject != null) { foundProject.Title = request.Title; foundProject.Description = request.Description; await _context.SaveChangesAsync(); } return(foundProject == null ? null : new ProjectResponse { Title = foundProject.Title, Description = foundProject.Description, Id = foundProject.Id, Archived = foundProject.Archived }); }
public async void Save(ThoughtDto thoughtDto) { using (context) { Thought thought; if (thoughtDto.ThoughtId > 0) { thought = context.Thoughts .SingleOrDefaultAsync(t => t.ThoughtId == thoughtDto.ThoughtId) .Result; thought.Update( thoughtDto.Description, (int)thoughtDto.Timeframe.TimeframeType, thoughtDto.Timeframe.TimeframeDateTime, thoughtDto.Project); try { context.Update <Thought>(thought); await context.SaveChangesAsync(); } catch (Exception e) { Console.WriteLine(e); throw; } } else { thought = Thought.Create(thoughtDto.Description, thoughtDto.SortId, (int)thoughtDto.Timeframe.TimeframeType, thoughtDto.Timeframe.TimeframeDateTime, thoughtDto.Project); context.Thoughts.Add(thought); context.SaveChanges(); } } }
public async virtual Task CreateAsync(TEntity entity) { await _dataset.AddAsync(entity); await _context.SaveChangesAsync(); }
public Task <int> CommitAsync() { return(_context.SaveChangesAsync()); }