Esempio n. 1
0
        public async Task <IActionResult> CreateProjectAdminByUserProjectIssue([FromRoute] string username, [FromRoute] string projectName, [FromBody] CreateProjectAdminRequest projectAdminRequest)
        {
            if (projectAdminRequest == null)
            {
                return(new BadRequestResult());
            }

            var project = await _projectService.GetProjectByUserAsync(username, projectName).ConfigureAwait(false);

            if (project == null)
            {
                return(new NotFoundResult());
            }

            if (HttpContext.GetUserId() != project.OwnerId)
            {
                return(Unauthorized());
            }

            var user = await _userService.GetUserByUserNameAsync(username).ConfigureAwait(false);

            if (user == null)
            {
                return(NotFound());
            }
            var admin = await _userService.GetUserByUserNameAsync(projectAdminRequest.UserName).ConfigureAwait(false);

            if (admin == null)
            {
                return(NotFound());
            }

            var projectAdmin = await _projectAdminService.GetProjectAdminAsync(project.Id, projectAdminRequest.UserName).ConfigureAwait(false);

            if (projectAdmin != null)
            {
                return(new ConflictResult());
            }

            var newProjectAdmin = new ProjectAdmin
            {
                ProjectId = project.Id,
                AdminId   = user.Id,
            };

            var created = await _projectAdminService.CreateProjectAdminAsync(newProjectAdmin).ConfigureAwait(false);

            var locationUri = _uriService.GetUri(username);

            if (created)
            {
                return(Created(locationUri, new Response <DragonflyUserResponse>(_mapper.Map <DragonflyUserResponse>(user))));
            }
            return(NotFound());
        }
Esempio n. 2
0
        public async Task <bool> DeleteProjectAdminAsync(Guid projectId, Guid adminId)
        {
            var projectAdmin = new ProjectAdmin {
                ProjectId = projectId, AdminId = adminId
            };

            _projectAdminRepository.Delete(projectAdmin);
            var deleted = await _projectAdminRepository.SaveAsync().ConfigureAwait(false);

            return(deleted > 0);
        }
Esempio n. 3
0
        public async Task <bool> CreateProjectAdminAsync(ProjectAdmin projectAdmin)
        {
            if (projectAdmin == null)
            {
                return(false);
            }

            await _projectAdminRepository.CreateAsync(projectAdmin).ConfigureAwait(false);

            var created = await _projectAdminRepository.SaveAsync().ConfigureAwait(false);

            return(created > 0);
        }
Esempio n. 4
0
        public async Task <ResultModel <bool> > AddAdminToProjectAsync(string userId, int projectId)
        {
            var user = await this.userManager.FindByIdAsync(userId);

            if (user == null)
            {
                return(new ResultModel <bool>
                {
                    Errors = new string[] { Errors.InvalidUserId },
                });
            }

            var project = await this.GetByIdAsync(projectId);

            if (project == null)
            {
                return(new ResultModel <bool>
                {
                    Errors = new string[] { Errors.InvalidProjectId },
                });
            }

            var projectAdmin = new ProjectAdmin()
            {
                User    = user,
                Project = project,
            };

            await this.dbContext.ProjectsAdmins.AddAsync(projectAdmin);

            await this.dbContext.SaveChangesAsync();

            await this.identityService.AddClaimToUserAsync(user.Id, Claims.Admin, projectId.ToString());

            return(new ResultModel <bool>
            {
                Success = true,
            });
        }