Esempio n. 1
0
        public async Task <Object> UpdateProjectForOwner([FromRoute] string userId, [FromBody] AspNetProjects project)
        {
            using (var ctx = new AckeeCtx())
            {
                // Get the user.
                var user = ctx.Users.FirstOrDefault(u => u.Id == userId);

                // Get the UserProject
                var userProject = await ctx.UserProjects.FirstOrDefaultAsync(
                    up => up.UserId == userId &&
                    up.Project.ProjectID == project.ProjectID);

                // Get the project
                var existingProject = ctx.Projects.FirstOrDefault(p => p.ProjectID == project.ProjectID);

                // Return if project for user already exists or userId is null.
                if (user == null || userProject == null || user.Id != existingProject.Owner.Id || existingProject == null)
                {
                    return(BadRequest());
                }

                // Update the project
                if (!string.IsNullOrWhiteSpace(project.ProjectName))
                {
                    existingProject.ProjectName = project.ProjectName;
                }

                if (!string.IsNullOrWhiteSpace(project.ProjectDescription))
                {
                    existingProject.ProjectDescription = project.ProjectDescription;
                }

                // Save changes
                await ctx.SaveChangesAsync();

                return(true);
            }
        }
Esempio n. 2
0
        public async Task <ActionResult <bool> > AddAssigneeToTask([FromRoute] string projectId, [FromRoute] string taskName, [FromBody] string userId)
        {
            using (var ctx = new AckeeCtx())
            {
                var task = await ctx.Tasks.FirstOrDefaultAsync(t => t.TaskName == taskName && t.Project.ProjectID == projectId);

                var assignee = await ctx.ApplicationUser.FirstOrDefaultAsync(a => a.Id == userId);

                if (task == null || assignee == null)
                {
                    return(NotFound());
                }

                var userTask = new UserTask();
                userTask.UserID = assignee.Id;
                userTask.TaskID = task.TaskID;

                ctx.UserTasks.Add(userTask);
                await ctx.SaveChangesAsync();

                return(true);
            }
        }
Esempio n. 3
0
        public async Task <object> AddMilestoneToTask([FromRoute] string projectId, [FromRoute] string taskName, [FromBody] string milestoneId)
        {
            using (var ctx = new AckeeCtx())
            {
                var task = await ctx.Tasks.FirstOrDefaultAsync(t => t.TaskName == taskName && t.Project.ProjectID == projectId);

                var milestone = await ctx.Milestones.FirstOrDefaultAsync(m => m.MilestoneID == milestoneId);

                if (task == null || milestone == null)
                {
                    return(NotFound());
                }

                var milestoneTask = new MilestoneTask();
                milestoneTask.MilestoneID = milestone.MilestoneID;
                milestoneTask.TaskID      = task.TaskID;

                ctx.MilestoneTasks.Add(milestoneTask);
                await ctx.SaveChangesAsync();

                return(true);
            }
        }
Esempio n. 4
0
        public async Task <ActionResult <bool> > AddProjectMember(string projectId, string userEmail)
        {
            using (var ctx = new AckeeCtx())
            {
                var project = await ctx.Projects.FirstOrDefaultAsync(p => p.ProjectID == projectId);

                var user = await ctx.ApplicationUser.FirstOrDefaultAsync(u => u.Email == userEmail);

                if (user == null || project == null)
                {
                    return(NotFound());
                }

                var userProject = new UserProject();
                userProject.ProjectId = projectId;
                userProject.UserId    = user.Id;

                ctx.UserProjects.Add(userProject);
                await ctx.SaveChangesAsync();

                return(true);
            }
        }
Esempio n. 5
0
        public async Task <Object> UpdateMilestoneById([FromRoute] string milestoneId, [FromBody] AspNetMilestones updatedMilestone)
        {
            using (var ctx = new AckeeCtx())
            {
                if (string.IsNullOrEmpty(updatedMilestone.MilestoneName))
                {
                    return(BadRequest());
                }

                // Get the milestone
                var milestone = await ctx.Milestones.FirstOrDefaultAsync(m => m.MilestoneID == milestoneId);

                // Update the milestone
                milestone.MilestoneName = updatedMilestone.MilestoneName;
                milestone.Description   = updatedMilestone.Description;
                milestone.EndDate       = updatedMilestone.EndDate;
                milestone.Completed     = updatedMilestone.Completed;

                // Save changes
                await ctx.SaveChangesAsync();

                return(true);
            }
        }
Esempio n. 6
0
        public async Task <object> CreateProjectForOwner([FromRoute] string userId, [FromBody] AspNetProjects project)
        {
            using (var ctx = new AckeeCtx())
            {
                // Get the user.
                var user = ctx.Users.FirstOrDefault(u => u.Id == userId);

                var existingProject = await ctx.UserProjects.FirstOrDefaultAsync(
                    up => up.UserId == userId &&
                    up.Project.ProjectName == project.ProjectName);

                // Return if project for user already exists or userId is null.
                if (user == null || existingProject != null)
                {
                    return(BadRequest());
                }

                // Create the new project.
                project.Owner       = user;
                project.DateCreated = DateTime.Now;

                // Add project to DB.
                ctx.Projects.Add(project);

                var userProject = new UserProject()
                {
                    ProjectId = project.ProjectID,
                    UserId    = user.Id
                };

                ctx.UserProjects.Add(userProject);
                await ctx.SaveChangesAsync();

                return(ctx.Projects.FirstOrDefault(p => p.ProjectID == project.ProjectID));
            }
        }