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