public IActionResult InsertSprint(SprintDto SprintDto)
{
SprintRep.InsertSprint(SprintDto);
var ProjectId = SprintDto.ProjectId;
return(RedirectToAction("ShowSprints", "Sprint", new { ProjectId }));
}
public void UpdateAsync_Should_Return_CorrectResponse()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 2,
Name = "Sprint 2",
Description = "Some description",
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 2, 2),
EndDate = new DateTime(2020, 2, 28)
};
var sprints = GetSampleSprints();
mockSprintRepo.Setup(repo => repo.GetByIdAsync(2)).ReturnsAsync(sprints[1]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(sprints);
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.UpdateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.True(result.Result.Success);
}
public void PutAsync_ReturnsOkResult()
{
//Arrange
SprintDto dto = new SprintDto {
Id = 1, ProjectId = 1, Items = null, StartDate = new DateTime(2020, 2, 26), EndDate = new DateTime(2020, 2, 26)
};
_mockSprintBL.Setup(bl => bl.UpdateAsync(dto, new String("NotFound")))
.Returns(Task.FromResult(
new SprintResponse(
new SprintDto
{
Id = 20,
ProjectId = 1,
Items = null,
StartDate = new DateTime(2020, 2, 26),
EndDate = new DateTime(2020, 2, 26)
})
));
//Act
var result = _sprintController.PutAsync(dto).Result;
//Asserrt
Assert.IsType <OkResult>(result);
}
public void UpdateAsync_Should_Return_Error_Response_When_Start_Date_Is_Later_Than_End_Date()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 2,
Name = "Sprint 2",
Description = "Some description",
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 2, 15),
EndDate = new DateTime(2020, 2, 14)
};
var sprints = GetSampleSprints();
mockSprintRepo.Setup(repo => repo.GetByIdAsync(2)).ReturnsAsync(sprints[1]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(sprints);
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.UpdateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.False(result.Result.Success);
Assert.Equal("Sprint end date must be later than start date", result.Result.Message);
}
public void UpdateAsync_Should_Return_Error_Response_When_End_Date_Is_Greater_Than_Start_Date_Of_The_Next_Sprint()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 2,
Name = "Sprint 2",
Description = "Some description",
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 2, 2),
EndDate = new DateTime(2020, 3, 2)
};
var sprints = GetSampleSprints();
mockSprintRepo.Setup(repo => repo.GetByIdAsync(2)).ReturnsAsync(sprints[1]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(sprints);
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.UpdateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.False(result.Result.Success);
Assert.Equal($"Error. Choose dates after {sprints[0].EndDate.Value.ToShortDateString()} and before {sprints[2].StartDate.Value.ToShortDateString()}", result.Result.Message);
}
public void UpdateAsync_Last_Sprint_Should_Return_Error_Response()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 3,
Name = "Sprint 3",
Description = "Some description",
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 3, 1),
EndDate = new DateTime(2020, 4, 1)
};
var sprints = GetSampleSprints();
mockSprintRepo.Setup(repo => repo.GetByIdAsync(3)).ReturnsAsync(sprints[2]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(sprints);
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.UpdateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.False(result.Result.Success);
Assert.Equal($"Error. Choose start date after {sprints[1].EndDate.Value.ToShortDateString()}", result.Result.Message);
}
public int CreateSprint(SprintDto input)
{
var product = new Sprint {
Name = input.Name, Description = input.Description, TenantId = AbpSession.TenantId
};
return(_sprintRepository.InsertAndGetId(product));
}
public async Task <SprintDto> GetByIdAsync(int id)
{
Sprint sprint = await _sprintRepository.GetByIdAsync(id);
SprintDto sprintDTO = _mapper.Map <Sprint, SprintDto>(sprint);
return(sprintDTO);
}
public IActionResult UpdateSprint(int id, [FromBody] SprintDto sprintD)
{
var sprint = converter.ToSprint(sprintD);
sm.UpdateSprint(id, sprint);
sm.UpdateProjectsToSprint(id, sprintD.Projects.Select(x => x.Id).ToList());
return(Ok(sprint));
}
public IActionResult CreateSprint([FromBody] SprintDto sprintD)
{
var sprint = converter.ToSprint(sprintD);
sm.CreateSprint(sprint);
sm.CreateProjectSprintsForSprint(sprint.Id, sprintD.Projects.Select(x => (int)x.Id).ToList());
return(Ok(sprintD));
}
public async Task <IActionResult> GetAsync(int id)
{
SprintDto sprintDTO = await _sprintBl.GetByIdAsync(id, UserId);
if (sprintDTO == null)
{
return(BadRequest("Sprint does not exist"));
}
return(Ok(sprintDTO));
}
public async Task <IActionResult> AddSprintToProject(int projectId, SprintDto sprint)
{
var sprintToAdd = new Sprint
{
DateRange = new DateRange(sprint.Start, sprint.Start.AddDays(sprint.Days))
};
var command = new AddSprintToProjectCommand(projectId, sprintToAdd);
await _publisher.Publish(command);
return(Ok());
}
public void UpdateSprint(SprintDto SprintDto)
{
var Sprint = GetSprint(SprintDto.Id);
Sprint.Title = SprintDto.Title;
Sprint.Description = SprintDto.Description;
Sprint.EndDate = SprintDto.EndDate;
Sprint.StartDate = SprintDto.StartDate;
Sprint.StatusSprint = (SprintStatus)SprintDto.StatusSprintDto;
db.Sprints.Update(Sprint);
db.SaveChanges();
}
public static IEnumerable <JiraWorkLogDto> FilterBySprintDates(this IEnumerable <JiraWorkLogDto> source,
ISprintFilter searchParams,
IEnumerable <SprintDto> sprints)
{
if (!sprints.Any())
{
return(source);
}
SprintDto firstSprint = sprints.OrderBy(x => x.StartDate).First();
return(source.Where(x => x.FilterAfterStartDate(firstSprint)));
}
public Sprint ToSprint(SprintDto sprintD)
{
Sprint sprint = new Sprint()
{
Name = sprintD.Name,
Description = sprintD.Description,
StartDate = sprintD.StartDate,
EndDate = sprintD.EndDate,
Priority = sprintD.Priority,
isDone = sprintD.isDone
};
return sprint;
}
public IHttpActionResult UpdateSprint(int id, SprintDto sprintDto)
{
var sprint = _sprintService.Update(id, sprintDto);
if (sprint == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IActionResult> PostAsync([FromBody] SprintDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
SprintResponse result = await _sprintBl.CreateAsync(dto, UserId);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok());
}
public SprintDto ToSprintDto(Sprint sprint, List<Project> projects = null)
{
SprintDto sprintDto = new SprintDto()
{
Id = sprint.Id,
Name = sprint.Name,
Description = sprint.Description,
StartDate = sprint.StartDate,
EndDate = sprint.EndDate,
Priority = sprint.Priority,
isDone = sprint.isDone,
Percent = GetPercents(sprint.StartDate, sprint.EndDate),
Projects = projects == null ? new List<ProjectDto>() : projects.Select(x => ToProjectDto(x)).ToList()
};
return sprintDto;
}
private SprintDto ConvertToSprintDisplayDto(SprintResult p)
{
var dto = new SprintDto
{
SprintId = p.SprintId,
EndDate = p.EndDate,
StartDate = p.StartDate,
SprintName = p.SprintName,
CompletedStories = p.CompletedStories,
TotalStories = p.TotalStories,
TeamID = p.TeamID,
TeamName = _cacheService.GetProjectTeamName(p.TeamID)
};
return(dto);
}
public void InsertSprint(SprintDto SprintDto)
{
var NewSprint = new Sprint()
{
Title = SprintDto.Title,
Description = SprintDto.Description,
StartDate = SprintDto.StartDate,
EndDate = SprintDto.EndDate,
TeamLeaderId = SprintDto.TeamLeaderId,
ProjectId = SprintDto.ProjectId
};
NewSprint.StatusSprint = (SprintStatus)SprintDto.StatusSprintDto;
db.Sprints.Add(NewSprint);
db.SaveChanges();
}
public void PostAsync_ReturnsBadRequestResultOnError()
{
//Arrange
SprintDto dto = new SprintDto {
Id = 0, Items = null, Name = "Sprint 1", Description = "Wow", ProjectId = 1, StartDate = new DateTime(2020, 2, 26), EndDate = new DateTime(2020, 2, 26)
};
_mockSprintBL.Setup(bl => bl.CreateAsync(dto, new String("NotFound")))
.Returns(Task.FromResult(
new SprintResponse(message: "Cannot add new sprint")));
//Act
var result = _sprintController.PostAsync(dto).Result;
//Asserrt
Assert.IsType <BadRequestObjectResult>(result);
}
public void PostAsync_ReturnsCorrectErrorMessage()
{
//Arrange
SprintDto dto = new SprintDto {
ProjectId = 1, StartDate = new DateTime(2020, 2, 26), EndDate = new DateTime(2020, 2, 26)
};
_mockSprintBL.Setup(bl => bl.CreateAsync(dto, new String("NotFound")))
.Returns(Task.FromResult(
new SprintResponse(message: "Cannot add new sprint")));
//Act
var result = _sprintController.PostAsync(dto).Result;
//Asserrt
Assert.Equal("Cannot add new sprint", (result as BadRequestObjectResult).Value);
}
public void PutAsync_ReturnsBadRequestResult()
{
//Arrange
SprintDto dto = new SprintDto {
Id = 1, ProjectId = 1, Items = null, StartDate = new DateTime(2020, 2, 26), EndDate = new DateTime(2020, 2, 26)
};
_mockSprintBL.Setup(bl => bl.UpdateAsync(dto, new String("NotFound")))
.Returns(Task.FromResult(
new SprintResponse(message: "An error occurred on updating the sprint")));
//Act
var result = _sprintController.PutAsync(dto).Result;
//Asserrt
Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal("An error occurred on updating the sprint", (result as BadRequestObjectResult).Value);
}
/// <summary>
/// Gets sprint by Id from sprint repository.
/// </summary>
/// <param name="id">Id of sprint.</param>
/// <param name="userId">Id of user.</param>
/// <returns>Sprint DTO.</returns>
public async Task <SprintDto> GetByIdAsync(int id, string userId)
{
// Searchs sprint by id
Sprint sprint = await _sprintRepository.GetByIdAsync(id);
// Gets role of user in current project and checks his rights to view sprints
AppUserRole role = await _projectUserRepository.GetRoleOfMember(userId, sprint.ProjectId);
if (!this.CanAccessSprint(role))
{
throw new ForbiddenResponseException("You do not have access");
}
// Maps and returns sprint DTO to controller
SprintDto sprintDTO = _mapper.Map <Sprint, SprintDto>(sprint);
return(sprintDTO);
}
public IActionResult AddSprintToProject(int projectId, SprintDto sprint)
{
var sprintToAdd = new Sprint(Duration.FromDays(sprint.Days))
{
StartDate = sprint.Start
};
var cmd = new AddSprintToProjectCommand(projectId, sprintToAdd);
var ok = _messageBus.Publish <AddSprintToProjectCommand, bool>(cmd);
if (!ok)
{
return(NotFound());
}
_unitOfWork.Commit();
return(Ok());
}
public Sprint Update(int id, SprintDto sprintDto)
{
var sprintFromDb = _unitOfWork.Sprints.Get(id);
if (sprintFromDb == null)
{
return(null);
}
Mapper.Map(sprintDto, sprintFromDb);
Validate(sprintFromDb);
if (_validationDictionary.IsValid)
{
_unitOfWork.Complate();
}
return(sprintFromDb);
}
/// <summary>
/// Validates and maps sprint DTO, calls creating sprint method from sprint repository.
/// </summary>
/// <param name="dto">Sprint DTO.</param>
/// <param name="userId">Id of user</param>
/// <returns>SprintResponse object</returns>
public async Task <SprintResponse> CreateAsync(SprintDto dto, string userId)
{
// Gets role of user in current project and checks his rights to create the sprint
AppUserRole role = await _projectUserRepository.GetRoleOfMember(userId, dto.ProjectId);
if (!this.CanChangeSprint(role))
{
throw new ForbiddenResponseException("Only owner and scrum master can create a sprint");
}
try
{
Sprint sprint = _mapper.Map <SprintDto, Sprint>(dto);
// Checks that sprint end date is greater than sprint start date
if (sprint.EndDate <= sprint.StartDate)
{
return(new SprintResponse("Sprint end date must be later than start date"));
}
// Searchs all sprints of current project and takes last sprint
IEnumerable <Sprint> sprints = await _sprintRepository.GetAllByProjectIdAsync(dto.ProjectId);
Sprint lastSprint = sprints.OrderByDescending(sp => sp.EndDate).FirstOrDefault();
// Checks if new sprint start date is greater than previous sprint end date
if (lastSprint != null && lastSprint.EndDate >= sprint.StartDate)
{
return(new SprintResponse($"Sprint overlaps. Choose start date after {lastSprint.EndDate.Value.ToShortDateString()}"));
}
// Tries to create new sprint in database and returns response to controller
await _sprintRepository.CreateAsync(sprint);
var sprintDTO = _mapper.Map <Sprint, SprintDto>(sprint);
return(new SprintResponse(sprintDTO));
}
catch (Exception)
{
return(new SprintResponse($"An error occurred when saving the sprint"));
}
}
public IActionResult AddSprintToPorject(int projectId, SprintDto sprint)
{
var sprintToAdd = new Sprint()
{
DateRange = new DateRange(sprint.Start.AddDays(sprint.Days))
};
var pr = _db.Projects.Include(p => p.Sprints)
.FirstOrDefault(p => p.Id == projectId);
if (pr == null)
{
return(NotFound());
}
pr.AddSprint(sprintToAdd);
_db.SaveChanges();
return(Ok());
}
public void CreateAsync_Should_Return_Correct_Response_When_Created()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 0,
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 4, 2),
EndDate = new DateTime(2020, 5, 1)
};
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(GetSampleSprints());
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.CreateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.True(result.Result.Success);
}
public void CreateAsync_Should_Return_Error_Response_When_Sprints_Overlaps()
{
// Arrange
SprintDto newSprintDto = new SprintDto
{
Id = 0,
Items = null,
ProjectId = 1,
StartDate = new DateTime(2020, 4, 1),
EndDate = new DateTime(2020, 5, 1)
};
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), 1)).ReturnsAsync(AppUserRole.Owner);
mockSprintRepo.Setup(repo => repo.GetAllByProjectIdAsync(1)).ReturnsAsync(GetSampleSprints());
var sprintBL = new SprintBl(mockSprintRepo.Object, mockMapper, mockProjectUserRepo.Object, mockItemRepo.Object);
// Act
var result = sprintBL.CreateAsync(newSprintDto, It.IsAny <string>());
// Assert
Assert.IsType <SprintResponse>(result.Result);
Assert.False(result.Result.Success);
Assert.Equal($"Sprint overlaps. Choose start date after {GetSampleSprints()[2].EndDate.Value.ToShortDateString()}", result.Result.Message);
}
