public UpdateProjectView()
{
updateProjectViewModel = new UpdateProjectViewModel(this);
InitializeComponent();
this.DataContext = updateProjectViewModel;
}
public ActionResult UpdateProject(UpdateProjectViewModel model)
{
var storedModel = ProjectService.Get(model.ProjectId);
if (storedModel == null)
{
return(HttpNotFound());
}
if (ModelState.IsValid)
{
try
{
ProjectService.Update(new ProjectModel
{
ProjectId = model.ProjectId,
Name = model.Name,
Abbreviation = model.Abbreviation,
Customer = model.Customer
});
ViewBag._SuccessMessage = "Uspesne ste upravili projekt";
}
catch (Exception ex)
{
var message = "Something went wrong with project update, please try again later";
Log.Error(ex, message);
return(RedirectToAction(nameof(UpdateProject)));
}
}
var viewModel = Populate(storedModel);
return(View(viewModel));
}
public async Task <IActionResult> Update([FromBody] UpdateProjectViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(400, ModelState));
}
var result = await _service.Update(id : model.Id,
name : model.Name,
projectType : model.ProjectType,
start : model.Start,
end : model.End,
projectedEnd : model.ProjectedEnd,
isComplete : model.IsComplete);
if (!result)
{
return(StatusCode(400, new { Message = $"Unable to update Project: {model.Name}", Status = 400 }));
}
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
_logger.LogError(ex.StackTrace);
return(StatusCode(500));
}
}
public async Task <IActionResult> Update(UpdateProjectViewModel model, [FromRoute] string projectUrl)
{
if (ModelState.IsValid)
{
if (model.StartDate > model.DueDate)
{
ModelState.AddModelError("DueDate", "Due date cannot be before start date.");
return(View(model));
}
int userId = int.Parse(User.Claims.First(c => c.Type == "UserId").Value);
Project project = Database.Project
.Where(p => p.Url == projectUrl)
.FirstOrDefault();
int access = Database.ProjectAssignment
.Include(a => a.Role)
.Where(a => a.ProjectId == project.Id && a.AssigneeId == userId && a.Role.Name == "Creator")
.Count();
if (access != 1)
{
return(StatusCode(403));
}
string[] routeNames = { "create", "index", "delete" };
int urlCount = Database.Project
.Count(p => p.Url == model.Url && p.Id != project.Id);
if (urlCount == 0 && !routeNames.Contains(model.Url))
{
project.Name = model.Name;
project.Url = model.Url;
project.Overview = model.Overview;
project.StartDate = model.StartDate;
project.DueDate = model.DueDate;
project.ParentProjectId = model.ParentProjectId == 0 ? null : model.ParentProjectId;
ProjectActivity activity = new ProjectActivity
{
ProjectId = project.Id,
AuthorId = userId,
Content = $"Project information updated"
};
Database.ProjectActivity.Add(activity);
await Database.SaveChangesAsync();
return(RedirectToAction("Index", "Project", new { projectUrl = project.Url }));
}
else
{
ModelState.AddModelError("Url", "Such url is taken.");
}
}
return(View(model));
}
public UpdateProject(Project project)
{
InitializeComponent();
model = new UpdateProjectViewModel();
DataContext = model;
this.GetValue(project);
}
public async Task <IActionResult> UpdateProject([FromBody] UpdateProjectViewModel viewModel)
{
var project = await projectService.GetProjectInfo(viewModel.ProjectId);
var model = mapper.Map(viewModel, project);
await projectService.UpdateProject(model);
return(new OkResult());
}
public IActionResult Edit([FromBody] UpdateProjectViewModel updateProjectViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
projectAppService.Update(updateProjectViewModel);
return(Ok());
}
public IActionResult Edit(UpdateProjectViewModel updateProjectViewModel)
{
if (!ModelState.IsValid)
{
return(View(updateProjectViewModel));
}
projectAppService.Update(updateProjectViewModel);
return(RedirectToAction("Index"));
}
private UpdateProjectViewModel Populate(ProjectModel model)
{
var viewModel = new UpdateProjectViewModel
{
ProjectId = model.ProjectId,
Name = model.Name,
Abbreviation = model.Abbreviation,
Customer = model.Customer
};
return(viewModel);
}
public async Task <IActionResult> Update([FromForm] UpdateProjectViewModel model)
{
if (ModelState.IsValid)
{
var command = this.unitOfWork.Create <UpdateProjectCommand>();
await command.ExecuteAsync(model);
}
else
{
}
return(Redirect($"/Projects/Details/{model.Id}"));
}
public ActionResult Edit(UpdateProjectViewModel projectViewModel)
{
if (ModelState.IsValid)
{
var updatedProjectEntity = mapper.Map <UpdateProjectViewModel, Project>(projectViewModel);
dbContext.Entry(updatedProjectEntity).State = EntityState.Modified;
dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <IActionResult> Update([FromForm, Bind("ProjectId,Name,Description")] UpdateProjectViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var updateProjectRequest = new UpdateProjectRequest
{
ProjectId = model.ProjectId.Value,
Name = model.Name,
Description = model.Description
};
var response = await _projectApplicationService.Handle(updateProjectRequest);
return(RedirectToAction(nameof(Index)));
}
public async Task <CommandResult <bool> > UpdateProject([FromBody] UpdateProjectViewModel viewModel)
{
var updateProjectModel = _mapper.Map <WebSiteProjectModel>(viewModel);
var result = await _ProjectManager.UpdateProject(updateProjectModel);
if (result.IsSucceeded)
{
foreach (var image in viewModel.Images)
{
this.ConfirmFileAdded(image);
this.ConfirmImageAdded(image);
}
this.ConfirmFileAdded(viewModel.CoverImage);
this.ConfirmImageAdded(viewModel.CoverImage);
}
return(result);
}
public async Task <IActionResult> UpdateProject([FromBody] UpdateProjectViewModel model)
{
EnumProjectAccessRight projectAccessRight = await _getAccessUser.GetUserAccessRightProject(Convert.ToInt32(HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)), model.Id);
if (!HttpContext.User.IsInRole("admin") && projectAccessRight != EnumProjectAccessRight.Admin)
{
return(StatusCode(403, "Access Denied !"));
}
Result result = await _projectGateway.UpdateProject(model.Id, model.Name, model.Description, model.IsPublic);
if (result.ErrorMessage == "Project with this id not exists")
{
return(BadRequest(result.ErrorMessage));
}
if (result.ErrorMessage == "Project with this name already exists")
{
return(BadRequest(result.ErrorMessage));
}
return(Ok("Project has been updated"));
}
