Skip to content
Snippets Groups Projects
Select Git revision
  • master
1 result

206.nfa

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    ProjectRoleController.cs 6.50 KiB
    using Coscine.Action;
    using Coscine.Action.EventArgs;
    using Coscine.Action.Implementations.User;
    using Coscine.Api.Project.Models;
    using Coscine.Api.Project.ReturnObjects;
    using Coscine.ApiCommons;
    using Coscine.ApiCommons.Exceptions;
    using Coscine.ApiCommons.Factories;
    using Coscine.Database.Model;
    using Microsoft.AspNetCore.Mvc;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Coscine.Api.Project.Controllers
    {
        public class ProjectRoleController : Controller
        {
            private readonly Authenticator _authenticator;
            private readonly List<IUserAction> _userActions;
            private readonly ProjectRoleModel _projectRoleModel;
    
            public ProjectRoleController()
            {
                _authenticator = new Authenticator(this, Program.Configuration);
                _userActions = new List<IUserAction>()
                {
                    new SPGroupAction()
                };
                _projectRoleModel = new ProjectRoleModel();
            }
    
            [Route("[controller]/{projectId}")]
            public IActionResult Index(string projectId)
            {
                return Ok(_authenticator.ValidateAndExecute((user) =>
                {
                    UserModel userModel = new UserModel();
                    RoleModel roleModel = new RoleModel();
                    ProjectModel projectModel = new ProjectModel();
                    Guid.TryParse(projectId, out Guid projectIdGuid);
                    if (projectModel.OwnsProject(user, projectModel.GetById(projectIdGuid)))
                    {
                        return _projectRoleModel.GetAllWhere((projectRole) =>
                            (projectRole.ProjectId == projectIdGuid)
                        ).Select((projectRole) =>
                        {
                            User userInst = projectRole.User;
                            if (userInst == null)
                            {
                                userInst = userModel.GetById(projectRole.UserId);
                            }
                            Role role = projectRole.Role;
                            if (role == null)
                            {
                                role = roleModel.GetById(projectRole.RoleId);
                            }
                            return new ProjectRoleObject(projectRole.ProjectId, new UserObject(userInst.Id, userInst.DisplayName, userInst.EmailAddress), new RoleObject(role.Id, role.DisplayName));
                        });
                    }
                    else
                    {
                        throw new UnauthorizedAccessException("User is not allowed to list all users to the given project!");
                    }
                }));
            }
    
            //Get all roles for current user and given project
            [HttpGet("[controller]/project/{projectId}")]
            public IActionResult Get(string projectId)
            {
                return Ok(_authenticator.ValidateAndExecute((user) =>
                {
                    RoleModel roleModel = new RoleModel();
                    Guid.TryParse(projectId, out Guid projectIdGuid);
                    UserObject userObject = new UserObject(user.Id, user.DisplayName, user.EmailAddress);
    
                    return _projectRoleModel.GetAllWhere((projectRole) =>
                        (projectRole.UserId == user.Id &&
                        projectRole.ProjectId == projectIdGuid)
                    ).Select((projectRole) => {
                        if(projectRole.Role == null)
                        {
                            projectRole.Role = roleModel.GetById(projectRole.RoleId);
                        }
                        return new ProjectRoleObject(projectRole.RelationId, userObject, new RoleObject(projectRole.Role.Id, projectRole.Role.DisplayName));
                    });
                }));
            }
    
            [HttpPost("[controller]")]
            public IActionResult Set()
            {
                return Ok(_authenticator.ValidateAndExecute((user) =>
                {
                    ProjectRoleObject projectRoleObject = ObjectFactory<ProjectRoleObject>.DeserializeFromStream(Request.Body);
                    ProjectModel projectModel = new ProjectModel();
                    var project = projectModel.GetById(projectRoleObject.ProjectId);
                    RoleModel roleModel = new RoleModel();
                    var role = roleModel.GetById(projectRoleObject.Role.Id);
                    UserModel userModel = new UserModel();
                    var userToAdd = userModel.GetById(projectRoleObject.User.Id);
                    if (projectModel.OwnsProject(user, project))
                    {
                        FireEvents((userAction, userEventArgs) => userAction.OnUserSet(userToAdd, project, role, userEventArgs));
                        return _projectRoleModel.SetFromObject(projectRoleObject);
                    }
                    else
                    {
                        throw new NotAuthorizedException("The user is not authorized to store a project role to the given project!");
                    }
                }));
            }
    
            [HttpDelete("[controller]/project/{projectId}/user/{userId}/role/{roleId}")]
            public IActionResult Delete(Guid projectId, Guid userId, Guid roleId)
            {
                return Ok(_authenticator.ValidateAndExecute((user) =>
                {
                    ProjectModel projectModel = new ProjectModel();
                    if (projectModel.OwnsProject(user, projectModel.GetById(projectId)))
                    {
                        _projectRoleModel.CheckIfLastOwnerWillBeRemoved(roleId, projectId);
    
                        var project = projectModel.GetById(projectId);
                        UserModel userModel = new UserModel();
                        var userToRemove = userModel.GetById(userId);
                        FireEvents((userAction, userEventArgs) => userAction.OnUserDelete(userToRemove, project, userEventArgs));
    
                        return _projectRoleModel.Delete(_projectRoleModel.GetWhere((projectRole) =>
                                projectRole.ProjectId == projectId
                                && projectRole.UserId == userId
                                && projectRole.RoleId == roleId));
                    }
                    else
                    {
                        throw new NotAuthorizedException("The user is not authorized to delete a project role for the given project!");
                    }
                }));
            }
    
            private void FireEvents(Action<IUserAction, UserEventArgs> eventAction)
            {
                UserEventArgs userEventArgs = new UserEventArgs(Program.Configuration, new object[0]);
                foreach (var userAction in _userActions)
                {
                    eventAction(userAction, userEventArgs);
                }
            }
        }
    }