public void Update(AssignmentDto item) { using (var ctx = ObjectContextManager <PTrackerEntities> .GetManager("PTrackerEntities")) { var data = (from r in ctx.ObjectContext.Assignments where r.ProjectId == item.ProjectId && r.ResourceId == item.ResourceId select r).FirstOrDefault(); if (data == null) { throw new DataNotFoundException("Assignment"); } if (!data.LastChanged.Matches(item.LastChanged)) { throw new ConcurrencyException("Assignment"); } data.Assigned = item.Assigned; data.RoleId = item.RoleId; var count = ctx.ObjectContext.SaveChanges(); if (count == 0) { throw new UpdateFailureException("Assignment"); } item.LastChanged = data.LastChanged; } }
public async Task <ActionResult> CreateAssignmentAsync([FromBody] AssignmentDto assignment) { AssignmentDto createdAssignment = await _assignmentService.CreateAssignmentAsync(assignment); return(CreatedAtRoute("GetAssignment", new { assignmentId = createdAssignment.Id }, createdAssignment)); }
public async Task <ActionResult <AssignmentDto> > CreateLessonAssignmentAsync( [FromRoute] Guid classroomId, [FromRoute] Guid lessonId, [FromBody] AssignmentDto assignmentDto ) { var user = (ApplicationUser)HttpContext.Items["ApplicationUser"]; Debug.Assert(user != null, nameof(user) + " != null"); try { var classroom = await _classroomService.FindAsync(classroomId); var authorization = await _authorizationService.AuthorizeAsync(User, classroom, "IsInClassroom"); if (!authorization.Succeeded) { return(Forbid()); } var assignment = await _assignmentService.CreateAsync(assignmentDto.ToAssignment()); var lesson = await _lessonService.FindAsync(lessonId); await _lessonService.AddAssignmentAsync(lesson, assignment); return(Ok(assignment.ToDto())); } catch (Exception e) { Console.WriteLine(e); return(BadRequest()); } }
public IHttpActionResult UpdateAssignment(int id, AssignmentDto assignmentDto) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var currUserName = GetUserName(); var assignmentInDb = _context.Assignments.SingleOrDefault(a => a.Id == id); if (assignmentInDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } bool isExist = _context.Assignments .Any(a => a.Name.Equals(assignmentDto.Name) && a.Type.Equals(assignmentDto.Type)); if (isExist) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Can't update,this Assignment Already Exist" }); } var originalId = assignmentInDb.Id; Mapper.Map(assignmentDto, assignmentInDb); assignmentInDb.Id = originalId; _context.SaveChanges(); return(Ok()); }
/// <summary> /// Creates new assignment and informs assignee with email. /// </summary> /// <param name="assignment">Assignment to be added.</param> /// <returns>Created assignment DTO.</returns> public async Task <AssignmentDto> CreateAssignmentAsync(AssignmentDto assignment) { UserProfile assigneeUser = await _unitOfWork.UserProfiles.GetUserProfileByIdAsync(assignment.AssigneeId); if (assigneeUser.AllowEmailNotifications) { ApplicationUser assigneeUserProfile = await _userManager.FindByIdAsync(assigneeUser.Id.ToString()); var recipientAddress = new EmailAddress { Address = assigneeUserProfile.Email, Name = $"{assigneeUser.FirstName} {assigneeUser.LastName}" }; var infoMessage = new EmailMessage { Subject = "New assignment", Content = $"You have been assigned to new task: {assignment.Name}.\n" + "Please visit your Assignments page for detailed information." }; infoMessage.ToAddresses.Add(recipientAddress); await _emailService.Send(infoMessage); } Assignment assignmentToCreate = _mapper.Map <Assignment>(assignment); Assignment createdAssignment = _unitOfWork.Assignments.AddAssignment(assignmentToCreate); await _unitOfWork.SaveAsync(); return(_mapper.Map <AssignmentDto>(createdAssignment)); }
public async Task <IActionResult> Edit(AssignmentDto assignmentDto) { using (var client = new HttpClient()) { if (assignmentDto.Status == "Inactive" || assignmentDto.Status == "Completed") { assignmentDto.WorkerId = null; } var assignmentsUrl = $"{baseUrl}api/assignments/{assignmentDto.AssignmentId}"; var assignmentDtoString = JsonConvert.SerializeObject(assignmentDto); var assignmentsResponse = await client.PutAsync(assignmentsUrl, new StringContent(assignmentDtoString, Encoding.UTF8, "application/json")); if (assignmentsResponse.IsSuccessStatusCode) { assignmentDto = JsonConvert.DeserializeObject <AssignmentDto>( await assignmentsResponse.Content.ReadAsStringAsync()); } else { ModelState.AddModelError(string.Empty, "Update failed"); } return(RedirectToAction("Index", "Projects")); } }
public IHttpActionResult Put(int id, AssignmentDto assignment) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != assignment.AssignmentId) { return(BadRequest()); } try { assignmentRepo.Update(Mapper.Map <Assignment>(assignment)); } catch (DbUpdateConcurrencyException) { if (!AssignmentExists(id)) { return(Content(HttpStatusCode.NotFound, "Item does not exist")); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <object> Assign(AssignmentDto model) { var workItem = await _context.WorkItems .Include(r => r.Report) .Include(u => u.AssignedUser) .FirstOrDefaultAsync(x => x.Id == model.WorkItemId); if (workItem == null) { return(NotFound()); } var submission = await _context.Submissions .Include(s => s.FileSpecification) .FirstOrDefaultAsync(x => x.Id == workItem.Report.SubmissionId); var idemUser = _idemService.GetUser(model.IdentityGuid); var user = _context.Users.FirstOrDefault(x => x.IdentityGuid == model.IdentityGuid) ?? new UserProfile(); Mapper.Map(idemUser, user); submission.Reassign(_currentUserFullName, workItem, user, model.Reason); _context.SaveChanges(); //Send assignment notification WorkEmailer.Send(workItem, submission); return(Ok(model)); }
public async Task <IActionResult> PutAssignment(int id, AssignmentDto assignmentDto) { var assignment = _mapper.Map <Assignment>(assignmentDto); if (id != assignment.AssignmentId) { return(BadRequest()); } _context.Entry(assignment).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AssignmentExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public IActionResult Put([FromRoute] int id, [FromBody] AssignmentDto assignment) { return(new JsonVoidResult { Errors = null, StatusCode = HttpStatusCode.OK, Message = null }); }
public async Task <ActionResult> Put(int id, [FromBody] AssignmentDto value) { if (await service.Update(id, value)) { return(NoContent()); } return(NotFound()); }
public async Task <ActionResult <Assignment> > PostAssignment(AssignmentDto assignmentDto) { var assignment = _mapper.Map <Assignment>(assignmentDto); _context.Assignments.Add(assignment); await _context.SaveChangesAsync(); return(CreatedAtAction("GetAssignment", new { id = assignment.AssignmentId }, assignment)); }
public IHttpActionResult Post(AssignmentDto assignment) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } assignmentRepo.Insert(Mapper.Map <Assignment>(assignment)); return(CreatedAtRoute("AddAssignment", new { id = assignment.AssignmentId }, assignment)); }
public IActionResult Post([FromBody] AssignmentDto assignment) { return(new JsonResult <int> { Errors = null, StatusCode = HttpStatusCode.Created, Data = AssignmentId++, Message = null }); }
public ActionResult <AssignmentDto> createAssignment(AssignmentDto assignmentDto) { var assignmentToCreate = _mapper.Map <Assignment>(assignmentDto); _repository.CreateAssignment(assignmentToCreate); _repository.SaveChanges(); var createdAssignment = _mapper.Map <AssignmentDto>(assignmentToCreate); return(CreatedAtRoute(nameof(findAssignmentById), new { Id = createdAssignment.AssignmentId }, assignmentDto)); }
public async Task <ActionResult <AssignmentDto> > GetAssignmentByIdAsync(Guid assignmentId) { AssignmentDto assignment = await _assignmentService.GetAssignmentByIdAsync(assignmentId); if (assignment == null) { return(NotFound("Could not find assignment with provided ID.")); } return(Ok(assignment)); }
public void GetAssignment_ConstructsQuery_ReturnsResultOfDispatch() { var assignmentId = TestIds.A; var result = new AssignmentDto(); _dispatcherMock.Setup(d => d.QueryAsync(It.Is <GetAssignment>(q => q.Id == assignmentId))).ReturnsAsync(result).Verifiable(); var actionResult = _controller.GetAssignment(assignmentId).GetAwaiter().GetResult(); Assert.AreEqual(actionResult.Value, result); _dispatcherMock.Verify(); }
public void Apply(IReadModelContext context, IDomainEvent <AssignmentAggregate, AssignmentId, AssignmentCreatedEvent> domainEvent) { AggregateId = domainEvent.AggregateIdentity.Value; var e = domainEvent.AggregateEvent; var assignment = new AssignmentDto() { AssignmentId = domainEvent.AggregateIdentity.GetGuid(), InvoiceId = e.InvoiceId, CurrentStatus = Status.Created }; Json = JsonConvert.SerializeObject(assignment); }
public async Task <bool> UpdateAssignmentAsync(AssignmentDto assignment) { if (await _unitOfWork.Assignments.GetAssignmentByIdAsync(assignment.Id.Value) == null) { return(false); } Assignment assignmentToUpdate = _mapper.Map <Assignment>(assignment); _unitOfWork.Assignments.UpdateAssignment(assignmentToUpdate); await _unitOfWork.SaveAsync(); return(true); }
public void Insert(AssignmentDto item) { item.LastChanged = MockDb.GetTimeStamp(); var newItem = new AssignmentData { ProjectId = item.ProjectId, ResourceId = item.ResourceId, Assigned = item.Assigned, RoleId = item.RoleId, LastChanged = item.LastChanged }; MockDb.Assignments.Add(newItem); }
public void Insert(AssignmentDto item) { var newItem = new Assignment { ProjectId = item.ProjectId, ResourceId = item.ResourceId, Assigned = item.Assigned, RoleId = item.RoleId }; db.Assignments.Add(newItem); db.SaveChanges(); item.LastChanged = newItem.LastChanged; }
public async Task <bool> Update(int id, AssignmentDto model) { bool flag = false; var result = await context.Assignments.Where(c => c.IdAssignment == id).ToListAsync(); if (result.Any()) { result.First().Name = model.Name; await context.SaveChangesAsync(); return(flag = true); } return(flag); }
public IHttpActionResult CreateAssignment(AssignmentDto assignmentDto) { var currUserName = GetUserName(); bool isExist = _context.Assignments.Where(a => a.CourseId == assignmentDto.CourseId). Any(a => a.Name.Equals(assignmentDto.Name) && a.Type.Equals(assignmentDto.Type)); if (isExist) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "This Assignment Is Exist ,Please Choose Another Name Or Type." }); } if (!ModelState.IsValid) { return(BadRequest()); } var assignment = Mapper.Map <AssignmentDto, Assignment>(assignmentDto); _context.Assignments.Add(assignment); _context.SaveChanges(); List <Student> courseStudents = _context.CourseEnrolls.Where(c => c.CourseId == assignment.CourseId).Select(c => c.Student).ToList(); foreach (var student in courseStudents) { var grade = new Grade { AssignmentGrade = null, Assignment = assignment, AssignmentId = assignment.Id, LecturerId = currUserName, Student = student, StudentId = student.Id }; _context.Grades.Add(grade); } _context.SaveChanges(); return(Created(new Uri(Request.RequestUri + "/" + assignment.CourseId), assignmentDto)); }
public async Task <ActionResult> UpdateAssignmentAsync(Guid assignmentId, [FromBody] AssignmentDto assignment) { if (assignmentId != assignment.Id) { return(BadRequest("Specified assignment ID is invalid.")); } var result = await _assignmentService.UpdateAssignmentAsync(assignment); if (!result) { return(NotFound("Could not find assignment with provided ID.")); } return(NoContent()); }
public void Insert(AssignmentDto item) { using (var ctx = ObjectContextManager <PTrackerEntities> .GetManager("PTrackerEntities")) { var newItem = new Assignment { ProjectId = item.ProjectId, ResourceId = item.ResourceId, Assigned = item.Assigned, RoleId = item.RoleId }; ctx.ObjectContext.AddToAssignments(newItem); ctx.ObjectContext.SaveChanges(); item.LastChanged = newItem.LastChanged; } }
public async Task <IActionResult> CreateAssignment([FromBody] AssignmentDto assignmentDto) { if (!ModelState.IsValid) { return(BadRequest()); } var assignment = Mapper.Map <AssignmentDto, Assignment>(assignmentDto); assignment.Timestamp = DateTime.Now.ToString(); _context.Assignments.Add(assignment); await _context.SaveChangesAsync(); assignment = await _context.Assignments.FindAsync(assignment.Id); var result = Mapper.Map <Assignment, AssignmentDto>(assignment); return(Ok(result)); }
public async Task UpdateAssignmentAsync_ReturnsBadRequestResponse_WhenPassedInvalidObject() { // Arrange var assignmentToUpdate = new AssignmentDto { Id = Guid.NewGuid(), Name = "Assignment", Status = AssignmentStatus.ToDo, ProjectId = Guid.NewGuid(), AssigneeId = Guid.NewGuid() }; // Act var actionResult = await _assignmentsController.UpdateAssignmentAsync(Guid.NewGuid(), assignmentToUpdate); // Assert Assert.IsInstanceOf(typeof(BadRequestObjectResult), actionResult); }
public async Task <IActionResult> Update(int id, AssignmentDto assignmentDto) { Assignment assignment = await _assignmentService.GetByIdAsync(id, x => x.Subject); if (assignment == null) { return(NotFound()); } if (assignment.TeacherId != _userService.UserId) { return(Forbid()); } _mapper.Map(assignmentDto, assignment); _db.Update(assignment); await _db.SaveChangesAsync(); return(Ok()); }
public void Update(AssignmentDto item) { var data = (from r in MockDb.Assignments where r.ProjectId == item.ProjectId && r.ResourceId == item.ResourceId select r).FirstOrDefault(); if (data == null) { throw new DataNotFoundException("Assignment"); } if (!data.LastChanged.Matches(item.LastChanged)) { throw new ConcurrencyException("Assignment"); } item.LastChanged = MockDb.GetTimeStamp(); data.Assigned = item.Assigned; data.RoleId = item.RoleId; data.LastChanged = item.LastChanged; }
public async Task CreateAssignmentAsync_ReturnsCreatedResponse_WhenPassedValidObject() { // Arrange var assignmentToCreate = new AssignmentDto { Name = "Assignment", Status = AssignmentStatus.ToDo, ProjectId = Guid.NewGuid(), AssigneeId = Guid.NewGuid() }; _stubAssignmentService.Setup(x => x.CreateAssignmentAsync(assignmentToCreate)) .ReturnsAsync(() => { assignmentToCreate.Id = Guid.NewGuid(); return(assignmentToCreate); }); // Act var actionResult = await _assignmentsController.CreateAssignmentAsync(assignmentToCreate); // Assert Assert.IsInstanceOf(typeof(CreatedAtRouteResult), actionResult); }