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)); }