public async Task <IActionResult> Update([FromRoute] string id, [FromBody] ProjectCreateDto dto)
{
if (!dto.IsValid())
{
return(BadRequest(new { message = "Invalid information" }));
}
var userId = User.GetUserId();
var project = await _repo.GetProject(id, userId);
if (project == null)
{
return(NotFound("Project not found."));
}
project.Name = dto.Name;
project.Description = dto.Description;
project.StartDate = dto.StartDate;
project.EndDate = dto.EndDate;
if (await _repo.SaveAll())
{
return(Ok(new
{
project.Name,
project.Description,
project.StartDate,
project.EndDate
}));
}
return(BadRequest());
}
public async Task Should_Create_With_Minimum_Fields_Defined()
{
// Arrange
var createDto = new ProjectCreateDto
{
Title = "New Project",
ShortTitle = "Shorty",
Code = "123XYZ,",
};
var expectedDto = new ProjectDto
{
Title = createDto.Title,
ShortTitle = createDto.ShortTitle,
Code = createDto.Code,
IsCompleted = false,
CreatedBy = _staff.DisplayName,
CreatedAt = FakeDateTime.UtcNow
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.Created);
ProjectDto result = await DeserializeResponseMessageAsync <ProjectDto>(responseMessage);
result.Should().BeEquivalentTo(expectedDto, opt => opt.Excluding(r => r.Id));
result.Id.Should().NotBeEmpty();
responseMessage.Headers.Location.AbsolutePath.Should().Be($"/{ApiEndpoints.ProjectsController.Get(result.Id)}");
}
public async Task <ActionResult <CommonResponse <ProjectDto> > > PostProject(ProjectCreateDto project)
{
CommonResponse <ProjectDto> response = new CommonResponse <ProjectDto>();
if (!ModelState.IsValid)
{
response.Error = new Error
{
Status = 400,
Message = "Did not pass validation, ensure it is in the correct format."
};
return(BadRequest(response));
}
Project projectModel = _mapper.Map <Project>(project);
try
{
_context.Projects.Add(projectModel);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
response.Error = new Error {
Status = 500, Message = e.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, response));
}
// Map to projectDto
response.Data = _mapper.Map <ProjectDto>(projectModel);
return(CreatedAtAction("GetProjectInProjectView", new { id = response.Data.Id }, response));
}
public async Task <IActionResult> CreateProject(ProjectCreateDto project)
{
var user = HttpContext.Items["User"] as UserLoginTokenDto;
var userInfo = await _context.User
.Where(u => u.Id == user.Id)
.Select(u => new
{
u.Id,
GroupId = u.Group.Id,
}).FirstOrDefaultAsync();
if (userInfo == null)
{
throw new ProblemDetailsException(new ProblemDetails
{
Title = "Forbidden",
Status = StatusCodes.Status403Forbidden,
Detail = "Invalid Group",
});
}
var newProject = new Project
{
Name = project.Name,
GroupId = userInfo.GroupId,
};
_context.Add(newProject);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProject", new { newProject.Id }, newProject));
}
public async Task Should_Not_Create_Due_To_Missing_Mandatory_Field()
{
// Arrange
var createDto = new ProjectCreateDto
{
Title = "New Project",
ShortTitle = "Shorty",
// mandatory "Code" field is missing here -> this should create the failure of the api call
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
ValidationProblemDetails validationProblemDetails = await DeserializeResponseMessageAsync <ValidationProblemDetails>(responseMessage);
validationProblemDetails.Title.Should().Be("One or more validation errors occurred.");
validationProblemDetails.Type.Should().Be("https://tools.ietf.org/html/rfc4918#section-11.2");
validationProblemDetails.Status.Should().Be(422);
validationProblemDetails.Errors["Code"].Should().NotBeEmpty();
}
public async void CreateProjectTest(Status expectedStatus)
{
var projectDto = new ProjectCreateDto
{
Title = RandomHelper.RandomString(),
Description = RandomHelper.RandomString(300)
};
var projectsPersisted = new List <Project>();
_projectRepository.Setup(d => d.CreateAsync(Capture.In(projectsPersisted)));
_projectRepository.Setup(d => d.ExistByTitleAsync(projectDto.Title, default))
.ReturnsAsync(expectedStatus == Status.Conflict);
var service = new ProjectService(_projectRepository.Object, _workRepository.Object);
var result = await service.CreateProjectAsync(projectDto);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_projectRepository.Verify(d => d.CreateAsync(It.IsAny <Project>()), Times.Once);
var project = projectsPersisted.Single();
Assert.Equal(projectDto.Title, project.Title);
Assert.Equal(projectDto.Description, project.Description);
}
else
{
_projectRepository.Verify(d => d.CreateAsync(It.IsAny <Project>()), Times.Never);
}
}
public async Task Should_Not_Create_Due_Wrong_Dates()
{
// Arrange
var createDto = new ProjectCreateDto
{
Title = "New Project",
ShortTitle = "Shorty",
Code = "123XYZ,",
StartDate = new DateTime(2020, 01, 01),
EndDate = new DateTime(2020, 01, 01) - new TimeSpan(5, 0, 0, 0), // this is before the StartDate
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
ValidationProblemDetails validationProblemDetails = await DeserializeResponseMessageAsync <ValidationProblemDetails>(responseMessage);
validationProblemDetails.Title.Should().Be("One or more validation errors occurred.");
validationProblemDetails.Type.Should().Be("https://tools.ietf.org/html/rfc4918#section-11.2");
validationProblemDetails.Status.Should().Be(422);
validationProblemDetails.Errors.Should().BeEquivalentTo(new Dictionary <string, string[]>()
{
{ "EndDate", new[] { "'EndDate' must be greater than 'StartDate'" } }
});
}
public async Task Should_Not_Create_Due_To_Non_Unique_ProjectCode()
{
// Arrange
var createDto = new ProjectCreateDto
{
Title = "New Project",
ShortTitle = "Shorty",
Code = ProjectSeedData.RockingXMas.Code,
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
ValidationProblemDetails errorMessage = await DeserializeResponseMessageAsync <ValidationProblemDetails>(responseMessage);
errorMessage.Title.Should().Be("One or more validation errors occurred.");
errorMessage.Status.Should().Be(422);
errorMessage.Errors.Should().BeEquivalentTo(new Dictionary <string, string[]>()
{
{ "Code", new[] { "The specified project code is already in use. The project code needs to be unique." } }
});
}
public ProjectServiceTests()
{
_projRepositoryMock = new Mock <IRepository <Project> >();
_subProjectRepoMock = new Mock <IRepository <SubProject> >();
_httpService = new Mock <IHttpService>();
_mockLogger = new Mock <ILogger <ProjectService> >();
_mockConfig = new Mock <IConfiguration>();
_projectService = new ProjectService(_projRepositoryMock.Object,
_subProjectRepoMock.Object,
_httpService.Object,
_mockLogger.Object,
_mockConfig.Object
);
_newProject = new ProjectCreateDto
{
Id = 0,
Code = "proj_1",
SubProjectIds = new List <int> {
1, 2, 3
}
};
_updateProject = new ProjectCreateDto
{
Id = 1,
Code = "proj_1",
SubProjectIds = new List <int> {
3, 6
}
};
}
public async Task <IActionResult> PostProject([FromBody] ProjectCreateDto projectCreateDto)
{
var project = _mapper.Map <Project>(projectCreateDto);
await _projectRepository.Create(project);
return(Ok());
}
public async Task <ActionResult <ProjectDto> > PostProjects(ProjectCreateDto projectsDto)
{
Project project = new Project {
IdDep = projectsDto.IdDep,
Name = projectsDto.Name,
Description = projectsDto.Description,
StartDate = projectsDto.StartDate.Date,
FinalDate = projectsDto.Finaldate.Date,
};
//Verifica se existe um departamento com o código passado.
if (!_context.Departments.Any(e => e.IdDep == project.IdDep))
{
return(NotFound(new { IdDep = project.IdDep, title = "Not Found", status = "404", message = "department not found" }));
}
try
{
_context.Projects.Add(project);
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
throw;
}
return(CreatedAtAction("GetProjects", new { id = project.NProject }, new ProjectDto {
IdProject = project.NProject,
IdDep = project.IdDep,
Name = project.Name,
Description = project.Description,
StartDate = project.StartDate.Date,
Finaldate = project.FinalDate.Date
}));
}
public async Task <IActionResult> CreateNewProject(ProjectCreateDto projectCreateDto)
{
if (string.IsNullOrWhiteSpace(projectCreateDto.Description) || string.IsNullOrWhiteSpace(projectCreateDto.ProjectName) || projectCreateDto.SelectedUserIds.Count == 0)
{
return(BadRequest("All fields are required!"));
}
var projectToCreate = _mapper.Map <Project>(projectCreateDto);
var projectUsers = new List <ProjectsAndUsers>();
foreach (var userId in projectCreateDto.SelectedUserIds)
{
var projectUser = new ProjectsAndUsers
{
ApplicationUserId = userId,
};
projectUsers.Add(projectUser);
}
projectToCreate.ProjectsAndUsers = projectUsers;
var currentUserId = _userManager.GetUserId(User);
projectToCreate.ApplicationUserId = currentUserId;
_unitOfWork.Projects.Add(projectToCreate);
if (await _unitOfWork.Complete() >= 1)
{
return(Ok("Created!"));
}
else
{
return(BadRequest("An error happened while creating new project!"));
}
}
public ServiceResultModel <Project> Update(ProjectCreateDto model)
{
if (model == null)
{
throw new ArgumentNullException();
}
var project = _projectRepo.GetAllIncluding(x => x.SubProjects).Where(x => x.Id == model.Id)
.Include(x => x.SubProjects).ThenInclude(x => x.Child).FirstOrDefault();
if (project == null)
{
throw new ArgumentNullException();
}
project.Name = model.Name;
project.StartDate = model.StartDate;
project.Code = model.Code;
var addedSubProjects = model.SubProjectIds.Except(project.SubProjects.Select(x => x.ChildId)).ToList();
var resultModel = ValidateProject(project, addedSubProjects);
if (resultModel.HasError)
{
return(resultModel);
}
_projectRepo.Update(project);
resultModel.Data = project;
return(resultModel);
}
/// <inheritdoc/>
public Project CreateProject(ProjectCreateDto dto)
{
var now = DateUtil.Now;
var entity = new ProjectTableEntity
{
ProjectId = Guid.NewGuid(),
ProjectCode = dto.ProjectCode,
Name = dto.Name,
Description = dto.Description,
Status = dto.Status,
SortNo = dto.SortNo,
CreateTime = now,
UpdateTime = now,
};
using (var tran = new TransactionScope())
{
_projectRepository.Create(entity);
foreach (var tag in dto.Tags)
{
_tagRepository.Create(new TagTableEntity
{
TagId = Guid.NewGuid(),
TargetId = entity.ProjectId,
Value = tag,
TargetTable = "Project",
CreateTime = now,
});
}
tran.Complete();
}
return(_projectQueryService.GetProject(entity.ProjectId));
}
public IActionResult Create(long companyId, [FromBody] ProjectCreateDto projectCreateDto)
{
projectCreateDto.CompanyId = companyId;
Project project = _projectCreateAssembler.toEntity(projectCreateDto);
_projectRepository.Create(project);
return(StatusCode(StatusCodes.Status201Created, new ApiStringResponseDto("Project Created!")));
}
public void Map_Should_Map_ProjectCreateDto_To_Project()
{
var vm = new ProjectCreateDto();
var entity = Mapper.Map <Project>(vm);
entity.ShouldNotBeNull();
entity.ShouldBeOfType <Project>();
}
public IHttpActionResult UpdateProject(int projectId, ProjectCreateDto dto)
{
if (projectId != dto.ProjectId)
{
return(BadRequest("Invalid request"));
}
return(SaveProject(dto));
}
public ActionResult <ProjectReadDto> CreateProject(ProjectCreateDto projectCreate)
{
var project = _mapper.Map <Project>(projectCreate);
_repository.CreateProject(project);
_repository.SaveChanges();
return(Ok(projectCreate));
}
public ActionResult <ProjectReadDto> CreateProject(ProjectCreateDto projectCreateDto)
{
var project = _mapper.Map <Project>(projectCreateDto);
_projectRepo.CreateProject(project);
_projectRepo.SaveChanges();
var projectReadDto = _mapper.Map <ProjectReadDto>(project);
return(CreatedAtRoute(nameof(GetProjectById), new { id = projectReadDto.Id }, projectReadDto));
}
public IActionResult CreateProject([FromBody] ProjectCreateDto project)
{
if (project == null)
{
return(BadRequest("Project object cannot be null"));
}
var newProjectId = _projectService.CreateProject(project);
return(CreatedAtRoute("ProjectById", new { projectId = newProjectId }, project));
}
public ActionResult <ProjectDto> CreateProject(ProjectCreateDto projectCreateDto)
{
var project = _mapper.Map <Project>(projectCreateDto);
_repository.CreateProject(project);
_repository.SaveChanges();
var projectDto = _mapper.Map <ProjectDto>(project);
//return URI to use for redirection after we create a project in react
return(CreatedAtRoute(nameof(GetProject), new { id = projectDto.id }, projectDto));
//return Ok(projectDto);
}
public async Task <ActionResult <ProjectDto> > CreateProject([FromBody] ProjectCreateDto dto)
{
List <WorkItemStatus> availableStatues =
dto.AvailableStatuses.Select(x => new WorkItemStatus(x)).ToList();
var project = new Project(dto.Title, dto.Description, availableStatues);
project = await _projectsRepository.SaveProject(project);
ProjectDto createdDto = _mapper.Map <ProjectDto>(project);
return(CreatedAtAction(nameof(GetProject), new { id = project.Id }, createdDto));
}
public ProjectDto CreateAsync(ProjectCreateDto createDto)
{
var command = new List <ProjectsCreateCommand> {
new ProjectsCreateCommand(new ProjectCreateDto())
};
var result = new ProjectDto {
Name = createDto.Name,
};
return(result);
}
public int CreateProject(ProjectCreateDto project)
{
var entity = new Project
{
Name = project.Name
};
_context.Projects.Add(entity);
_context.SaveChanges();
return(entity.ProjectID);
}
public void ThereIsOneProject(string projectTitle)
{
var create = new ProjectCreateDto
{
Start = new DateTime(2020, 3, 10),
End = new DateTime(2020, 3, 17),
Title = projectTitle,
Description = "Demonstrating some tools and patterns to test ASP.NET Core applications.",
MaxParticipants = 16
};
Task.WaitAll(testContext.PostAsync(testContext.ProjectsEndpoint, create));
}
public async Task <IActionResult> RenameProject(int id, ProjectCreateDto project)
{
var user = HttpContext.Items["User"] as UserLoginTokenDto;
var userInfo = await _context.User
.Where(u => u.Id == user.Id)
.Select(u => new
{
GroupId = u.Group.Id,
ProjectId = u.Group.GroupProject.Id,
}).FirstOrDefaultAsync();
if (userInfo == null || id != userInfo.ProjectId)
{
throw new ProblemDetailsException(new ProblemDetails
{
Title = "Forbidden",
Status = StatusCodes.Status403Forbidden,
Detail = "Invalid Project",
});
}
var newProject = new Project
{
Id = userInfo.ProjectId,
GroupId = userInfo.GroupId,
Name = project.Name,
UpdatedDate = new DateTimeOffset(),
};
_context.Entry(newProject).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!await ProjectExists(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public async Task Should_Create_With_All_Fields_Defined()
{
// Arrange
var createDto = new ProjectCreateDto
{
Title = "New Project",
ShortTitle = "ShortName",
Description = "New project description",
Code = "0815XY",
TypeId = SelectValueMappingSeedData.ProjectTypeMappings[0].Id,
GenreId = SelectValueMappingSeedData.ProjectGenreMappings[0].Id,
StartDate = new DateTime(2021, 01, 01),
EndDate = new DateTime(2021, 01, 31),
StateId = SelectValueMappingSeedData.ProjectStateMappings[0].Id,
ParentId = ProjectSeedData.HoorayForHollywood.Id,
};
var expectedDto = new ProjectDto
{
Title = createDto.Title,
ShortTitle = createDto.ShortTitle,
Description = createDto.Description,
Code = createDto.Code,
TypeId = createDto.TypeId,
GenreId = createDto.GenreId,
StartDate = createDto.StartDate,
EndDate = createDto.EndDate,
StateId = createDto.StateId,
ParentId = createDto.ParentId,
IsCompleted = false,
CreatedBy = _staff.DisplayName,
CreatedAt = FakeDateTime.UtcNow
};
// Act
HttpResponseMessage responseMessage = await _authenticatedServer
.CreateClient()
.AuthenticateWith(_staff)
.PostAsync(ApiEndpoints.ProjectsController.Post(), BuildStringContent(createDto));
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.Created);
ProjectDto result = await DeserializeResponseMessageAsync <ProjectDto>(responseMessage);
result.Should().BeEquivalentTo(expectedDto, opt => opt.Excluding(r => r.Id));
result.Id.Should().NotBeEmpty();
responseMessage.Headers.Location.AbsolutePath.Should().Be($"/{ApiEndpoints.ProjectsController.Get(result.Id)}");
}
public async Task <ActionResult> CreateDto([FromBody] ProjectCreateDto dto)
{
var project = new Project {
Description = dto.Description,
End = dto.End,
MaxParticipants = dto.MaxParticipants,
Start = dto.Start,
Title = dto.Title
};
var persistedProject = await db.Projects.AddAsync(project);
await db.SaveChangesAsync();
return(CreatedAtAction(nameof(GetById), persistedProject.Entity.Id));
}
public IActionResult Create([FromBody] ProjectCreateDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ListModelErrors.ToArray()));
}
var result = _projectService.Create(model);
if (result.HasError)
{
return(HandleBadRequest(result.ErrorMessages));
}
return(Ok());
}
public async Task <HttpResponseMessage> PostAsync <TBody>(string path, [FromBody] ProjectCreateDto dto)
{
_logger.LogInformation($"POST: Creating resource of type {typeof(TBody).Name}");
var command = new ProjectsCreateCommand(dto);
var response = await _mediator.Send(command);
var result = new HttpResponseMessage
{
StatusCode = System.Net.HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(response.Data), System.Text.Encoding.UTF8,
"application/json")
};
return(result);
}
