public ActionResult Update(int id, ProjectUpdate model) { if (!ModelState.IsValid) { var employeeList = new EmployeeRepo(); var customerList = new CustomerRepo(); model.Customers = customerList.GetCustomers(); model.Employees = employeeList.GetEmployees(); return(View(model)); } if (model.ProjectId != id) { ModelState.AddModelError("", "Id Mismatch"); return(View(model)); } var service = CreateProjectService(); if (service.UpdateProject(model)) { TempData["SaveResult"] = "The project has been updated."; return(RedirectToAction("Index")); } ModelState.AddModelError("", "Could not update the project."); return(View(model)); }
/// <summary> /// Deprecated and not currently referenced /// </summary> /// <param name="projectUpdate"></param> /// <returns></returns> public bool RecordProjectUpdate(ProjectUpdate projectUpdate) { try { List <StatusUpdate> updates = projectUpdate.StatusUpdates.ToList(); //__first make sure each StatusUpdate has necessary info' Guid projectUpdateId = Guid.NewGuid(); foreach (StatusUpdate statusUpdate in updates) { statusUpdate.ProjectUpdateID = projectUpdateId; } //__create new entry in ProjectUpdate table projectUpdate.ProjectUpdateID = projectUpdateId; context.ProjectUpdates.Add(projectUpdate); context.SaveChanges(); //__use existing method to record StatusUpdates RecordStatusUpdate(updates); } catch (Exception) { return(false); } return(true); }
public async Task <IActionResult> UpdateProject([FromBody][Required] ProjectUpdate project, [FromRoute] int projectId) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Project result = await _projectService.GetByIdAsync(projectId); if (result == null) { return(BadRequest("Project not found")); } if (!User.IsInRole("Admin")) { Student student = await _studentService.GetByIdAsync(Int32.Parse(User.Identity.Name)); if (student.Group.ProposedProject == null || !student.Group.ProposedProject.Equals(result)) { return(BadRequest("Not allowed")); } } await _projectService.UpdateProjectThroughRequestModelAsync(result, project, Int32.Parse(User.Identity.Name)); return(Ok()); }
public void List(string caption, ProjectUpdate update, bool displayDetails) { if (caption == null) { throw new ArgumentNullException(nameof(caption)); } if (update == null) { throw new ArgumentNullException(nameof(update)); } var dataRows = update.Packages.Select(p => { var data = new DataRow(() => { if (!displayDetails) { return new string[] {} } ; return(update.ProjectFiles.Select(f => new FileInfo(f).Name)); }); data.Values["Package"] = p.Name; data.Values["Current Version"] = p.CurrentVersion; data.Values["Updated Version"] = p.UpdatedVersion ?? "NOT FOUND"; return(data); }).ToArray(); var dataSet = new DataSet(dataRows); DataSetViewer.Display(caption, dataSet, _textWriter); }
public Response UpdateProject(ProjectUpdate project) { var result = RunInsertJson(project.images); if (result.valid) { var procedure = "sp_project_update"; using (var conn = new MySqlConnection(_connectionString)) { try { conn.Open(); var param = new DynamicParameters(); param.Add("INid", project.id); param.Add("INname", project.name); param.Add("INdescription", project.description); param.Add("INcontent", project.content); param.Add("INurl", project.url); var data = conn.QueryFirstOrDefault <Response>(procedure, param, commandType: System.Data.CommandType.StoredProcedure); return(data); } catch (Exception ex) { throw; } } } else { return(null); } }
public async Task UpdateProjectThroughRequestModelAsync(Project project, ProjectUpdate projectUpdate, int userId) { project.Approved = projectUpdate.Approved; project.ClientContact = projectUpdate.ClientContact; project.ClientEmail = projectUpdate.ClientEmail; project.ClientName = projectUpdate.ClientName; project.Comments = projectUpdate.Comments; project.Description = projectUpdate.Description; project.Difficulty = projectUpdate.Difficulty; project.IPType = projectUpdate.IPType; project.ProjectName = projectUpdate.ProjectName; project.Proposed = projectUpdate.Proposed; await UpdateAsync(project); if (project.AssignedGroup == null) { return; } NotificationContext notificationContext = new NotificationContext() { CreatedBy = await _context.Users.FindAsync(userId), Data = string.Format("The project assigned to your team has been updated"), NotificationType = NotificationType.SYSTEM, Time = DateTime.UtcNow }; await SendNotificationsToRangeOfStudentsAsync(notificationContext, project.AssignedGroup.Students); }
public static ProjectUpdate Create(ProjectUpdateBatch projectUpdateBatch) { var projectUpdate = new ProjectUpdate(projectUpdateBatch, ProjectStage.PlanningDesign, MakeTestName("Project Description"), ProjectLocationSimpleType.None, false); projectUpdateBatch.ProjectUpdate = projectUpdate; return(projectUpdate); }
public static void SetFrom(this Project project, ProjectUpdate update) { project.Title = update.Title; project.Description = update.Description; project.IsCompleted = update.IsCompleted; project.StartingDate = update.StartingDate; project.ClosingDate = update.ClosingDate; }
public static void GuessPhase(ref ProjectUpdate projectUpdate) { string stringToSearch = ""; stringToSearch += projectUpdate.Subject + " "; stringToSearch += projectUpdate.Body; projectUpdate.Phase = GuessPhase(stringToSearch).ToString(); }
public async Task EnsuresNonNullArguments() { var client = new ObservableProjectsClient(Substitute.For <IGitHubClient>()); var updateProject = new ProjectUpdate { Name = "someNewName" }; await Assert.ThrowsAsync <ArgumentNullException>(() => client.Update(1, null).ToTask()); }
public async Task <ActionResult> DeleteConfirmed(int id) { ProjectUpdate projectUpdate = await db.ProjectUpdates.FindAsync(id); db.ProjectUpdates.Remove(projectUpdate); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public IActionResult Update(ProjectUpdate project) { if (!ModelState.IsValid) { return(View(project)); } repository.Update(project); return(Redirect("~/")); }
public async Task PostsToCorrectURL() { var connection = Substitute.For <IApiConnection>(); var client = new ProjectsClient(connection); var updateProject = new ProjectUpdate(); await client.Update(1, updateProject); connection.Received().Patch <Project>(Arg.Is <Uri>(u => u.ToString() == "projects/1"), updateProject, "application/vnd.github.inertia-preview+json"); }
public static ProjectUpdate Create(ProjectUpdateBatch projectUpdateBatch) { var focusArea = TestFocusArea.Create(); var projectUpdate = new ProjectUpdate(projectUpdateBatch, ProjectStage.Planned, ProjectLocationSimpleType.None); projectUpdate.ProjectDescription = MakeTestName("Project Description"); projectUpdate.FocusArea = focusArea; projectUpdateBatch.ProjectUpdate = projectUpdate; return(projectUpdate); }
public async Task <Project> UpdateAsync(ProjectUpdate toUpdate, CancellationToken cancellationToken = default) { var project = await _context.Projects.SingleAsync(p => p.Id == toUpdate.Id, cancellationToken); project.UpdateFrom(toUpdate); project.UpdatedOn = DateTime.UtcNow; await _context.SaveChangesAsync(cancellationToken); return(project); }
// OK public StatusCodes InsertProjectUpdate(ProjectUpdateModel source, ClaimsIdentity identity, int projectId) { try { //get the project var _project = uow.ProjectRepository.FindById(projectId); if (_project == null) { return(StatusCodes.NOT_FOUND); } else { //check if current user is the projectId's creator //else return NOT ALLOWED long requestorUserId; try { requestorUserId = uow.UserRepository .SearchFor(e => e.Username == identity.Name) .Select(e => e.Id) .SingleOrDefault(); } catch (InvalidOperationException ex) { throw new InvalidOperationException("User lookup for requestor Id for project update creation failed", ex); } if (_project.User.Id != requestorUserId) { return(StatusCodes.NOT_AUTHORIZED); } var _projectUpdate = new ProjectUpdate() { ProjectId = projectId, AttachmentSetId = source.AttachmentSetId, Title = source.Title, Description = source.Description, WhenDateTime = DateTime.Now, }; uow.ProjectUpdateRepository.Insert(_projectUpdate, true); } return(StatusCodes.OK); } catch (Exception) { throw; } }
public Project Update(ProjectUpdate project) { var toEdit = context.Projects.SingleOrDefault(p => p.Id == project.Id); if (toEdit != null) { toEdit.SetFrom(project); context.SaveChanges(); } return(toEdit); }
public HttpResponseMessage UpdatePhase(ProjectUpdate projectUpdate) { try { DataAccess.ChangeProjectUpdatePhase(projectUpdate); } catch (Exception) { return(new HttpResponseMessage(HttpStatusCode.BadRequest)); } return(new HttpResponseMessage(HttpStatusCode.Accepted)); }
public void PostsToCorrectURL() { var gitHubClient = Substitute.For <IGitHubClient>(); var client = new ObservableProjectsClient(gitHubClient); var updateProject = new ProjectUpdate { Name = "someNewName" }; client.Update(1, updateProject); gitHubClient.Repository.Project.Received().Update(1, updateProject); }
public async Task <ActionResult> Edit([Bind(Include = "Id,ProjectId,Text,DateInserted")] ProjectUpdate projectUpdate) { if (ModelState.IsValid) { db.Entry(projectUpdate).State = EntityState.Modified; await db.SaveChangesAsync(); return(RedirectToAction("Index")); } ViewBag.ProjectId = new SelectList(db.Projects, "Id", "Title", projectUpdate.ProjectId); return(View(projectUpdate)); }
public async Task <IActionResult> CreateRequirement([FromBody] ProjectDetailsViewModel projectRequirement) { var user = await GetCurrentUserAsync(); var project = _context.Projects.Include(p => p.Updates).FirstOrDefault(x => x.Id == projectRequirement.ProjectId); List <NotificationUser> notificationUsers = _context.ProjectUser.Where(x => x.ProjectId == projectRequirement.ProjectId).Select(u => new NotificationUser { UserId = u.UserId }).ToList(); ProjectRequirement requirement = new ProjectRequirement { Project = project, Name = projectRequirement.RequirementName, Description = projectRequirement.RequirementDescription, Priority = projectRequirement.RequirementPriority, Category = projectRequirement.RequirementCategory }; ProjectUpdate projectUpdate = new ProjectUpdate { Title = "New Requirement Added", Description = "'" + projectRequirement.RequirementName + "' was added.", Date = DateTime.UtcNow, Type = UpdateType.Add }; project.Updates.Add(projectUpdate); _context.Requirements.Add(requirement); var requirementVm = _mapper.Map <RequirementViewModel>(requirement); Notification notification = new Notification { Title = "A new requirement was added to " + project.Name, Body = user.FirstName + " " + user.LastName + " added the following requirement to the " + project.Name + " project: " + requirementVm.Name + ".", Type = UpdateType.Add, Users = notificationUsers, UserLink = user.Id, ProjectLink = requirementVm.ProjectId, DateTime = DateTime.Now }; _context.Notifications.Add(notification); await _context.SaveChangesAsync(); return(Ok(new UpdateReqResponse { Requirement = requirementVm })); }
public IActionResult UpdateProject([FromBody] ProjectUpdate project) { if (!Request.Headers.ContainsKey("Authorization")) { return(Unauthorized()); } var data = _alphahomeService.UpdateProject(project); if (data.valid) { return(new JsonResult(data)); } return(BadRequest(data)); }
// GET: ProjectUpdates/Edit/5 public async Task <ActionResult> Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ProjectUpdate projectUpdate = await db.ProjectUpdates.FindAsync(id); if (projectUpdate == null) { return(HttpNotFound()); } return(View(projectUpdate)); }
public VersionControlSystemInfo UpdateRepositoryForProject(Project projectToUpdate) { var project = new ProjectUpdate { Id = projectToUpdate.VersionControlSystemInfo.ProjectId, Name = projectToUpdate.Name, Description = projectToUpdate.Info, Public = projectToUpdate.AccessLevel == AccessLevel.Public, VisibilityLevel = projectToUpdate.AccessLevel == AccessLevel.Public ? VisibilityLevel.Public : VisibilityLevel.Private }; var updatedProject = _gitLabClient.Projects.Update(project); return(new VersionControlSystemInfo(updatedProject.Id, new Uri(updatedProject.WebUrl))); }
public async Task UpdatesProject() { var project = await CreateRepositoryProjectHelper(_github, _context.RepositoryId); var projectUpdate = new ProjectUpdate { Name = "newName", State = ItemState.Closed }; var result = await _github.Repository.Project.Update(project.Id, projectUpdate); Assert.Equal("newName", result.Name); Assert.Equal(ItemState.Closed, result.State); Assert.Equal(project.Id, result.Id); }
public async Task <ActionResult> Create(ProjectUpdateViewModel viewModel) { if (ModelState.IsValid) { var update = new ProjectUpdate() { ProjectId = viewModel.ProjectId, Text = viewModel.Text, DateInserted = DateTime.Now }; db.ProjectUpdates.Add(update); await db.SaveChangesAsync(); return(RedirectToAction("Details", "Project", new { id = viewModel.ProjectId })); } return(View(viewModel)); }
public async Task <TransactionResult> SaveProjectUpdateTransaction(ProjectUpdateDTO projectUpdateDTO, string user) { try { AspNetUsers _user = await context.AspNetUsers.Where(u => u.UserName == user).FirstOrDefaultAsync(); Project _project = null; if (projectUpdateDTO.ProjectFK != null) { _project = await context.Project.FindAsync(projectUpdateDTO.ProjectFK); } if (_project.AspNetUsers != _user) { return(new TransactionResult(TransResult.Fail, "This is not your project", null)); } if (projectUpdateDTO.Id == null || projectUpdateDTO.Id == 0) { ProjectUpdate projectUpdate = new ProjectUpdate() { Project = _project, Message = projectUpdateDTO.Message, Date = DateTime.Now }; context.ProjectUpdate.Add(projectUpdate); await context.SaveChangesAsync(); return(new TransactionResult(TransResult.Success, "Success", null, projectUpdate.Id)); } else { ProjectUpdate projectUpdate = await context.ProjectUpdate.FindAsync(projectUpdateDTO.Id); projectUpdate.Project = _project; projectUpdate.Message = projectUpdateDTO.Message; projectUpdate.Date = DateTime.Now; await context.SaveChangesAsync(); return(new TransactionResult(TransResult.Success, "Success", null)); } } catch (Exception ex) { return(new TransactionResult(TransResult.Fail, ex.Message, ex)); } }
public IActionResult AddNewsToProject([FromBody] ProjectUpdate projectUpdate) { try { if (_projectService.AddNewsToProject(projectUpdate)) { return(Ok()); } else { return(null); } } catch (Exception ex) { Logger.LogException(Log, ex, MethodBase.GetCurrentMethod()); return(new StatusCodeResult(503)); } }
public void GetXmlTest() { string expected = @"<?xml version=""1.0"" encoding=""utf-8""?> <function controlid=""unittest""> <update> <PROJECT> <PROJECTID>P1234</PROJECTID> <NAME>hello world</NAME> </PROJECT> </update> </function>"; ProjectUpdate record = new ProjectUpdate("unittest") { ProjectId = "P1234", ProjectName = "hello world" }; this.CompareXml(expected, record); }
public async Task <ResponseEntity> updateProject(int?idProject = 0, ProjectUpdate projectUpdate = null, string token = "") { Project project = _projectRepository.GetSingleByIdAsync(idProject).Result; if (project == null) { return(new ResponseEntity(StatusCodeConstants.NOT_FOUND, "Project is not found", MessageConstants.MESSAGE_ERROR_404)); } project.alias = FuncUtilities.BestLower(projectUpdate.projectName); //project.creator = project.creator; project.creator = _userService.getUserByToken(token).Result.id; project.description = FuncUtilities.Base64Encode(projectUpdate.description); project.projectName = projectUpdate.projectName; var result = _projectRepository.UpdateAsync(idProject, project).Result; return(new ResponseEntity(StatusCodeConstants.OK, result, MessageConstants.MESSAGE_SUCCESS_200)); }
public async Task<ProjectUpdate.response> ProjectUpdate(ProjectUpdate.request request, CancellationToken? token = null) { return await SendAsync<ProjectUpdate.response>(request.ToXmlString(), token.GetValueOrDefault(CancellationToken.None)); }