public virtual JsonResult CreateTask(
[DataSourceRequest] DataSourceRequest request,
ProjectDetailsViewModel task)
{
var projectId = int.Parse(this.Session["ProjectId"].ToString());
if (this.ModelState.IsValid)
{
var taskdb = new SubTask()
{
ProjectId = projectId,
Title = task.Title,
ParentId = task.ParentTaskId,
Start = task.Start,
End = task.End,
PercentComplete = 0,
Price = 0,
IsUserNotified = false
};
this.subTaskService.Add(taskdb);
task.TaskId = taskdb.Id;
task.ParentTaskId = taskdb.ParentId;
}
return this.Json(new[] { task }.ToDataSourceResult(request, this.ModelState));
}
public ActionResult ProjectDetails(int?projectId)
{
if (projectId == null)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
var project = (from p in DbContext.Projects
where p.Id == projectId
select p).FirstOrDefault();
var model = new ProjectDetailsViewModel()
{
Id = project.Id,
Name = project.Name,
Details = project.Details,
Tickets = project.Tickets,
DateCreated = project.DateCreated,
DateUpdated = project.DateUpdated,
Users = project.Users
};
return(View(model));
}
public ProjectDetailsDialog()
{
InitializeComponent();
DataContext = new ProjectDetailsViewModel();
}
public async Task <IActionResult> UpdateTask([FromBody] ProjectDetailsViewModel projectTask)
{
_ = ModelState;
var user = await GetCurrentUserAsync();
var task = _context.Tasks.Include(t => t.SubTasks).Include(u => u.Users).FirstOrDefault(ta => ta.Id == projectTask.TaskId);
var project = _context.Projects.Include(p => p.Updates).FirstOrDefault(x => x.Id == projectTask.ProjectId);
List <NotificationUser> notificationUsers = _context.ProjectUser.Where(x => x.ProjectId == projectTask.ProjectId).Select(u => new NotificationUser {
UserId = u.UserId
}).ToList();
List <TaskUser> selectedUsers = new List <TaskUser>();
if (projectTask.Users != null)
{
selectedUsers = projectTask.Users.Where(u => u.IsSelected).Select(u => new TaskUser {
UserId = u.UserId, Username = u.Username
}).ToList();
}
//List<SubTask> subTasksDb = _mapper.Map<ICollection<SubTaskViewModel>, List<SubTask>>(projectTask.SubTasks);
foreach (var st in projectTask.SubTasks)
{
if (st.Id == 0)
{
var subTask = _mapper.Map <SubTask>(st);
task.SubTasks.Add(subTask);
}
}
task.Name = projectTask.TaskName;
task.Description = projectTask.TaskDescription;
//task.SubTasks = subTasksDb;
task.Users = selectedUsers;
ProjectUpdate projectUpdate = new ProjectUpdate
{
Title = "Task Edited",
Description = "'" + projectTask.TaskName + "' was edited.",
Date = DateTime.UtcNow,
Type = UpdateType.Edit
};
Notification notification = new Notification
{
Title = "A task was updated in " + project.Name,
Body = user.FirstName + " " + user.LastName + " updated the following task in the " + project.Name + " project: " + projectTask.TaskName + ".",
Type = UpdateType.Edit,
Users = notificationUsers,
UserLink = user.Id,
ProjectLink = projectTask.ProjectId,
DateTime = DateTime.Now
};
_context.Notifications.Add(notification);
var requirementTask = _mapper.Map <RequirementTaskViewModel>(task);
List <SubTaskViewModel> subTasks = _mapper.Map <ICollection <SubTask>, List <SubTaskViewModel> >(task.SubTasks);
List <TaskUserViewModel> users = _mapper.Map <ICollection <TaskUser>, List <TaskUserViewModel> >(task.Users);
project.Updates.Add(projectUpdate);
await _context.SaveChangesAsync();
return(Ok(new CreateTaskResponse
{
Id = requirementTask.Id,
Name = requirementTask.Name,
Description = requirementTask.Description,
ProjectRequirementId = requirementTask.ProjectRequirementId,
Status = requirementTask.Status,
SubTasks = subTasks,
Users = users
}));
}
public void RerunProjectMetrics(ProjectDetailsViewModel viewModel)
{
Analyze(viewModel);
}
public void CreateIgnoreFile(ProjectDetailsViewModel projectDetails)
{
codebaseService.WriteIgnoreFile(projectDetails.ProjectFolder, projectDetails.FilesToIgnore);
}
public CSharpCollectionViewStub(ProjectDetailsViewModel details)
{
ProjectDetails = details;
}
private static void ClearAllCodes(ProjectDetailsViewModel vm)
{
vm.FieldOfResearchCode = null;
vm.SocioEconomicObjectiveCode = null;
}
public void EntityUpdated(projectList updatedEntities)
{
using (var db = new ApplicationDbContext())
{
Trace.WriteLine("Updated Project");
foreach (var tuple in updatedEntities)
{
switch (tuple.Item1)
{
case EntityState.Modified:
{
var dbProject = db.Projects.Find(tuple.Item2.Id);
if (dbProject == null)
{
continue; //Project has been deleted
}
//Update Project Details box
var detailsViewModel = new ProjectDetailsViewModel(dbProject);
Clients.Group(LiveUpdateHelper.GroupName(ViewModelDataType.Project,
ActionType.Details, dbProject.Id))
.UpdateData(ViewModelDataType.Project.ToString(),
ActionType.Details.ToString(), detailsViewModel);
//Update Projects List
var projectItemViewModel = new ProjectItemViewModel(dbProject);
Clients.Group(LiveUpdateHelper.GroupName(ViewModelDataType.Project,
ActionType.Index, dbProject.Id))
.UpdateItemData(ViewModelDataType.Project.ToString(),
ActionType.Index.ToString(), projectItemViewModel);
//Update Sprint Board
foreach (var team in dbProject.Teams)
{
var thisSprint = dbProject.GetThisSprint();
var thisProjSprint = new ProjectSprintViewModel()
{
ProjectId = dbProject.Id,
ProjectName = dbProject.Title,
TeamName = team.Team.TeamName,
SprintItteration = thisSprint.Iteration,
SprintStartDate = thisSprint.StartDate,
SprintEndDate = thisSprint.EndDate,
Features = new List <SprintFeatures>()
};
//Add features to view model
foreach (var feat in thisSprint.Features.OrderBy(f => f.Priority))
{
thisProjSprint.Features.Add(new SprintFeatures()
{
FeatureId = feat.Id,
FeatureName = feat.Title,
FeatureDescription = feat.Description,
TasksNotStarted =
feat.Tasks.Where(t => t.State == EnumTaskState.NotStarted)
.OrderBy(p => p.Priority)
.Select(t => new TaskItemViewModel(t))
.ToList(),
TasksInProgress =
feat.Tasks.Where(t => t.State == EnumTaskState.InProgress)
.OrderBy(p => p.Priority)
.Select(t => new TaskItemViewModel(t))
.ToList(),
TasksDone =
feat.Tasks.Where(t => t.State == EnumTaskState.Done)
.OrderBy(p => p.Priority)
.Select(t => new TaskItemViewModel(t))
.ToList()
});
}
//Push to group
Clients.Group(LiveUpdateHelper.GroupName(ViewModelDataType.Sprint, ActionType.Details, dbProject.Id))
.UpdateItemData(ViewModelDataType.Sprint.ToString(), ActionType.Index.ToString(), thisProjSprint);
}
}
break;
case EntityState.Added:
{
//Find owner and push add
var dbProject = db.Projects.Find(tuple.Item2.Id);
if (dbProject == null)
{
continue; //Project has been deleted
}
var projectItemViewModel = new ProjectItemViewModel(dbProject);
var group = Clients.Group(LiveUpdateHelper.GroupName(dbProject.User_Id));
group.AddData(ViewModelDataType.Project.ToString(),
ActionType.Index.ToString(), projectItemViewModel);
}
break;
case EntityState.Deleted:
{
//Find owner and push delete
if (tuple.Item2 != null)
{
var group = Clients.Group(LiveUpdateHelper.GroupName(ViewModelDataType.Project, ActionType.Index, tuple.Item2.Id));
group.RemoveData(ViewModelDataType.Project.ToString(),
ActionType.Index.ToString(), tuple.Item2.Id);
}
}
break;
}
}
}
}
public ActionResult Details(int?id)
{
if (id == null)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Bad request!");
}
var project = projectsRepository.GetProjectById(id);
if (project == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, "Not found!");
}
if (!coursesRepository.IsInCourse(project.CourseId, User.Identity.GetUserId(), User.IsInRole("Administrator")))
{
throw new HttpException((int)HttpStatusCode.Forbidden, "Forbidden!");
}
if (coursesRepository.IsTeacherInCourse(project.CourseId, User.Identity.GetUserId(), User.IsInRole("Administrator")))
{
ViewBag.IsTeacher = true;
}
else
{
// Checking if the project hasn't started yet
if (DateTime.Now < project.Start && !User.IsInRole("Administrator") && !coursesRepository.IsAssistantTeacherInCourse(project.CourseId, User.Identity.GetUserId(), User.IsInRole("Administrator")))
{
throw new HttpException((int)HttpStatusCode.Forbidden, "Forbidden!");
}
}
double totalGrade = 0;
double totalGrades = 0;
double totalValue = 0;
foreach (var task in project.ProjectTasks)
{
var gradeProjectTask = task.GradeProjectTasks.Where(g => g.UserId == User.Identity.GetUserId()).FirstOrDefault();
if (gradeProjectTask != null)
{
totalGrade += task.GradeProjectTasks.Where(g => g.UserId == User.Identity.GetUserId()).FirstOrDefault().Grade *task.Value;
totalValue += task.Value;
totalGrades++;
}
}
if (totalGrades == project.ProjectTasks.Count && (project.ProjectTasks.Count > 0))
{
ViewBag.Grade = Math.Round(totalGrade / totalValue, 2);
}
else
{
ViewBag.Grade = "All tasks haven't been graded yet.";
}
var taskViewModels = new List <TaskViewModel>();
foreach (var task in project.ProjectTasks)
{
taskViewModels.Add(new TaskViewModel
{
BestSubmission = submissionsRepository.GetBestUserSubmissionForTask(task.Id, User.Identity.GetUserId()),
Task = task
});
}
var view = new ProjectDetailsViewModel
{
Project = project,
Tasks = taskViewModels
};
return(View(view));
}
internal override void InitViewModel()
{
_vm = new ProjectDetailsViewModel(this);
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Project project = db.Projects.Find(id);
var ticket = db.Tickets.Where(t => t.ProjectId == project.Id).ToList();
if (project == null)
{
return(View("Error"));
}
var pm = rHelp.IsUserInRole(User.Identity.GetUserId(), "Project_Manager") || rHelp.IsUserInRole(User.Identity.GetUserId(), "DemoProject_Manager");
if (pm)
{
if (!pHelp.IsUserOnProject(User.Identity.GetUserId(), project.Id))
{
return(View("Error"));
}
}
var dev = rHelp.IsUserInRole(User.Identity.GetUserId(), "Developer") || rHelp.IsUserInRole(User.Identity.GetUserId(), "DemoDeveloper");
if (dev)
{
if (!pHelp.IsUserOnProject(User.Identity.GetUserId(), project.Id))
{
return(View("Error"));
}
}
var sub = rHelp.IsUserInRole(User.Identity.GetUserId(), "Submitter") || rHelp.IsUserInRole(User.Identity.GetUserId(), "DemoSubmitter");
if (sub)
{
if (!pHelp.IsUserOnProject(User.Identity.GetUserId(), project.Id))
{
return(View("Error"));
}
}
ViewBag.ProjectId = id;
var AdminId = db.Users.ToList().Where(u => u.Id == User.Identity.GetUserId());
if (User.IsInRole("Admin") || User.IsInRole("DemoAdmin"))
{
ViewBag.AdminId = new SelectList(AdminId, "Id", "FullName", pHelp.ListUsersOnProjectIn2Roles((int)id, "Admin", "DemoAdmin").FirstOrDefault());
}
else
{
ViewBag.AdminId = new SelectList(rHelp.UsersIn2Roles("Admin", "DemoAdmin"), "Id", "FullName", pHelp.ListUsersOnProjectIn2Roles((int)id, "Admin", "DemoAdmin").FirstOrDefault());
}
ViewBag.ProjectManagerId = new SelectList(rHelp.UsersIn2Roles("Project_Manager", "DemoProject_Manager"), "Id", "FullName", pHelp.ListUsersOnProjectIn2Roles((int)id, "Project_Manager", "DemoProject_Manager").FirstOrDefault());
ViewBag.Developers = new MultiSelectList(rHelp.UsersIn2Roles("Developer", "DemoDeveloper"), "Id", "FullName", pHelp.ListUsersOnProjectIn2Roles((int)id, "Developer", "DemoDeveloper"));
ViewBag.Submitters = new MultiSelectList(rHelp.UsersIn2Roles("Submitter", "DemoSubmitter"), "Id", "FullName", pHelp.ListUsersOnProjectIn2Roles((int)id, "Submitter", "DemoSubmitter"));
var meh = new ProjectDetailsViewModel();
meh.Projects = project;
meh.TicketList = ticket;
return(View(meh));
}
public ActionResult Details(ProjectDetailsViewModel model)
{
var project = this.projectsService.GetById(model.Id);
if (this.ModelState.IsValid)
{
project.Title = model.Title;
project.Description = model.Description;
project.Priority = model.Priority;
project.Start = model.Start;
project.LeadId = model.LeadId;
this.projectsService.Update(project);
this.projectsService.AddAttachments(
project,
model.UploadedAttachments,
System.Web.HttpContext.Current.Server);
this.AddToastMessage(string.Empty, NotificationMessages.ProjectUpdated, ToastType.Success);
return this.RedirectToAction("Index");
}
return this.View(model);
}
public ProjectView(ProjectDetailsViewModel argVM)
: this()
{
this.ViewModel = argVM;
}
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Project project = await db.Projects.FindAsync(id);
if (project == null)
{
return(HttpNotFound());
}
var userAsp = _userManager.FindById(User.Identity.GetUserId());
User loggedInUser = null;
if (userAsp != null)
{
loggedInUser = db.Users.Where(x => x.AspNetUsersId.Equals(userAsp.Id)).FirstOrDefault();
}
var user = project.User;
var aspNetUser = user.AspNetUser;
var viewModel = new ProjectDetailsViewModel()
{
LoggedinId = loggedInUser == null ? 0 :loggedInUser.Id,
CreatorId = user.Id,
Title = project.Title,
Description = project.Description,
DueDate = project.DueDate,
Ratio = (int)(((double)project.CurrentFundAmount / project.TargetAmount) * 100),
TargetAmount = project.TargetAmount,
CreatorNoProjects = user.Projects.Count,
CurrentFund = project.CurrentFundAmount,
CreatorFullName = aspNetUser.FirstName + " " + aspNetUser.LastName,
CurrentBackerCount = project.BackerProjects.Count,
DateInserted = project.DateInserted,
Id = project.Id,
CreatorImageUrl = user.PhotoUrl,
ProjectImageUrl = project.PhotoUrl,
Comments = project.UserProjectComments.Select(c => new ProjectCommentViewModel()
{
CommentorFullName = c.User.AspNetUser.FirstName + " " + c.User.AspNetUser.LastName,
DateInserted = c.DateInserted,
Text = c.Text
}).ToList(),
Updates = project.ProjectUpdates.Select(u => new ProjectUpdateViewModel()
{
FullName = aspNetUser.FirstName + " " + aspNetUser.LastName,
DateInserted = u.DateInserted,
Text = u.Text
}).ToList(),
Backers = project.BackerProjects.Select(b => new BackerViewModel()
{
FullName = b.User.AspNetUser.FirstName + " " + b.User.AspNetUser.LastName,
NoProjects = b.User.BackerProjects.Count
}).ToList(),
Rewards = project.Rewards.Select(r => new RewardViewModel()
{
Id = project.Id,
ProjectId = project.Id,
CurrentAvailable = r.CurrentAvailable,
Description = r.Description,
MaxAvailable = r.MaxAvailable,
MaxAmount = r.MaxRequiredAmount,
MinAmount = r.MinRequiredAmount,
Title = r.Name
}
).ToList()
};
return(View(viewModel));
}
public static async Task <WSCreateNAVProject.Update_Result> UpdateNavProject(string Key, ProjectDetailsViewModel ProjectToUpdate, NAVWSConfigurations WSConfigurations)
{
WSCreateNAVProject.Update NAVUpdate = new WSCreateNAVProject.Update()
{
WSJob = new WSCreateNAVProject.WSJob()
{
Key = Key,
No = ProjectToUpdate.ProjectNo,
Description100 = ProjectToUpdate.Description,
Bill_to_Customer_No = ProjectToUpdate.ClientNo,
Estado_eSUCH = (Estado_eSUCH)((int)ProjectToUpdate.Status),
Estado_eSUCHSpecified = true,
RegionCode20 = ProjectToUpdate.RegionCode,
FunctionAreaCode20 = ProjectToUpdate.FunctionalAreaCode,
ResponsabilityCenterCode20 = ProjectToUpdate.ResponsabilityCenterCode,
Job_Posting_Group = ""
//Project_Manager = ProjectToUpdate.ProjectLeader,
//Person_Responsible = ProjectToUpdate.ProjectResponsible
}
};
//Configure NAV Client
EndpointAddress WS_URL = new EndpointAddress(WSConfigurations.WS_Job_URL.Replace("Company", WSConfigurations.WS_User_Company));
WSCreateNAVProject.WSJob_PortClient WS_Client = new WSCreateNAVProject.WSJob_PortClient(navWSBinding, WS_URL);
WS_Client.ClientCredentials.Windows.AllowedImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Delegation;
WS_Client.ClientCredentials.Windows.ClientCredential = new NetworkCredential(WSConfigurations.WS_User_Login, WSConfigurations.WS_User_Password, WSConfigurations.WS_User_Domain);
try
{
WSCreateNAVProject.Update_Result result = await WS_Client.UpdateAsync(NAVUpdate);
return(result);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IActionResult CreateProject()
{
var projectDetailsViewModel = new ProjectDetailsViewModel();
return(View(projectDetailsViewModel));
}
protected abstract ActionResult ReturnOnGetForProject(ProjectDetailsViewModel vm);
public static ProjectDetailsViewModel MapFrom(this ProjectDetailsViewModel model, Project entity)
{
if (entity == null || model == null)
{
return(model);
}
model.InjectFrom <SameNameWithRecursion>(entity);
if (entity.StartDate != null)
{
model.StartDate = entity.StartDate.Value.ToShortDateString();
}
if (entity.EndDate != null)
{
model.EndDate = entity.EndDate.Value.ToShortDateString();
}
if (entity.Funders.IsNotEmpty())
{
var funderTypes = Enum.GetValues(typeof(Funder)).Cast <Funder>().Where(o => entity.Funders.Any(q => q.Funder == o)).ToList();
foreach (var funderType in funderTypes)
{
var viewModel = model.Funders.FirstOrDefault(o => o.Funder == funderType);
if (viewModel == null)
{
continue;
}
var funder = entity.Funders.First(o => o.Funder == funderType);
viewModel.IsFunded = true;
viewModel.GrantNumber = funder.GrantNumber;
}
}
if (entity.SocioEconomicObjectives.IsNotEmpty())
{
var newObjectives = (entity.SocioEconomicObjectives.Where(o => !model.SocioEconomicObjectives
.Any(q => o.SocioEconomicObjective.Id == q.Code.Id))
.Select(o => (ProjectSocioEconomicObjective) new ProjectSocioEconomicObjective().InjectFrom(o)))
.ToList();
if (newObjectives.IsNotEmpty())
{
model.SocioEconomicObjectives.AddRange(newObjectives);
}
}
if (!entity.FieldsOfResearch.IsNotEmpty())
{
return(model);
}
var newResearchList = (from o in entity.FieldsOfResearch
where !model.FieldsOfResearch.Any(q => o.FieldOfResearch.Id == q.Code.Id)
select(ProjectFieldOfResearch) new ProjectFieldOfResearch().InjectFrom(o)).ToList();
if (newResearchList.IsNotEmpty())
{
model.FieldsOfResearch.AddRange(newResearchList);
}
return(model);
}
public void Analyze(ProjectDetailsViewModel viewModel)
{
CodeBase.SourceType = viewModel.RepositorySourceType;
CodeBase.Name = viewModel.ProjectName;
CodeBase = analysisService.Analyze(BuildArguments(viewModel));
}
protected override ActionResult ReturnOnGetForProject(ProjectDetailsViewModel vm)
{
return(View("Project", vm));
}
public void AutoSaveProject(ProjectDetailsViewModel projectDetails)
{
Apply(CodeBase, projectDetails);
autoSaveService.Save(CodeBase);
}
// GET: /<controller>/
public async Task <IActionResult> Index(int id)
{
var project = await _projectrepo.Get(id);
var mappedproject = _mapper.Map <Project, ProjectViewModel>(project);
var property = await _propertyrepo.Get(project.PropertyId);
var mappedproperty = _mapper.Map <Property, PropertyViewModel>(property);
var propertyOwner = await _siteUserManager.FindByIdAsync(project.PropertyOwnerId.ToString());
var draughtsman = await _siteUserManager.FindByIdAsync(project.DraughtsmanId.ToString());
//string siteid = "1732d901-82c3-4c48-9e02-3049c8ea2738";
var siteId = User.GetUserSiteIdAsGuid();
ProjectDetailsViewModel projectDetails = new ProjectDetailsViewModel
{
ProjectId = project.ProjectId,
ProjectName = project.ProjectName,
ProjectDescription = project.ProjectDescription,
MunicipalRefNo = project.MunicipalRefNo,
DateofSubmission = project.DateofSubmission,
MunicipalAssessmentOfficer = project.MunicipalAssessmentOfficer,
AssessmentOfficerEmail = project.AssessmentOfficerEmail,
AssessmentOfficerContactNo = project.AssessmentOfficerContactNo,
DateCreated = project.DateCreated,
DateModified = project.DateModified,
PropertyId = project.PropertyId,
DraughtsmanId = project.DraughtsmanId,
ProjectStateId = project.ProjectStateId,
SiteId = property.SiteId,
PropertyName = property.PropertyName,
PropertyAddress = property.PropertyAddress,
PropertyERF_LotNo = property.PropertyERF_LotNo,
IsComplex = property.IsComplex,
IsEstate = property.IsEstate,
Complex_Estate_No = property.Complex_Estate_No,
PropertySGNo = property.PropertySGNo,
PropertyOwnerFirstName = propertyOwner.FirstName,
PropertyOwnerLastName = propertyOwner.LastName,
PropertyOwnerEmail = propertyOwner.Email,
// PropertyOwnerContactNo = propertyOwner.PhoneNumber,
DraughtsmanFirstName = draughtsman.FirstName,
DraughtsmanLastName = draughtsman.LastName,
DraughtsmanEmail = draughtsman.Email,
// DraughtsmanContactNo = draughtsman.PhoneNumber,
};
//mappedproject.Property = mappedproperty;*/
var projectStatusItemViewModel = new ProjectStatusItemViewModel
{
ProjectId = id,
Project = projectDetails
// Project = mappedproject
};
var projectitemstatuses = await _repo.GetAllById(id);
var projectItemStatusList = new List <ProjectItemStatusViewModel> {
};
foreach (var projectitemstatus in projectitemstatuses)
{
var mappeditemstatus = _mapper.Map <ProjectItemStatus, ProjectItemStatusViewModel>(projectitemstatus);
projectItemStatusList.Add(mappeditemstatus);
}
projectStatusItemViewModel.ProjectItemStatuses = projectItemStatusList;
return(View(projectStatusItemViewModel));
}
public async Task <IActionResult> CreateTask([FromBody] ProjectDetailsViewModel projectTask)
{
var user = await GetCurrentUserAsync();
List <NotificationUser> notificationUsers = _context.ProjectUser.Where(x => x.ProjectId == projectTask.ProjectId).Select(u => new NotificationUser {
UserId = u.UserId
}).ToList();
List <TaskUser> selectedUsers = new List <TaskUser>();
if (projectTask.Users != null)
{
selectedUsers = projectTask.Users.Where(u => u.IsSelected).Select(u => new TaskUser {
UserId = u.UserId, Username = u.Username
}).ToList();
}
ICollection <SubTask> requirementTasks = _mapper.Map <List <SubTaskViewModel>, ICollection <SubTask> >(projectTask.SubTasks);
RequirementTask projTask = new RequirementTask
{
Name = projectTask.TaskName,
Description = projectTask.TaskDescription,
Users = selectedUsers,
ProjectRequirementId = projectTask.RequirementId,
SubTasks = requirementTasks
};
ProjectUpdate projectUpdate = new ProjectUpdate
{
Title = "New Task Added",
Description = "'" + projTask.Name + "' was added.",
Date = DateTime.UtcNow,
Type = UpdateType.Add
};
var project = _context.Projects.Include(p => p.Updates).FirstOrDefault(x => x.Id == projectTask.ProjectId);
project.Updates.Add(projectUpdate);
_context.Tasks.Add(projTask);
Notification notification = new Notification
{
Title = "A new task was added to " + project.Name,
Body = user.FirstName + " " + user.LastName + " added the following task to the " + project.Name + " project: " + projectTask.TaskName + ".",
Type = UpdateType.Add,
Users = notificationUsers,
UserLink = user.Id,
ProjectLink = projectTask.ProjectId,
DateTime = DateTime.Now
};
_context.Notifications.Add(notification);
await _context.SaveChangesAsync();
List <SubTaskViewModel> subTasks = _mapper.Map <ICollection <SubTask>, List <SubTaskViewModel> >(projTask.SubTasks);
List <TaskUserViewModel> users = _mapper.Map <ICollection <TaskUser>, List <TaskUserViewModel> >(projTask.Users);
return(Ok(new CreateTaskResponse
{
Id = projTask.Id,
Name = projTask.Name,
Description = projTask.Description,
ProjectRequirementId = projTask.ProjectRequirementId,
IsCompleted = false,
Status = projTask.Status,
SubTasks = subTasks,
Users = users,
//Update = projectUpdate
}));
}
public virtual JsonResult DestroyTask(
[DataSourceRequest] DataSourceRequest request,
ProjectDetailsViewModel task)
{
this.subTaskService.Delete(task.TaskId);
return this.Json(new[] { task }.ToDataSourceResult(request, this.ModelState));
}
public async Task <IActionResult> Details(int id)
{
var currentUser = await GetCurrentUserAsync();
var allUsers = _context.Users.Where(u => !u.Projects.Any(p => p.ProjectId == id)).Select(x => new ProjectUsersViewModel {
UserId = x.Id, Username = x.FirstName + " " + x.LastName
}).ToList();
if (_context.Projects.Any(p => p.Id == id))
{
var query = _context.Projects
.Include(u => u.Users)
.Include(p => p.Updates)
.Include(r => r.ProjectRequirements)
.ThenInclude(ProjectRequirement => ProjectRequirement.Tasks)
.ThenInclude(Task => Task.Users)
.Include(r => r.ProjectRequirements)
.ThenInclude(ProjectRequirement => ProjectRequirement.Tasks)
.ThenInclude(Task => Task.Comments)
.Include(r => r.ProjectRequirements)
.ThenInclude(ProjectRequirement => ProjectRequirement.Tasks)
.ThenInclude(Task => Task.SubTasks)
.Include(r => r.ProjectRequirements)
.ThenInclude(ProjectRequirement => ProjectRequirement.Comments)
.First(p => p.Id == id);
var project = _mapper.Map <ProjectViewModel>(query);
foreach (var req in project.ProjectRequirements)
{
foreach (var comment in req.Comments)
{
var userId = comment.UserId;
var commentPoster = _context.Users.FirstOrDefault(x => x.Id == userId);
comment.FirstName = commentPoster.FirstName;
comment.LastName = commentPoster.LastName;
comment.CurrentUser = currentUser.Id;
}
}
var projectViewModel = new ProjectViewModel
{
Id = project.Id,
Name = project.Name,
Description = project.Description,
Priority = project.Priority,
StartDate = project.StartDate,
Deadline = project.Deadline,
Status = project.Status,
ProjectRequirements = project.ProjectRequirements,
Users = project.Users,
Updates = project.Updates
};
var model = new ProjectDetailsViewModel()
{
Project = projectViewModel,
Users = GetAllUsersInProject(id),
AllUsers = allUsers,
CurrentUser = currentUser.Id
};
return(View(model));
}
this.AddAlertDanger($"The project with ID: {id} was not found, are you sure the ID was correct?");
return(RedirectToAction("Index"));
}
public virtual JsonResult UpdateTaskOnlyProgress(
[DataSourceRequest] DataSourceRequest request,
ProjectDetailsViewModel task)
{
if (this.ModelState.IsValid)
{
var taskDb = this.subTaskService.GetById(task.TaskId);
taskDb.PercentComplete = task.PercentComplete;
this.subTaskService.Update(taskDb);
task.TaskId = taskDb.Id;
task.ParentTaskId = taskDb.ParentId;
}
return this.Json(new[] { task }.ToDataSourceResult(request, this.ModelState));
}
public IActionResult Add(ProjectFormViewModel projectForm)
{
// For the Add, do not need to check for if the projectCollections are in the db
// because this Project is unique, there can be no duplicates.
var firebaseUser = _utils.GetCurrentUser(User);
// Check to ensure an unauthorized user (anonymous account) can not add a project
if (firebaseUser == null)
{
return(NotFound());
}
// Ensure the userId on the incoming project matches the person making the request
if (projectForm.Project.UserId != firebaseUser.Id)
{
return(BadRequest());
}
// Get all of this user's projects
var allProjects = _projectRepo.Get(firebaseUser.Id);
// see if the name of the incoming collection is in the db
var projectWithThatName = allProjects.Find(c => c.Name == projectForm.Project.Name);
// if there is a returned project, we can't add because name isn't unique for this user
if (projectWithThatName != null)
{
return(NotFound());
}
// Need to add the default requirement for the project here
projectForm.Project.CreationDate = DateTime.Now;
try
{
_projectRepo.Add(projectForm.Project);
try
{
// After we add the project, assign the project id to each projectCollection
foreach (var projectCollection in projectForm.ProjectCollections)
{
projectCollection.ProjectId = projectForm.Project.Id;
}
}
// The user attempted to enter Null for their ProjectCollecitons
catch (NullReferenceException e)
{
// Make a CollectionDetailsViewModel to pass the created collection into for deletion
var projectDetails = new ProjectDetailsViewModel
{
Project = projectForm.Project,
ProjectCollections = new List <ProjectCollection>()
};
// Remove the just entered collection from db
_projectRepo.Delete(projectDetails);
// Return a BadRequest
return(BadRequest());
}
// Add ProjectCollections
_projColRepo.Add(projectForm.ProjectCollections);
return(Ok(projectForm));
}
catch (DbUpdateException e)
{
return(NotFound());
}
}
private async Task <bool> GetProject(Guid projectId)
{
try
{
project = await ProjectsService.GetProject(projectId);
if (project != null)
{
var userWork = Common.Instance.GetUserWork().Where(x => x.WorkspaceId == Common.CurrentWorkspace.Id && x.ProjectId == project.Id);
if (userWork != null && userWork.Count() > 0)
{
lblProjectItems.Text = string.Format("Work ({0})", userWork.Count());
slProjectItems.IsVisible = true;
}
//check permissions to view all tasks
//bool userHasEditTaskPermissions = project.UserHasEditTaskPermissions(Common.CurrentWorkspace.UserID);
bool userHasEditTaskPermissions = false;
if (project.ProjectResources != null)
{
foreach (ProjectInsight.Models.Projects.ProjectResource r in project.ProjectResources)
{
if (
(
(r.IsProjectScheduler.HasValue && r.IsProjectScheduler.Value == true)
||
(r.IsProjectManager.HasValue && r.IsProjectManager.Value == true)
) &&
(r.User_Id.HasValue && r.User_Id.Value == Common.CurrentWorkspace.UserID)
)
{
userHasEditTaskPermissions = true;
}
}
}
var item = new ProjectDetailsViewModel
{
Id = project.Id.ToString(),
Title = project.ItemNumberFullAndNameDisplayPreference,
WorkPercentComplete = project.WorkPercentComplete.Value,
Status = project.ProjectStatus != null ? project.ProjectStatus.Name : "",
TasksCount = project.TaskCount ?? 0,
UserHasEditTaskPermissions = userHasEditTaskPermissions,
RefreshControls = true
};
//TODO IssuesCount property needed on Project model
try
{
var itemCounts = await ProjectsService.client.GetProjectItemCountsAsync(project.Id.Value);
if (itemCounts != null)
{
item.IssuesCount = itemCounts.IssueCount.Value;
item.TasksCount = itemCounts.TaskCount.Value;
}
//List<ProjectInsight.Models.Issues.Issue> issues = await IssuesService.client.GetByProjectAsync(project.Id.Value);
//item.IssuesCount = issues == null ? 0 : issues.Count();
}
catch (Exception ex)
{
}
item.Description = System.Text.RegularExpressions.Regex.Replace(project.Description, "<.*?>", String.Empty);
if (project.ProjectStatus != null)
{
if (string.IsNullOrEmpty(project.ProjectStatus.ChartColor))
{
item.StatusColor = ProjectInsightMobile.Helpers.ExtensionMethods.GetHexString((Color)Application.Current.Resources["LightBackgroundColor"]);
item.StatusFontColor = ProjectInsightMobile.Helpers.ExtensionMethods.GetHexString((Color)Application.Current.Resources["DarkGrayTextColor"]);
}
else
{
item.StatusColor = project.ProjectStatus.ChartColor;
item.StatusFontColor = ProjectInsightMobile.Helpers.ExtensionMethods.GetHexString((Color)Application.Current.Resources["WhiteTextColor"]);
}
}
string percentComplete = "0";
if (project.WorkPercentComplete != null)
{
percentComplete = project.WorkPercentComplete.Value.ToString();
}
item.Duration = project.DurationString;
item.Duration = String.Format("{0} ({1}% Complete)", project.DurationString, percentComplete);
if (project.StartDateTimeUserLocal != null)
{
item.StartDate = project.StartDateTimeUserLocal.Value;
}
if (project.EndDateTimeUserLocal != null)
{
item.EndDate = project.EndDateTimeUserLocal.Value;
}
item.Description = item.Description.Replace("<img ", "<img style='max-width: 100%;' ");
viewModel = item;
BindingContext = viewModel;
}
}
catch (Exception ex)
{
//AuthenticationService.Logout();
return(false);
}
return(true);
}
