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);
}
