public void UpdateProject_Successfully(string projectName, int projectId, string userID, string userName)
{
_projectRepository.GetAll(x => x.Active).ReturnsForAnyArgs(ProjectList());
var addDto = new AddProjectDto
{
ProjectID = projectId,
ProjectName = projectName,
};
var updateProject = new Project
{
ID = projectId,
ProjectName = projectName,
ContactEmail = "*****@*****.**",
ContactName = "Test"
};
_projectRepository.Find(projectId).ReturnsForAnyArgs(ProjectList().FirstOrDefault(x => x.ID == addDto.ProjectID));
_projectRepository.Update(Arg.Any <Project>()).Returns(updateProject);
var actualResult = _userDashboardProcessor.UpdateProject(addDto, userID, userName);
Assert.AreEqual(updateProject.ID, actualResult.ProjectID);
}
/// <summary>
/// Updates the project.
/// </summary>
/// <param name="addProjectDto">The update project dto.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="userName">Name of the user.</param>
/// <returns></returns>
/// <exception cref="PowerDesignProException">ProjectNameExist</exception>
public AddProjectResponseDto UpdateProject(AddProjectDto addProjectDto, string userId, string userName)
{
var projectCount = _projectRepository.GetAll(p => p.UserID == userId && p.Active)
.Where(p => p.ID != addProjectDto.ProjectID &&
addProjectDto.ProjectName.Equals(
p.ProjectName,
StringComparison.InvariantCultureIgnoreCase)).Count();
if (projectCount > 0)
{
throw new PowerDesignProException("ProjectNameExist", Message.ProjectDashboard);
}
var Project = _projectRepository.Find(addProjectDto.ProjectID);
_addProjectDtoToEntityMapper.UpdateMap(addProjectDto, Project, userId, userName);
var projectDetail = _projectRepository.Update(Project);
_projectRepository.Commit();
return(new AddProjectResponseDto
{
ProjectID = projectDetail.ID,
ProjectName = projectDetail.ProjectName
});
}
public async Task <ActionResult> AddProject(AddProjectDto addProjectDto)
{
var project = this.mapper.Map <Projects>(addProjectDto);
await unitOfWork.ProjectRepository.AddProject(project);
return(await unitOfWork.SaveAll() ? Ok() : BadRequest());
}
public void Add(AddProjectDto dto)
{
var ProjectModel = Mapper.Map <ProjectModel>(dto);
ProjectModel.KeyId = Guid.NewGuid();
ProjectModel.CreatedAt = ProjectModel.UpdatedAt = DateTime.Now;
_ProjectRepository.Add(ProjectModel);
}
public TestCaseContext WithNewProjectForUser(UserInfoDto user, AddProjectDto addProjectDto, out ProjectInfoDto projectInfo)
{
projectInfo = ProjectController.CreateProject(addProjectDto).Value;
Assert.NotNull(projectInfo);
return(this);
}
public void Add(AddProjectDto project)
{
_dbContext.Projects.Add(new Project {
Name = project.Name,
Description = project.Description,
IsDeleted = false,
CreationDate = DateTime.Now
});
_dbContext.SaveChanges();
}
public void AddProject_ProjectExist(string projectName, string userID, string userName)
{
_projectRepository.GetAll(x => x.Active).ReturnsForAnyArgs(ProjectList());
var addDto = new AddProjectDto
{
ProjectName = projectName,
};
var result = _userDashboardProcessor.AddProject(addDto, userID, userName);
_projectRepository.Add(Arg.Any <Project>()).DidNotReceive();
}
public async Task <IActionResult> Create([FromBody] AddProjectDto dto)
{
var validator = CheckValidation(dto);
if (!validator.IsValid)
{
throw new BadRequestException(validator.Errors);
}
var result = await _projectService.CreateAsync(dto);
return(ResultOk(result));
}
public IActionResult Post([FromBody] AddProjectDto dto
, [FromServices] IAddProjectCommand command
, [FromServices] AddProjectValidator validator)
{
var result = validator.Validate(dto);
if (result.IsValid)
{
Project project = _mapper.Map <Project>(dto);
_useCaseExecutor.ExecuteCommand(command, project);
return(Ok("Project created successfully"));
}
return(UnprocessableEntity(UnprocessableEntityResponse.Message(result.Errors)));
}
public async Task <ProjectDto> CreateAsync(AddProjectDto dto)
{
var existedProject = await Repository.SingleAsync(s => s.Name == dto.Name);
if (existedProject != null)
{
throw new BadRequestException("Project is ready existed.");
}
var entity = dto.ToEntity();
entity.SetAudit(AppContext.Value);
var result = await CreateAsync(entity);
return(result?.ToDto());
}
public HttpResponseMessage UpdateProject(AddProjectDto requestDto)
{
if (requestDto == null || !ModelState.IsValid)
{
var errorResponse = new
{
ErrorCode = -1,
ErrorDescription = MessageCollection.Instance.GetMessage("NameFieldRequired", Message.ProjectDashboard)
};
return(Request.CreateResponse(HttpStatusCode.OK, errorResponse));
}
return(CreateHttpResponse(() =>
{
return Request.CreateResponse(_userDashboard.UpdateProject(requestDto, UserID, UserName));
}));
}
public CommonResult Add(AddProjectDto project)
{
if (string.IsNullOrEmpty(project.Name))
{
return(CommonResult.Failure("Cannot create project without name provided"));
}
if (string.IsNullOrEmpty(project.Description))
{
return(CommonResult.Failure("Cannot create project without description provided"));
}
var existingProject = _projectRepository.GetByName(project.Name);
if (existingProject != null && existingProject.IsDeleted == false && existingProject.Name == project.Name)
{
return(CommonResult.Failure("Project name already exists"));
}
_projectRepository.Add(project);
return(CommonResult.Success());
}
public ProjectInfoDto AddProject(AddProjectDto argues)
{
var newProject = new ProjectInfo
{
AuthorId = argues.UserId,
GithubLink = argues.ProjectUrl,
Title = argues.ProjectName,
Skills = argues
.Tags
.Select(t => new ProjectSkill {
SkillName = t
})
.ToList()
};
return(_projectRepository
.Create(newProject)
.To(p => new ProjectInfoDto(p)));
}
public void AddProject_Successfully(string userID, string userName, string projectName, int projectId)
{
_projectRepository.GetAll(x => x.Active).ReturnsForAnyArgs(ProjectList());
var addDto = new AddProjectDto
{
ProjectName = projectName,
};
var addedProject = new Project
{
ID = projectId,
ProjectName = projectName,
};
_projectRepository.Add(Arg.Any <Project>()).Returns(addedProject);
var actualResult = _userDashboardProcessor.AddProject(addDto, userID, userName);
Assert.AreEqual(addedProject.ID, actualResult.ProjectID);
}
public CommonResult Add(AddProjectDto project)
{
if (String.IsNullOrWhiteSpace(project.Name))
{
return(CommonResult.Failure("Project name is empty."));
}
if (String.IsNullOrWhiteSpace(project.Description))
{
return(CommonResult.Failure("Project description is empty."));
}
var existingProject = _projectsRepository.GetByName(project.Name);
if (existingProject != null && !existingProject.IsDeleted && existingProject.Name == project.Name)
{
return(CommonResult.Failure("Project name already exists."));
}
_projectsRepository.Add(project);
return(CommonResult.Success());
}
/// <summary>
/// Adds the project.
/// </summary>
/// <param name="addProjectDto">The add project dto.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="userName">Name of the user.</param>
/// <returns></returns>
/// <exception cref="PowerDesignProException">ProjectNameExist</exception>
public AddProjectResponseDto AddProject(AddProjectDto addProjectDto, string userId, string userName)
{
var projectCount = _projectRepository.GetAll(p => p.UserID == userId && p.Active)
.Where(p => p.ProjectName.ToUpper() == addProjectDto.ProjectName.ToUpper())
.Count();
if (projectCount > 0)
{
throw new PowerDesignProException("ProjectNameExist", Message.ProjectDashboard);
}
var project = _addProjectDtoToEntityMapper.AddMap(addProjectDto, userId, userName);
var projectDetail = _projectRepository.Add(project);
_projectRepository.Commit();
return(new AddProjectResponseDto
{
ProjectID = projectDetail.ID,
ProjectName = projectDetail.ProjectName
});
}
public Task AddProject(AddProjectDto addProjectDto)
{
throw new System.NotImplementedException();
}
public static Project ToEntity(this AddProjectDto dto)
{
return(Mapper.Map <Project>(dto));
}
public ActionResult <ProjectInfoDto> CreateProject([FromBody][Required] AddProjectDto addProjectDto)
{
//TODO: validate tags - it is must exist in database
//TODO: validate project url - it is must be project at author github
return(_projectService.AddProject(addProjectDto));
}
