public async Task AddProject()
{
var projectMod = new ProjectAdd
{
EndDate = DateTime.Today.AddDays(2),
StartDate = DateTime.Today,
PMUsrId = "Usr/1",
ProjectTitle = "Project A1",
Priority = 1
};
var project = new Project
{
End = projectMod.EndDate,
MaxTaskCount = 0,
PMId = projectMod.PMUsrId,
Priority = projectMod.Priority,
Start = projectMod.StartDate,
Status = 0,
Title = projectMod.ProjectTitle
};
var mockProjTaskRepo = new Mock <IProjectTaskRepo>();
mockProjTaskRepo.Setup(repo => repo.AddProject(It.IsAny <Project>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1")));
var mockLogger = createProjServiceLogger();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(mapper => mapper.Map <Project>(It.IsAny <ProjectAdd>())).Returns(project);
var projectTaskService = new ProjTaskService(mockProjTaskRepo.Object, mockLogger, mockMapper.Object);
var result = await projectTaskService.AddProject(projectMod);
Assert.True(result.Item1);
Assert.Equal("P/1", result.Item2);
}
public Project Add(ProjectAdd project)
{
var toAdd = project.ToProject();
context.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public IActionResult Add(ProjectAdd project)
{
if (!ModelState.IsValid)
{
return(View(project));
}
repository.Add(project);
return(Redirect("~/"));
}
public static Project ToProject(this ProjectAdd add)
=> new Project
{
Title = add.Title,
Description = add.Description,
IsCompleted = add.IsCompleted,
ClosingDate = add.ClosingDate,
StartingDate = add.StartingDate
};
protected async Task AddAsync()
{
var project = await ProjectRepository.AddAsync(ProjectAdd);
ProjectAdd = new ProjectAdd();
await NavigationContext.OnMenuUpdatedAsync(Control);
NavigationManager.NavigateTo("/project/" + project.Id);
}
public IActionResult PostProject([FromBody] ProjectAdd project)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newProject = projectService.AddProject(project);
return(Ok(newProject));
}
public async Task <Project> AddAsync(ProjectAdd toAdd, CancellationToken cancellationToken = default)
{
var project = toAdd.ToEntity();
project.CreatedOn = DateTime.UtcNow;
project.Order = await _context.Projects.MaxAsync(p => (int?)p.Order, cancellationToken) ?? 0 + 1;
await _context.AddAsync(project, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(project);
}
public async Task<Tuple<bool, string>> AddProject(ProjectAdd project)
{
if ((project.EndDate > DateTime.MinValue) && (project.StartDate > DateTime.MinValue)
&& (project.StartDate > project.EndDate))
return new Tuple<bool, string>(false, "start date greater than end date");
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(project);
var validationResults = new List<ValidationResult>();
if (Validator.TryValidateObject(project, validationContext, validationResults))
{
var projectDO = mapper.Map<Project>(project);
return await projectTaskRepo.AddProject(projectDO);
}
return new Tuple<bool, string>(false, "validation failures");
}
public void GetterSetter()
{
var projectMod = new ProjectAdd
{
EndDate = DateTime.Today.AddDays(2),
StartDate = DateTime.Today,
PMUsrId = "Usr/1",
ProjectTitle = "Project A1"
};
Assert.Equal(DateTime.Today.AddDays(2), projectMod.EndDate);
Assert.Equal(DateTime.Today, projectMod.StartDate);
Assert.Equal("Usr/1", projectMod.PMUsrId);
Assert.Equal("Project A1", projectMod.ProjectTitle);
}
public ProjectModel AddProject(ProjectAdd projectToAdd)
{
var project = mapper.Map <Project>(projectToAdd);
var owner = unitOfWork.UserRepository.GetByID(projectToAdd.OwnerId);
project.Owner = owner;
unitOfWork.ProjectRepository.Insert(project);
var projectUser = new ProjectUser();
projectUser.User = owner;
projectUser.Project = project;
unitOfWork.ProjectUserRepository.Insert(projectUser);
unitOfWork.Save();
return(mapper.Map <ProjectModel>(project));
}
public async Task AddProjectTest()
{
var projectService = new Mock <IProjTaskService>();
var projAdd = new ProjectAdd
{
EndDate = DateTime.Today.AddDays(2),
PMUsrId = "Usr/1",
Priority = 1,
ProjectTitle = "Project Title",
StartDate = DateTime.Today
};
projectService.Setup(repo => repo.AddProject(It.IsAny <ProjectAdd>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1")));
var logger = createLogger();
var projectController = new ProjectController(projectService.Object, logger);
var actionResult = (await projectController.AddProject(projAdd)).Result as CreatedResult;
Assert.NotNull(actionResult);
Assert.Equal(201, actionResult.StatusCode);
}
public async Task <ActionResult <bool> > AddProject([FromBody] ProjectAdd projectAdd)
{
if (projectAdd == null)
{
ModelState.AddModelError("ParameterEmpty", "Input parameter are all empty");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await projService.AddProject(projectAdd);
if (result.Item1)
{
return(Created($"api/Project/{result.Item2}", result.Item1));
}
else
{
return(StatusCode(500, "Unable to create project"));
}
}
public static Project ToEntity(this ProjectAdd add)
{
return(new Project {
Title = add.Title
});
}
public ActionResult <Project> Add(ProjectAdd project) => repository.Add(project);
protected override void OnInitialized()
{
ProjectAdd = new ProjectAdd();
base.OnInitialized();
}
