public ActionResult RegisterProject([FromBody] ProjectCreateDTO projectData)
{
if (!ModelState.IsValid)
{
return(BadRequest(new
{
Message = "La informacion de registro del proyecto son invalidos.",
ErrorsCount = ModelState.ErrorCount,
Errors = ModelState.Select(x => x.Value.Errors)
}));
}
var newProject = this._mapper.Map <Project>(projectData);
if (newProject == null)
{
return(BadRequest(new { Error = "No se enviaron los datos esperados." }));
}
var tempProject = this._appDBContext.Projects.Add(newProject);
this._appDBContext.SaveChanges();
var projectModel = this._mapper.Map <ProjectResponseDTO>(tempProject.Entity);
return(Ok(new
{
Message = "Ok",
Result = projectModel
}));
}
public async Task <Response <ProjectDTO> > Create(Guid teamId, ProjectCreateDTO dto, ClaimsPrincipal claims)
{
var result = await _service.Create(claims.GetUserId(), teamId, dto);
// await BroadcastChanges(result, ChangesType.Created);
return(result);
}
public ActionResult Edit(ProjectCreateDTO req)
{
Response res = new Response();
if (ModelState.IsValid)
{
try
{
if (req.Id > 0)
{
res.Data = ProjectRepository.Update(req);
}
else
{
req.CreateDate = DateTime.Now;
res.Data = ProjectRepository.Create(req);
}
}
catch (Exception ex)
{
res.Message = ex.InnerException.Message;
}
}
else
{
res.Data = false;
res.Message = string.Join(",", ModelState.SelectMany(ms => ms.Value.Errors).Select(e => e.ErrorMessage));
}
return(Json(res, JsonRequestBehavior.AllowGet));
}
public async Task <int> CreateProject(ProjectCreateDTO projectCreateDto, int userId)
{
var project = _mapper.Map <Project>(projectCreateDto);
var user = await _userService.GetUserDetailsById(userId);
project.AuthorId = userId;
project.CreatedAt = DateTime.Now;
project.AccessModifier = projectCreateDto.Access;
var userEditorSettings = (await _userService.GetUserDetailsById(userId)).EditorSettings;
var newProjectEditorSetting = new EditorSettingDTO
{
CursorStyle = userEditorSettings.CursorStyle,
FontSize = userEditorSettings.FontSize,
ScrollBeyondLastLine = userEditorSettings.ScrollBeyondLastLine,
RoundedSelection = userEditorSettings.RoundedSelection,
TabSize = userEditorSettings.TabSize,
LineHeight = userEditorSettings.LineHeight,
LineNumbers = userEditorSettings.LineNumbers,
ReadOnly = userEditorSettings.ReadOnly,
Theme = userEditorSettings.Theme,
Language = (projectCreateDto.Language.ToString()).ToLower()
};
var createDTO = await _editorSettingService.CreateEditorSettings(newProjectEditorSetting);
project.EditorProjectSettingsId = _mapper.Map <EditorSetting>(createDTO).Id;
_context.Projects.Add(project);
await _context.SaveChangesAsync();
_logger.LogInformation($"project created {project.Name}");
return(project.Id);
}
public async Task <ActionResult> CreateProject([FromForm] ProjectCreateDTO project)
{
var author = this.GetUserIdFromToken();
var projectId = await _projectService.CreateProject(project, author);
_logger.LogInformation(LoggingEvents.InsertItem, $"Created project {projectId}");
if (Request.Form.Files.Count > 0)
{
var projectStructure = await _projectStructureService.CreateEmptyAsync(projectId, project.Name);
var zipFile = Request.Form.Files[0];
//await _projectStructureService.UnzipProject(projectStructure, zipFile, author, projectId);
await _projectStructureService.ImportProject(projectStructure.Id, zipFile, projectId.ToString(), author, false, null);
}
else if (!string.IsNullOrEmpty(project.GithubUrl))
{
IFormFile formfile = null;
Uri url = new Uri(project.GithubUrl);
var fileNameFromUri = $"{url.Segments[url.Segments.Length - 1]}-master.zip";
UriBuilder uriBuilder = new UriBuilder(url);
uriBuilder.Path = Path.Combine(url.AbsolutePath, "archive/master.zip");
using (HttpClient client = new HttpClient())
{
HttpResponseMessage response = await client.GetAsync(uriBuilder.ToString());
if (response.IsSuccessStatusCode)
{
var streamResult = await response.Content.ReadAsStreamAsync();
streamResult.Seek(0, SeekOrigin.Begin);
if (streamResult != null)
{
formfile = await _projectService.ConvertFilestreamToIFormFile(streamResult, fileNameFromUri, fileNameFromUri);
}
}
}
var projectStructure = await _projectStructureService.CreateEmptyAsync(projectId, project.Name);
await _projectStructureService.ImportProject(projectStructure.Id, formfile, projectId.ToString(), author, false, null, true);
}
//else if (formfile != null)
//{
// var projectStructure = await _projectStructureService.CreateEmptyAsync(projectId, project.Name);
// await _projectStructureService.ImportProject(projectStructure.Id, formfile, projectId.ToString(), author, false, null);
//}
else
{
var projectStructureDTO = await _projectTemplateService.GenerateProjectTemplate(project.Name, projectId, author, project.Language);
await _projectStructureService.CreateAsync(projectStructureDTO);
}
return(Created("/project", projectId));
}
private ProjectCreate getCreateViewModel(ProjectCreateDTO dto)
{
ProjectCreate viewModel = this.getCreateViewModel();
viewModel.Name = dto.Name;
viewModel.ProjectID = dto.ProjectID;
viewModel.Rate = dto.Rate;
return(viewModel);
}
public async Task <ProjectDTO> CreateProject(ProjectCreateDTO project)
{
var response = await client.PostAsJsonAsync($"{baseUrl}/api/projects", project);
if (response.StatusCode != System.Net.HttpStatusCode.Created)
{
throw new Exception($"{response.StatusCode} : {await response.Content.ReadAsStringAsync()}");
}
return(await response.Content.ReadAsAsync <ProjectDTO>());
}
public async Task Create_WhenDeadlineEarliearOrEqualCreatedDate_ThenResponseCode400()
{
var httpResponseTeams = await client.GetAsync($"api/teams");
var stringResponseTeams = await httpResponseTeams.Content.ReadAsStringAsync();
var teams = JsonConvert.DeserializeObject <ICollection <TeamDTO> >(stringResponseTeams);
var httpResponseUsers = await client.GetAsync($"api/users");
var stringResponseUsers = await httpResponseUsers.Content.ReadAsStringAsync();
var users = JsonConvert.DeserializeObject <ICollection <UserDTO> >(stringResponseUsers);
var projectDeadlineEarlier = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now - new TimeSpan(1, 0, 0, 0),
AuthorId = users.Max(u => u.Id),
TeamId = teams.Max(t => t.Id)
};
string jsonInString = JsonConvert.SerializeObject(projectDeadlineEarlier);
var httpResponseEarlier = await client.PostAsync("api/projects",
new StringContent(jsonInString, Encoding.UTF8, "application/json"));
var stringResponse = await httpResponseEarlier.Content.ReadAsStringAsync();
var createdProject = JsonConvert.DeserializeObject <ProjectDTO>(stringResponse);
await client.DeleteAsync($"api/projects/{createdProject.Id}");
var projectDeadlineEqual = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now,
AuthorId = users.Max(u => u.Id),
TeamId = teams.Max(t => t.Id)
};
jsonInString = JsonConvert.SerializeObject(projectDeadlineEqual);
var httpResponseEqual = await client.PostAsync("api/projects",
new StringContent(jsonInString, Encoding.UTF8, "application/json"));
stringResponse = await httpResponseEqual.Content.ReadAsStringAsync();
createdProject = JsonConvert.DeserializeObject <ProjectDTO>(stringResponse);
await client.DeleteAsync($"api/projects/{createdProject.Id}");
Assert.Equal(HttpStatusCode.BadRequest, httpResponseEarlier.StatusCode);
Assert.Equal(HttpStatusCode.BadRequest, httpResponseEqual.StatusCode);
}
public async Task <GenericResponseDTO <int> > CreateProject(ProjectCreateDTO newProject)
{
var currentUser = await authHelper.GetCurrentUser(User, database);
var response = new GenericResponseDTO <int>()
{
Success = false
};
// Project validation
if (string.IsNullOrWhiteSpace(newProject.ClientName))
{
response.Message = "A project must have a client name.";
return(response);
}
if (string.IsNullOrWhiteSpace(newProject.ProjectName))
{
response.Message = "A project must have a project name.";
return(response);
}
// Create the tags
var tags = new List <Tag>();
if (newProject.Tags != null)
{
newProject.Tags.ForEach(x => tags.Add(new Tag()
{
Name = x
}));
}
// Create the new project object
var project = new Project()
{
ClientName = newProject.ClientName,
Description = newProject.Description,
CreatedTime = DateTime.UtcNow,
Name = newProject.ProjectName,
Teacher = currentUser,
InviteCode = Guid.NewGuid().ToString(),
Tags = tags,
Students = new List <User>()
};
await database.AddAsync(project);
await database.SaveChangesAsync();
response.Success = true;
response.Data = project.Id;
return(response);
}
public async Task CreateNewProjectStructureAsync_WhenOneProjectHasShortestTaskByNameId4_ThenShortestTaskId4()
{
var team = new Team {
Id = 1, Name = "new team", CreatedAt = DateTime.Now
};
context.Teams.Add(team);
await context.SaveChangesAsync();
var user = new User {
Id = 1, Birthday = DateTime.Now, TeamId = team.Id
};
context.Users.Add(user);
await context.SaveChangesAsync();
var projectCreate = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now + new TimeSpan(1, 0, 0, 0),
AuthorId = user.Id,
TeamId = team.Id
};
var project = await projectService.CreateProject(projectCreate);
var taskId = 1;
var taskFake = new Faker <TaskModel>()
.RuleFor(c => c.Id, f => taskId++)
.RuleFor(c => c.Name, f => f.Lorem.Sentence())
.RuleFor(c => c.Description, f => f.Lorem.Word())
.RuleFor(c => c.ProjectId, f => f.PickRandom(project).Id)
.RuleFor(c => c.PerformerId, f => f.PickRandom(user).Id)
.RuleFor(c => c.State, f => f.Random.Enum <TaskState>())
.RuleFor(pi => pi.CreatedAt, f => f.Date.Between(new DateTime(2015, 1, 1), new DateTime(2019, 1, 1)))
.RuleFor(pi => pi.FinishedAt, f => f.Date.Future(5, new DateTime(2019, 1, 1)));
var tasks = taskFake.Generate(5);
context.Tasks.AddRange(tasks);
await context.SaveChangesAsync();
var taskId4 = context.Tasks.Find(4);
taskId4.Name = "0";
context.Tasks.Update(taskId4);
var result = (await projectService.CreateNewProjectStructureAsync()).FirstOrDefault();
Assert.Equal(taskId4.Id, result.ShortestTaskByName.Id);
}
public async Task <ActionResult <ProjectDTO> > CreateAsync([FromBody] ProjectCreateDTO project)
{
try
{
return(Ok(await service.CreateAsync(project)));
}
catch (ValidationException e)
{
return(BadRequest(e.ValidationErrors));
}
catch (NotFoundException e)
{
return(NotFound(new { Id = e.Key, e.Message }));
}
}
public async Task GetUserProjectTasksCountByUserId_WhenUserProjectHas5Tasks_ThenTasksCountIs5()
{
var team = new Team {
Id = 1, Name = "new team", CreatedAt = DateTime.Now
};
context.Teams.Add(team);
await context.SaveChangesAsync();
var user = new User {
Id = 1, Birthday = DateTime.Now, TeamId = team.Id
};
context.Users.Add(user);
await context.SaveChangesAsync();
var projectCreate = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now + new TimeSpan(1, 0, 0, 0),
AuthorId = user.Id,
TeamId = team.Id
};
var project = await projectService.CreateProject(projectCreate);
var taskId = 201;
var taskFake = new Faker <TaskModel>()
.RuleFor(c => c.Id, f => taskId++)
.RuleFor(c => c.Name, f => f.Lorem.Sentence())
.RuleFor(c => c.Description, f => f.Lorem.Sentences())
.RuleFor(c => c.ProjectId, f => f.PickRandom(project).Id)
.RuleFor(c => c.PerformerId, f => f.PickRandom(user).Id)
.RuleFor(c => c.State, f => f.Random.Enum <TaskState>())
.RuleFor(pi => pi.CreatedAt, f => f.Date.Between(new DateTime(2015, 1, 1), new DateTime(2019, 1, 1)))
.RuleFor(pi => pi.FinishedAt, f => f.Date.Future(5, new DateTime(2019, 1, 1)));
var tasks = taskFake.Generate(5);
context.Tasks.AddRange(tasks);
await context.SaveChangesAsync();
var result = await projectService.GetUserProjectTasksCountByUserId(user.Id);
Assert.Equal(5, result.Values.ElementAt(0));
}
public async Task AddUserToProjectOnLogin()
{
await TestAuthHelpers.LogInUser(database, configuration, projectController);
ProjectCreateDTO projectInfo = new ProjectCreateDTO {
ProjectName = "Soup Delivery Website",
ClientName = "Soup Delivery LLC"
};
GenericResponseDTO <int> createProjectResponse = await projectController.CreateProject(projectInfo);
Assert.IsTrue(createProjectResponse.Success);
int projectID = createProjectResponse.Data;
Project project = await database.Projects
.AsNoTracking()
.FirstOrDefaultAsync(p => p.Id == projectID);
string projectInviteCode = project.InviteCode;
UserDTO registrationInfo = new UserDTO {
Email = "*****@*****.**",
Password = "******",
FirstName = "Suzuya",
LastName = "Z."
};
GenericResponseDTO <int> registerResponse = await authController.Register(registrationInfo);
Assert.IsTrue(registerResponse.Success);
UserDTO loginInfo = new UserDTO {
Email = "*****@*****.**",
Password = "******",
InviteCode = projectInviteCode
};
await authController.Login(loginInfo);
User user = await database.Users
.Include(x => x.Projects)
.FirstOrDefaultAsync(u => u.Id == registerResponse.Data);
Assert.IsTrue(user.Projects.Count == 1);
Assert.IsTrue(user.Projects[0].Id == project.Id);
}
public async Task <ProjectDTO> CreateProject(ProjectCreateDTO projectDto)
{
var projectEntity = mapper.Map <Project>(projectDto);
projectEntity.CreatedAt = DateTime.Now;
await userService.GetUserById(projectEntity.AuthorId);
await teamService.GetTeamById(projectEntity.TeamId);
if (projectEntity.Deadline <= projectEntity.CreatedAt)
{
throw new ArgumentException("Deadline of a created project must be later then created date");
}
await repository.Create(projectEntity);
await unitOfWork.SaveChangesAsync();
return((await GetAllProjects()).FirstOrDefault(p => p.Id == projectEntity.Id));
}
public async Task CreateNewProjectStructureAsync_WhenOneProjectHasDescriptionLengthGreaterThan20AndUsersInTeam3_ThenUsersCount3()
{
var team = new Team {
Id = 1, Name = "new team", CreatedAt = DateTime.Now
};
context.Teams.Add(team);
await context.SaveChangesAsync();
for (int i = 0; i < 3; i++)
{
var user = new User {
Id = i + 1, Birthday = DateTime.Now, TeamId = team.Id
};
context.Users.Add(user);
await context.SaveChangesAsync();
}
StringBuilder desc = new StringBuilder();
for (int i = 0; i < 21; i++)
{
desc.Append("o");
}
var projectCreate = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now + new TimeSpan(1, 0, 0, 0),
AuthorId = context.Users.FirstOrDefault().Id,
TeamId = team.Id
};
var project = await projectService.CreateProject(projectCreate);
var result = (await projectService.CreateNewProjectStructureAsync()).FirstOrDefault();
Assert.Equal(3, result.TotalUsersCount);
}
public ActionResult <ProjectReadDTO> PostProject(ProjectCreateDTO project)
{
if (!ModelState.IsValid)
{
_logger.LogError("Bad Request 400.");
return(BadRequest(ModelState));
}
//if (!User.Identity.IsAuthenticated)
//{
// return Unauthorized(_repository.ErrorDescription(HttpStatusCode.Unauthorized));
//}
if (project != null)
{
var projectModel = _mapper.Map <Project>(project);
_repository.CreateProject(projectModel);
if (_repository.SaveChanges())
{
var projectDto = _mapper.Map <ProjectReadDTO>(projectModel);
_logger.LogInformation("Creating project" + projectDto.Name + ".");
return(CreatedAtRoute(new { Id = projectDto.Id }, projectDto));
}
else
{
return(StatusCode(500, new { message = "Internal Server error 500. Something went wrong" }));
}
}
else
{
_logger.LogError("Project " + project.Name + "can't be created.");
return(NotFound(_repository.ErrorDescription(HttpStatusCode.NotFound)));
}
}
public async Task Create_ThanResponseWithCode201AndCorrespondedBody()
{
var httpResponseTeams = await client.GetAsync($"api/teams");
var stringResponseTeams = await httpResponseTeams.Content.ReadAsStringAsync();
var teams = JsonConvert.DeserializeObject <ICollection <TeamDTO> >(stringResponseTeams);
var httpResponseUsers = await client.GetAsync($"api/users");
var stringResponseUsers = await httpResponseUsers.Content.ReadAsStringAsync();
var users = JsonConvert.DeserializeObject <ICollection <UserDTO> >(stringResponseUsers);
var project = new ProjectCreateDTO
{
Name = "A",
Description = "BBB",
Deadline = DateTime.Now + new TimeSpan(1, 0, 0, 0),
AuthorId = users.Max(u => u.Id),
TeamId = teams.Max(t => t.Id)
};
string jsonInString = JsonConvert.SerializeObject(project);
var httpResponse = await client.PostAsync("api/projects",
new StringContent(jsonInString, Encoding.UTF8, "application/json"));
var stringResponse = await httpResponse.Content.ReadAsStringAsync();
var createdProject = JsonConvert.DeserializeObject <ProjectDTO>(stringResponse);
await client.DeleteAsync($"api/projects/{createdProject.Id}");
Assert.Equal(HttpStatusCode.Created, httpResponse.StatusCode);
Assert.Equal(project.Name, createdProject.Name);
Assert.Equal(project.Description, createdProject.Description);
Assert.Equal(project.Deadline, createdProject.Deadline);
Assert.Equal(project.AuthorId, createdProject.Author.Id);
Assert.Equal(project.TeamId, createdProject.Team.Id);
}
public ActionResult Edit(ProjectCreateDTO req)
{
Response res = new Response();
if (ModelState.IsValid)
{
try
{
if (req.Id > 0)
{
res.Data = _projectRepository.Update(req, out string msg);
res.Message = msg;
}
else
{
var currentUser = OperatorProvider.Provider.GetCurrent();
req.R_Company_Id = currentUser.CompanyId.ToInt();
req.CreateDate = DateTime.Now;
res.Data = _projectRepository.Create(req, out string msg);
res.Message = msg;
}
}
catch (Exception ex)
{
res.Message = ex.Message;
}
}
else
{
res.Data = false;
res.Message = string.Join(",", ModelState
.SelectMany(ms => ms.Value.Errors)
.Select(e => e.ErrorMessage));
}
return(Json(res, JsonRequestBehavior.DenyGet));
}
public async Task <Response <ProjectDTO> > Create(Guid userId, Guid teamId, ProjectCreateDTO dto, bool sendInvites = true)
{
var entity = new ProjectModel
{
Name = dto.Name,
TeamId = teamId,
CreatedDate = DateTime.UtcNow,
ColorHex = dto.ColorHex,
CreatorId = userId
};
entity = await _repository.Create(entity);
await _projectsUsersRepository.AddProjectUser(entity.Id, userId, MembershipStatus.SuperAdmin);
await _membershipService.InviteUsers(entity.Id, InviteEntityType.Project, userId, dto.Emails, sendInvites);
var result = _mapper.Map <ProjectModel, ProjectDTO>(entity);
return(new Response <ProjectDTO>
{
Data = result
});
}
public async Task <Response <ProjectDTO> > Create([FromQuery, Required] Guid teamId, [FromBody] ProjectCreateDTO dto)
{
return(await _handler.Create(teamId, dto, User));
}
public async Task <Response <SignUpStepDTO <ProjectDTO> > > SignUpProject(Guid userId, ProjectCreateDTO dto)
{
var step = await _repository.GetRegistrationStepByUserId(userId);
var stepValidate = ValidateStep <ProjectDTO>(step, RegistrationStep.ProjectCreated);
if (!stepValidate.IsSuccess)
{
return(stepValidate);
}
if (step.Status == MembershipStatus.Member)
{
return(new ForbiddenErrorResponse <SignUpStepDTO <ProjectDTO> >(new Error
{
Code = ErrorCodes.Security.Forbidden,
Message = ErrorMessages.Security.Forbidden
}));
}
var teamPage = await _teamsProvider.GetUserTeams(userId, new PageModel());
var team = teamPage.Data.Items.FirstOrDefault();
if (team == null)
{
step = await _repository.SetRegistrationStep(userId, RegistrationStep.UsernameEntered);
return(new BusinessConflictErrorResponse <SignUpStepDTO <ProjectDTO> >(new []
{
new Error
{
Code = ErrorCodes.Business.InvalidRegistrationStep,
Message = ErrorMessages.Business.InvalidRegistrationStep
}
})
{
Data = new SignUpStepDTO <ProjectDTO>
{
RegistrationStep = _mapper.Map <UserRegistrationStepModel, UserRegistrationStepDTO>(step)
}
});
}
var project = await _projectsService.Create(userId, team.TeamId, dto, false);
if (project.IsSuccess)
{
step = await _repository.SetRegistrationStep(userId, RegistrationStep.ProjectCreated);
}
return(new Response <SignUpStepDTO <ProjectDTO> >
{
Data = new SignUpStepDTO <ProjectDTO>
{
RegistrationStep = _mapper.Map <UserRegistrationStepModel, UserRegistrationStepDTO>(step),
Data = project.Data
}
});
}
public async Task <ActionResult <ProjectDTO> > Create([FromBody] ProjectCreateDTO dto)
{
var project = await projectService.CreateProject(dto);
return(Created($"api/Projects/{project.Id}", project));
}
public ActionResult Create(ProjectCreateDTO form)
{
if (ModelState.IsValid)
{
string userID = User.Identity.GetUserId();
Project project;
// existing project
if (form.ProjectID > 0)
{
// refuse edit if user has no project access
if (!this.db.HasProjectAccess(form.ProjectID, userID))
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
project = this.db.Projects
.Where(p => p.ProjectID == form.ProjectID)
.Include(p => p.Rates).First();
if (project.Status == ProjectStatus.Completed)
{
return(this.RedirectToAction("Details", new { id = project.ProjectID }));
}
}
// new project
else
{
project = new Project();
}
// allow field edition only for owner and new projects
if (form.ProjectID == 0 || this.db.HasProjectRole(form.ProjectID, userID, Role.Owner))
{
project.Name = form.Name;
}
if (project.Rates == null)
{
project.Rates = new List <Rate>();
}
// if the rate is not already contained, add it and remove the old one for the current user
if (!project.Rates.Contains(form.Rate, new PropertyComparer <Rate, int>(r => r.RateID)))
{
this.db.Rates.Attach(form.Rate);
project.Rates.Add(form.Rate);
project.Rates.RemoveAll(r => r.UserID == userID);
}
// add a owner entry if the project is new
if (form.ProjectID == 0)
{
db.Projects.Add(project);
// save to get id
db.SaveChanges();
this.db.ProjectRoles.Add(new ProjectRole()
{
ProjectID = project.ProjectID, UserID = userID, Role = Role.Owner
});
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
// validation failed
ProjectCreate viewModel = this.getCreateViewModel(form);
return(View(viewModel));
}
}
public async Task <Response <SignUpStepDTO <ProjectDTO> > > SignUpProject(ProjectCreateDTO dto, ClaimsPrincipal claims)
{
var result = await _service.SignUpProject(claims.GetUserId(), dto);
return(result);
}
public async Task <Response <SignUpStepDTO <ProjectDTO> > > CreateProject([Required, FromBody] ProjectCreateDTO dto)
{
return(await _handler.SignUpProject(dto, User));
}
