public IActionResult Delete(int id)
{
var model = new ProjectUpdateModel();
model.Delete(id);
return(RedirectToAction("Index"));
}
public async Task <JsonResult> Update([FromBody] ProjectUpdateModel model)
{
int projectId = model.Project.Id;
int userId = int.Parse(User.Identity.Name);
// Проверяем доступ
var linkedProject = await _dbContext.GetLinkedAcceptedProject(projectId, userId)
.ConfigureAwait(false);
if (linkedProject == null || linkedProject.RoleId == 1)
{
throw new Exception(TextResource.API_NoAccess);
}
var project = await _dbContext.Projects.FirstOrDefaultAsync(x => x.Id == projectId)
.ConfigureAwait(false);
if (project == null)
{
throw new Exception(TextResource.API_NotExistProjectId);
}
project.Title = model.Project.Title;
project.Description = model.Project.Description;
await _dbContext.SaveChangesAsync()
.ConfigureAwait(false);
return(new JsonResult(new ProjectUpdateResponse {
project = project
}));
}
public async Task <int> UpdateByIdAsync(int projectId, ProjectUpdateModel mproject)
{
var project = _context.Projects.FirstOrDefault(c => c.ProjectId == projectId);
if (project == null)
{
throw new ExpectException("Could not find data which ProjectId equal to " + projectId);
}
//ProjectNo must be unique
var checkData = _context.Projects.Where(p => p.ProjectNo == mproject.ProjectNo &&
p.ProjectId != projectId).ToList();
if (checkData.Count > 0)
{
throw new ExpectException("The data which ProjectNo '" + mproject.ProjectNo + "' already exist in system");
}
//Get UserInfo
var user = _loginUser.GetLoginUserInfo();
project.ProjectName = mproject.ProjectName;
project.ProjectNo = mproject.ProjectNo;
project.Completed = mproject.Completed;
project.Modifier = user.UserName;
project.ModifiedDate = DateTime.Now;
await _context.SaveChangesAsync();
return(project.ProjectId);
}
public async Task <IHttpActionResult> UpdateList([FromBody] ProjectUpdateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _context.Users.FirstOrDefault(u => u.UserName.Equals(User.Identity.Name));
if (user == null)
{
return(BadRequest("Invalid user data"));
}
var list = user.Projects.FirstOrDefault(p => p.ProjectId.Equals(model.ProjectId));
if (list == null)
{
return(BadRequest());
}
list.Name = model.Name;
await _context.SaveChangesAsync();
return(Ok());
}
private static void MapProperty(CsvReader csv, ProjectUpdateModel project, _projectPropertyMap property)
{
// Get the property value and translate it if necessary (using the edit options)
var value = property.Translate(csv.GetField(property.Name));
if (!string.IsNullOrWhiteSpace(value))
{
try
{
object objValue;
// For some reason, have to treat floats differently in automapper. This might be a bug in automapper.
if (property.property.PropertyType.IsAssignableFrom(typeof(float?)))
{
objValue = PortfolioMapper.ExportMapper.Map <float?>(value);
}
else
{
objValue = PortfolioMapper.ExportMapper.Map(value, typeof(string), property.property.PropertyType);
}
// Set the property value on the project
property.property.SetValue(project, objValue);
}
catch (AutoMapperMappingException ame)
{
string msg = $"Error mapping property [{property.property.Name}] of type [{property.property.PropertyType.Name}], value is [{value}]";
throw new Exception(msg, ame);
}
}
}
public ICollection <Milestone> Resolve(ProjectUpdateModel source, Project destination, MilestoneEditModel[] sourceMember, ICollection <Milestone> destMember, ResolutionContext context)
{
ICollection <Milestone> result = new List <Milestone>();
// Remove
if (destMember != null)
{
foreach (var entity in destMember.ToList())
{
var portfolioContext = context.Items[nameof(PortfolioContext)] as PortfolioContext;
if (sourceMember == null || !sourceMember.Any(s => s.Id == entity.Id))
{
portfolioContext.Milestones.Remove(entity);
}
}
}
if (sourceMember != null && sourceMember.Length > 0)
{
foreach (var milestone in sourceMember)
{
Milestone entity = (milestone.Id > 0 ? destMember.FirstOrDefault(m => m.Id == milestone.Id) : null) ?? new Milestone();
context.Mapper.Map(milestone, entity);
result.Add(entity);
}
}
return(result);
}
public ActionResult EditProject([Bind] ProjectUpdateModel model)
{
if (model == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var project = context.Projects.Where(id => id.ProjectId
.Equals(model.ProjectId)).FirstOrDefault();
project.ProjectName = model.ProjectName;
project.ProjectCode = model.ProjectCode;
project.NatureOfIndustry = model.NatureOfIndustry;
try
{
context.Entry(project).State = EntityState.Modified;
context.SaveChanges();
TempData["Success"] = "Project Updated Successfully";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
catch (Exception ex)
{
TempData["Error"] = "Project Update Error";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
}
TempData["Error"] = "Project Update Error";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
public ActionResult DeleteProjectConfirmed(ProjectUpdateModel model)
{
if (model == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var project = context.Projects.Where(id => id.ProjectId
.Equals(model.ProjectId)).FirstOrDefault();
try
{
context.Projects.Remove(project);
context.SaveChanges();
TempData["Success"] = "Project Deleted Successfully";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
catch (Exception ex)
{
TempData["Error"] = "Project Delete Unsuccessful";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
}
TempData["Error"] = "Project Delete Unsuccessful";
return(RedirectToAction("ViewProjects", "SuperAdmin"));
}
public void TestTask(TaskModel testTask)
{
string message = string.Empty;
ProjectController projectController = new ProjectController();
ProjectUpdateModel projectResult = new ProjectUpdateModel();
UserUpdateModel userResult = AddEditUser();
ProjectModel testProject = GetTestProject();
TaskController taskc = new TaskController();
TaskUpdateModel tresult = new TaskUpdateModel();
testProject.Manager_ID = userResult.user.User_ID;
testProject.Manager_Name = userResult.user.First_Name + userResult.user.Last_Name;
projectResult = projectController.Post(testProject);
message = projectResult.status.Message;
Assert.AreEqual(NEW_PROJECT_SUCCESS, message);
testTask.Project_ID = projectResult.project.Project_ID;
testTask.Project_Name = projectResult.project.ProjectName;
testTask.User_ID = userResult.user.User_ID;
testTask.Task_ID = 0;
tresult = taskc.Post(testTask);
Assert.AreEqual(NEW_TASK_SUCCESS, tresult.status.Message);
TaskModel tasks = taskc.Get().Where(x => x.TaskName == testTask.TaskName).FirstOrDefault();
tresult = taskc.Post(tasks);
Assert.AreEqual(UPDATE_TASK_SUCCESS, tresult.status.Message);
}
public static async Task CreateProjectAsync(string portfolio, ProjectUpdateModel project)
{
var dto = await TestBackendAPIClient.GetAsync <GetProjectDTO <ProjectEditViewModel> >($"api/Projects/{portfolio}/newproject");
project.project_id = dto.Project.project_id;
await TestBackendAPIClient.PostAsync <ProjectUpdateModel>("api/Projects", project);
}
public IActionResult Edit(int id)
{
var model = new ProjectUpdateModel();
model.Load(id);
return(View(model));
}
public IActionResult Edit(ProjectUpdateModel model)
{
if (ModelState.IsValid)
{
//model.EditProject();
}
return(View(model));
}
public static async Task CreateProjectAsync(string portfolio, string title)
{
var project = new ProjectUpdateModel()
{
project_name = title,
phase = "phase0"
};
await CreateProjectAsync(portfolio, project);
}
public IActionResult Add(ProjectUpdateModel model)
{
if (ModelState.IsValid)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var path = model.GetUploadedImage(model.Image.FileName);
model.AddNewProject(path, userId);
}
return(View(model));
}
// 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 void Update(ProjectUpdateModel model, string email)
{
try
{
_projectRepository.Update(model, email);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task MapPeopleAsync(ProjectUpdateModel update, Project project)
{
project.Lead = await EnsureForAsync(update.oddlead, project.Lead, project.Reservation.Portfolio);
project.KeyContact1 = await EnsureForAsync(update.key_contact1, project.KeyContact1, project.Reservation.Portfolio);
project.KeyContact2 = await EnsureForAsync(update.key_contact2, project.KeyContact2, project.Reservation.Portfolio);
project.KeyContact3 = await EnsureForAsync(update.key_contact3, project.KeyContact3, project.Reservation.Portfolio);
await MapTeamMembersAsync(update, project);
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] ProjectUpdateModel mProject)
{
if (!ModelState.IsValid)
{
return(HttpBadRequest(ModelStateError()));
}
var projectId = await _projectRepository.UpdateByIdAsync(id, mProject);
return(CreatedAtRoute("GetByProjectIdAsync", new { controller = "Projects", projectId = projectId }, mProject));
}
public async Task<IResultModel> Update(ProjectUpdateModel model)
{
var entity = await _repository.GetAsync(model.Id);
if (entity == null)
return ResultModel.NotExists;
_mapper.Map(model, entity);
var result = await _repository.UpdateAsync(entity);
return ResultModel.Result(result);
}
public void Update(ProjectUpdateModel model, string email)
{
Project project = _context.Project.FirstOrDefault(p => p.Email == email && p.Id == model.Id);
if (project == null)
{
throw new Exception("Decline!!!");
}
project.Description = model.Description;
project.StartDate = model.StartDate;
project.EndDate = model.EndDate;
_context.Project.Update(project);
_context.SaveChanges();
}
public IActionResult Update([FromBody] ProjectUpdateModel model)
{
Request.Headers.TryGetValue("Authorization", out var token);
string email = _accountManager.GetEmailByToken(token);
try
{
_projectManager.Update(model, email);
return(Ok("Success!!!"));
}
catch (Exception e)
{
return(Conflict(e.Message));
}
}
public IActionResult Patch(Guid id, [FromBody] ProjectUpdateModel model)
{
var query = new GetProjectQuery(id);
var project = _bus.PublishQuery(query);
// validation
if (project == null)
{
return(NotFound());
}
var command = new UpdateProjectCommand(id, model.Title, model.Description);
_bus.PublishCommand(command);
return(Ok());
}
public void ProjectAddEditTest(ProjectModel testProject)
{
string message = string.Empty;
ProjectController projectController = new ProjectController();
ProjectUpdateModel projectResult = new ProjectUpdateModel();
UserUpdateModel userResult = AddTestUser();
testProject.Manager_ID = userResult.user.User_ID;
testProject.Manager_Name = userResult.user.First_Name + userResult.user.Last_Name;
projectResult = projectController.Post(testProject);
message = projectResult.status.Message;
Assert.AreEqual(NEW_PROJECT_SUCCESS, message);
testProject.Project_ID = projectResult.project.Project_ID;
Assert.AreEqual(EXISTING_PROJECT_SUCCESS, projectController.Post(testProject).status.Message);
Assert.IsNotNull(projectController.Get());
}
// OK
public StatusCodes EditProjectUpdate(ProjectUpdateModel source, ClaimsIdentity identity, int updateId)
{
try
{
var _projectUpdate = uow.ProjectUpdateRepository.FindById(updateId);
if (_projectUpdate == null)
{
return(StatusCodes.NOT_FOUND);
}
else
{
// update found. does the user that wishes to update it really is the project creator? check this here
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 (_projectUpdate.Project.UserId != requestorUserId)
{
return(StatusCodes.NOT_AUTHORIZED);
}
_projectUpdate.WhenDateTime = DateTime.Now;
_projectUpdate.Title = source.Title;
_projectUpdate.Description = source.Description;
uow.ProjectUpdateRepository.Update(_projectUpdate, true);
}
return(StatusCodes.OK);
}
catch (Exception)
{
throw;
}
}
public async Task UpdateProjectAsync(string projectId, ProjectUpdateModel projectUpdateModel)
{
var update = Builders <Project> .Update
.Set(databaseProject => databaseProject.Name, projectUpdateModel.Name)
.Set(databaseProject => databaseProject.Categorie, projectUpdateModel.Categorie)
.Set(databaseProject => databaseProject.Description, projectUpdateModel.Description)
.Set(databaseProject => databaseProject.Keywords, projectUpdateModel.Keywords)
.Set(databaseProject => databaseProject.Team, projectUpdateModel.Team)
.Set(databaseProject => databaseProject.LaunchDate, projectUpdateModel.LaunchDate)
.Set(databaseProject => databaseProject.IsLucratif, projectUpdateModel.IsLucratif)
.Set(databaseProject => databaseProject.IsDeclared, projectUpdateModel.IsDeclared);
await _projects.UpdateOneAsync(databaseProject =>
databaseProject.Id == projectId,
update
);
}
public IHttpActionResult UpdateProject([FromUri] int projectId, [FromBody] ProjectUpdateModel prjUpdateModel)
{
if (Request.Headers.Authorization == null)
{
return(Content(HttpStatusCode.Unauthorized, "Invalid token"));
}
var token = Request.Headers.Authorization.ToString();
var tokenString = token.Substring("Basic ".Length).Trim();
var project = _projectManager.GetProject(projectId);
if (_authorizer.GetTokenInfo(tokenString) == null)
{
return(Content(HttpStatusCode.Unauthorized, "Invalid token"));
}
if (project.Leader != _authorizer.GetTokenInfo(tokenString).UserId)
{
return(Content(HttpStatusCode.Unauthorized, "Invalid token"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (prjUpdateModel.PrjImage != null)
{
project.ProjectImage = prjUpdateModel.PrjImage;
}
if (prjUpdateModel.ProjectName != null)
{
project.ProjectName = prjUpdateModel.ProjectName;
}
if (prjUpdateModel.ProjectDescription != null)
{
project.ProjectDescription = prjUpdateModel.ProjectDescription;
}
if (prjUpdateModel.Tags != null)
{
_projectManager.AddTagsToProject(prjUpdateModel.Tags, project.ProjectId);
}
_projectManager.UpdateProject(project);
return(Ok(new ProjectPresentation(project, _userManager.GetMembers(project))));
}
public async Task <List <ProjectUpdateModel> > ImportProjectsAsync(MultipartFormDataStreamProvider files, PortfolioConfiguration config, ProjectEditOptionsModel options)
{
var projects = new List <ProjectUpdateModel>();
var optionsProperties = typeof(ProjectEditOptionsModel).GetProperties().Select(p => new _optionsPropertyMap(p, options)).ToList();;
var projectProperties = typeof(ProjectUpdateModel).GetProperties().Select(p => new _projectPropertyMap(p, config)).ToList();
foreach (var file in files.FileData)
{
using (var reader = new StreamReader(file.LocalFileName))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
if (await csv.ReadAsync())
{
if (csv.ReadHeader())
{
// Go through the header and get the properties used in the import
List <_projectPropertyMap> headerProperties = new List <_projectPropertyMap>();
foreach (var h in csv.HeaderRecord)
{
var property = projectProperties.SingleOrDefault(p => h == p.Name);
if (property != null)
{
property.optionsProperty = optionsProperties.SingleOrDefault(op => op.JsonPropertyName == property.JsonPropertyName);
headerProperties.Add(property);
}
}
// Read in the project records
while (await csv.ReadAsync())
{
var project = new ProjectUpdateModel();
foreach (var property in headerProperties)
{
MapProperty(csv, project, property);
}
projects.Add(project);
}
}
}
}
}
return(projects);
}
private async Task MapTeamMembersAsync(ProjectUpdateModel update, Project project)
{
if (project.People == null)
{
project.People = new List <Person>();
}
else
{
project.People.Clear();
}
if (update?.team != null && update.team.Length > 0)
{
foreach (var id in update.team)
{
var person = await EnsurePersonForPrincipalName(id, project.Reservation.Portfolio);
if (person != null)
{
project.People.Add(person);
}
}
}
}
public async Task UpdateProjectAsync(ProjectUpdateModel update)
{
try
{
var context = ServiceContext.PortfolioContext;
// Load and map the project
await projectService.UpdateProject(update, permissionCallback : ServiceContext.AssertEditor);
}
catch (AutoMapperMappingException amex)
{
if (amex.InnerException is ProjectDataValidationException)
{
var resp = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = amex.InnerException.Message
};
throw new HttpResponseException(resp);
}
else
{
throw amex;
}
}
}
public HttpResponseMessage InsertOrEditProjectUpdate(ProjectUpdateModel projectUpdate, int projectId, int updateId = 0)
{
if (!ModelState.IsValid || projectId <= 0 || updateId < 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var identity = User.Identity as ClaimsIdentity;
using (var s = new ProjectUpdateRepository())
{
var httpStatusCode = HttpStatusCode.Created;
//insert project update
if (updateId.Equals(0))
{
ProjectUpdateRepository.StatusCodes hasInserted = s.InsertProjectUpdate(projectUpdate, identity, projectId);
switch (hasInserted)
{
//project creator not found
case ProjectUpdateRepository.StatusCodes.NOT_FOUND:
httpStatusCode = HttpStatusCode.NotFound;
break;
//not authorized to insert a project update to this project - you are not the project creator
case ProjectUpdateRepository.StatusCodes.NOT_AUTHORIZED:
httpStatusCode = HttpStatusCode.MethodNotAllowed;
break;
//project update inserted ok
case ProjectUpdateRepository.StatusCodes.OK:
httpStatusCode = HttpStatusCode.Created;
break;
}
}
//update existing project update
else
{
ProjectUpdateRepository.StatusCodes hasUpdated = s.EditProjectUpdate(projectUpdate, identity, updateId);
switch (hasUpdated)
{
//project update not found
case ProjectUpdateRepository.StatusCodes.NOT_FOUND:
httpStatusCode = HttpStatusCode.NotFound;
break;
//not authorized to update this project update
case ProjectUpdateRepository.StatusCodes.NOT_AUTHORIZED:
httpStatusCode = HttpStatusCode.MethodNotAllowed;
break;
//project update edited ok
case ProjectUpdateRepository.StatusCodes.OK:
httpStatusCode = HttpStatusCode.OK;
break;
}
}
return(Request.CreateResponse(httpStatusCode));
}
}
