ProjectController.cs

using Coscine.Action;
using Coscine.Action.EventArgs;
using Coscine.Action.Utils;
using Coscine.Api.Project.ParameterObjects;
using Coscine.ApiCommons;
using Coscine.Configuration;
using Coscine.Database.DataModel;
using Coscine.Database.Models;
using Coscine.Database.ReturnObjects;
using Coscine.Database.Util;
using Coscine.Logging;
using Coscine.Metadata;
using Coscine.ResourceTypes;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Coscine.Api.Project.Controllers
{
    /// <summary>
    /// This controller represents the actions which can be taken with a project object.
    /// </summary>
    [Authorize]
    public class ProjectController : Controller
    {
        private readonly Authenticator _authenticator;
        private readonly ProjectModel _projectModel;
        private readonly IConfiguration _configuration;
        private readonly Emitter _emitter;
        private readonly ActivatedFeaturesModel _activatedFeaturesModel;
        private readonly ProjectRoleModel _projectRoleModel;
        private readonly ProjectQuotaModel _projectQuotaModel;
        private readonly ResourceTypeModel _resourceTypeModel;
        private readonly CoscineLogger _coscineLogger;
        private readonly VisibilityModel _visibilityModel;
        private readonly InvitationModel _invitationModel;
        private readonly RoleModel _roleModel;
        private readonly UserModel _userModel;
        private readonly RdfStoreConnector _rdfStoreConnector;

        /// <summary>
        /// ProjectController constructor
        /// </summary>
        /// <param name="logger">Logger</param>
        public ProjectController(ILogger<ProjectController> logger)
        {
            _authenticator = new Authenticator(this, Program.Configuration);
            _configuration = Program.Configuration;
            _projectModel = new ProjectModel();
            _emitter = new Emitter(_configuration);
            _activatedFeaturesModel = new ActivatedFeaturesModel();
            _projectRoleModel = new ProjectRoleModel();
            _resourceTypeModel = new ResourceTypeModel();
            _projectQuotaModel = new ProjectQuotaModel();
            _coscineLogger = new CoscineLogger(logger);
            _visibilityModel = new VisibilityModel();
            _rdfStoreConnector = new RdfStoreConnector(Program.Configuration.GetString("coscine/local/virtuoso/additional/url"));
            _invitationModel = new InvitationModel();
            _roleModel = new RoleModel();
            _userModel = new UserModel();
        }

        /// <summary>
        /// Returns all available projects (including sub projects)
        /// </summary>
        /// <returns>OK</returns>
        [Route("[controller]")]
        public ActionResult<IEnumerable<ProjectObject>> Index()
        {
            var user = _authenticator.GetUser();
            var result = _projectModel.GetWithAccess(user, UserRoles.Member, UserRoles.Owner).ToList()
                .Select((project) => _projectModel.CreateReturnObjectFromDatabaseObject(project))
                .OrderBy(element => element.DisplayName);

            return Ok(result);
        }

        /// <summary>
        /// Retrieves all top level projects
        /// </summary>
        /// <returns>OK</returns>
        [Route("[controller]/-/topLevel")]
        public ActionResult<IEnumerable<ProjectObject>> GetTopLevelProjects()
        {
            var user = _authenticator.GetUser();
            var projects = _projectModel.GetTopLevelWithAccess(user, UserRoles.Member, UserRoles.Owner).ToList()
                .Select((project) => _projectModel.CreateReturnObjectFromDatabaseObject(project))
                .OrderBy(element => element.DisplayName);

            if (Request.Query != null && Request.Query["noanalyticslog"] != "true")
            {
                LogAnalyticsViewHome(projects.Select(x => x.Id.ToString()).ToList());
            }

            return Ok(projects);
        }

        /// <summary>
        /// This returns the project if the user has access to it
        /// </summary>
        /// <param name="id">Id of the project</param>
        /// <returns>OK or status code 401</returns>
        [HttpGet("[controller]/{id}")]
        public ActionResult<ProjectObject> Get(Guid id)
        {
            var user = _authenticator.GetUser();
            var project = _projectModel.GetById(id);
            if (_projectModel.HasAccess(user, project, UserRoles.Member, UserRoles.Owner))
            {
                var subProjectModel = new SubProjectModel();
                var subProjectRel = subProjectModel.GetAllWhere((subProject) => subProject.SubProjectId == project.Id && !project.Deleted);

                var parentProjectRelation = subProjectRel.FirstOrDefault();
                if (parentProjectRelation != null && _projectModel.HasAccess(user, parentProjectRelation.ProjectId, UserRoles.Member, UserRoles.Owner))
                {
                    return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project, parentProjectRelation.ProjectId));
                }
                return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project));
            }
            else
            {
                return Unauthorized($"User has no access to a project with id: {id}");
            }
        }

        /// <summary>
        /// This returns the project if the user has access to it
        /// </summary>
        /// <param name="slug">Slug of the project</param>
        /// <returns>OK or status code 401</returns>
        [HttpGet("[controller]/slug/{slug}")]
        public ActionResult<ProjectObject> GetBySlug(string slug)
        {
            var user = _authenticator.GetUser();
            var project = _projectModel.GetBySlug(slug);
            if (_projectModel.HasAccess(user, project, UserRoles.Member, UserRoles.Owner))
            {
                var subProjectModel = new SubProjectModel();
                var subProjectRel = subProjectModel.GetAllWhere((subProject) => subProject.SubProjectId == project.Id && !project.Deleted);

                var parentProjectRelation = subProjectRel.FirstOrDefault();
                if (parentProjectRelation != null && _projectModel.HasAccess(user, parentProjectRelation.ProjectId, UserRoles.Member, UserRoles.Owner))
                {
                    return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project, parentProjectRelation.ProjectId));
                }
                return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project));
            }
            else
            {
                return Unauthorized($"User has no access to a project with slug: {slug}");
            }
        }

        /// <summary>
        /// Gets all resources in a project
        /// </summary>
        /// <param name="id">Id of the project</param>
        /// <returns>JSON object or status code 401</returns>
        [HttpGet("[controller]/{id}/resources")]
        public ActionResult<IEnumerable<ResourceObject>> GetResources(Guid id)
        {
            var project = _projectModel.GetById(id);
            var user = _authenticator.GetUser();

            var resourceModel = new ResourceModel();
            var resourceTypeModel = new ResourceTypeModel();
            if (_projectModel.HasAccess(user, project, UserRoles.Member, UserRoles.Owner))
            {
                var resources = resourceModel.GetAllWhere((resource) =>
                        (from projectResource in resource.ProjectResources
                         where projectResource.ProjectId == project.Id
                         select projectResource).Any())
                        .Select((resource) => ResourceTypes.Helpers.CreateResourceReturnObject(resource)).OrderBy(element => element.DisplayName);
                if (Request.Query != null && Request.Query["noanalyticslog"] != "true")
                {
                    var projectObject = _projectModel.CreateReturnObjectFromDatabaseObject(_projectModel.GetById(project.Id));
                    LogAnalyticsViewProject(project, resources.ToList(), projectObject.Disciplines, projectObject.Organizations, user);
                }
                return Ok(resources);
            }
            else
            {
                return Unauthorized($"User has no access to a project with id: {id}");
            }
        }

        /// <summary>
        /// Updates a project
        /// </summary>
        /// <param name="id">Id of the project</param>
        /// <param name="projectObject">A Project Object</param>
        /// <returns>OK or status code 401</returns>
        [HttpPost("[controller]/{id}")]
        public IActionResult Update(Guid id, [FromBody] ProjectObject projectObject)
        {
            var user = _authenticator.GetUser();
            var project = _projectModel.GetById(id);
            if (_projectModel.HasAccess(user, project, UserRoles.Owner))
            {
                LogAnalyticsEditProject(project, _projectModel.GetMetadataCompleteness(projectObject), projectObject.Disciplines, projectObject.Organizations, user);
                return Ok(_projectModel.UpdateByObject(project, projectObject));
            }
            else
            {
                return Unauthorized("The user is not authorized to perform an update on the selected project!");
            }
        }

        /// <summary>
        /// Deletes a project
        /// </summary>
        /// <param name="id">Id of the project</param>
        /// <returns>JSON object or status code 401</returns>
        [HttpDelete("[controller]/{id}")]
        public IActionResult Delete(Guid id)
        {
            var user = _authenticator.GetUser();
            var project = _projectModel.GetById(id);
            if (_projectModel.HasAccess(user, project, UserRoles.Owner))
            {
                var projectObject = _projectModel.CreateReturnObjectFromDatabaseObject(_projectModel.GetById(project.Id));
                LogAnalyticsDeleteProject(project, projectObject.Disciplines, projectObject.Organizations, user);
                DeleteProject(project);
                return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project));
            }
            else
            {
                return Unauthorized("The user is not authorized to perform an update on the selected project!");
            }
        }

        /// <summary>
        /// Deletes the project
        /// </summary>
        /// <param name="project">Project</param>
        /// <param name="isHard">isHard</param>
        /// <param name="propagateAction">propagate Action</param>
        public void DeleteProject(Database.DataModel.Project project, bool isHard = false, bool propagateAction = true)
        {
            var subProjectModel = new SubProjectModel();
            foreach (var subProject in subProjectModel.GetAllWhere(
                (subProject) => subProject.ProjectId == project.Id
                                && (!subProject.SubProjectNavigation.Deleted || isHard)
            ))
            {
                Database.DataModel.Project subProjectObject;
                if (isHard)
                {
                    subProjectObject = _projectModel.GetByIdIncludingDeleted(subProject.SubProjectId);
                    subProjectModel.Delete(subProject);
                }
                else
                {
                    subProjectObject = _projectModel.GetById(subProject.SubProjectId);
                }
                DeleteProject(subProjectObject, isHard, propagateAction);
            }

            foreach (var subProject in subProjectModel.GetAllWhere((subProject) => subProject.SubProjectId == project.Id))
            {
                if (isHard)
                {
                    subProjectModel.Delete(subProject);
                }
            }

            if (isHard)
            {
                var projectResourceModel = new ProjectResourceModel();
                var resourceModel = new ResourceModel();
                var resourceTypeModel = new ResourceTypeModel();
                foreach (var projectResource in projectResourceModel.GetAllWhere((projectResource) => projectResource.ProjectId == project.Id))
                {
                    var resource = resourceModel.GetById(projectResource.ResourceId);
                    var resourceTypeOptions = resourceModel.GetResourceTypeOptions(projectResource.ResourceId);
                    var resourceTypeDefinition = ResourceTypeFactory.Instance.GetResourceType(resource);
                    resourceTypeDefinition.DeleteResource(projectResource.ResourceId.ToString(), resourceTypeOptions);
                    projectResourceModel.Delete(projectResource);
                    resourceModel.Delete(resource);
                }

                var projectRoleModel = new ProjectRoleModel();
                foreach (var projectRole in projectRoleModel.GetAllWhere((projectRole) => projectRole.ProjectId == project.Id))
                {
                    projectRoleModel.Delete(projectRole);
                }

                var projectDisciplineModel = new ProjectDisciplineModel();
                foreach (var projectDiscipline in projectDisciplineModel.GetAllWhere((projectDiscipline) => projectDiscipline.ProjectId == project.Id))
                {
                    projectDisciplineModel.Delete(projectDiscipline);
                }

                var projectInstituteModel = new ProjectInstituteModel();
                foreach (var projectInstitute in projectInstituteModel.GetAllWhere((projectInstitute) => projectInstitute.ProjectId == project.Id))
                {
                    projectInstituteModel.Delete(projectInstitute);
                }

                foreach (var projectQuota in _projectQuotaModel.GetAllWhere((Quota) => Quota.ProjectId == project.Id))
                {
                    _projectQuotaModel.Delete(projectQuota);
                }

                foreach (var invitation in _invitationModel.GetAllWhere((x) => x.Project == project.Id))
                {
                    _invitationModel.Delete(invitation);
                }

                _activatedFeaturesModel.DeactivateAllFeatures(project);

                if (propagateAction)
                {
                    _emitter.EmitProjectDelete(new ProjectEventArgs(_configuration)
                    {
                        Project = project
                    });
                }

                _projectModel.HardDelete(project);
            }
            else
            {
                _projectModel.Delete(project);
            }
        }

        /// <summary>
        /// Creates a project
        /// </summary>
        /// <param name="projectObject">A Project Object</param>
        /// <returns>JSON object or status code 401</returns>
        [HttpPost("[controller]")]
        public IActionResult Store([FromBody] ProjectObject projectObject)
        {
            var user = _authenticator.GetUser();

            if (projectObject.ParentId != new Guid()
                && !_projectModel.HasAccess(user, _projectModel.GetById(projectObject.ParentId), UserRoles.Member, UserRoles.Owner))
            {
                return Unauthorized("User is not allowed to create SubProjects.");
            }

            var defaultQuotas = _rdfStoreConnector.GetQuotaDefault(user.Id.ToString());
            var projectQuotas = defaultQuotas.Select(defaulQuota =>
            {
                var resourceType = _resourceTypeModel.GetWhere(resourceType => resourceType.DisplayName == defaulQuota.ResourceType);

                return new ProjectQuota
                {
                    MaxQuota = defaulQuota.DefaultMaxQuota,
                    Quota = defaulQuota.DefaultQuota,
                    ResourceTypeId = resourceType.Id
                };
            });

            var project = _projectModel.StoreFromObject(projectObject, user, projectQuotas);

            if (projectObject.ParentId != new Guid()
                // Both an owner and a member can add subprojects to projects
                && _projectModel.HasAccess(user, _projectModel.GetById(projectObject.ParentId), UserRoles.Member, UserRoles.Owner))
            {
                var subProjectModel = new SubProjectModel();
                subProjectModel.LinkSubProject(projectObject.ParentId, project.Id);
            }

            _emitter.EmitProjectCreate(new ProjectEventArgs(_configuration)
            {
                Project = project,
                ProjectOwner = user
            });

            LogAnalyticsAddProject(project, _projectModel.GetMetadataCompleteness(projectObject), projectObject.Disciplines, projectObject.Organizations, user);

            return Ok(_projectModel.CreateReturnObjectFromDatabaseObject(project));
        }

        /// <summary>
        /// List all invitations of a project.
        /// </summary>
        /// <param name="projectId">Id of the project</param>
        /// <returns>List of invitations</returns>
        [HttpGet("[controller]/invitation/list/{projectId}")]
        public ActionResult<IEnumerable<InvitationReturnObject>> ListInvitations(Guid projectId)
        {
            var project = _projectModel.GetById(projectId);

            if (project == null)
            {
                return NotFound($@"The project ""{projectId}"" was not found.");
            }

            var user = _authenticator.GetUser();

            if (!_projectModel.HasAccess(user, project, UserRoles.Owner))
            {
                return Unauthorized("You are not an owner of the project.");
            }

            var invitations = _invitationModel.GetAllWhere(x => x.Project == projectId)
                .Select(x => new InvitationReturnObject
                {
                    Id = x.Id,
                    Expiration = x.Expiration,
                    Issuer = x.Issuer,
                    ProjectId = x.Project,
                    RoleId = x.Role,
                    UserMail = x.InviteeEmail
                });

            return new ActionResult<IEnumerable<InvitationReturnObject>>(invitations);
        }

        /// <summary>
        /// Call to analytics logger.
        /// </summary>
        /// <param name="projectId">Project id of the project</param>
        /// <returns>204 no content</returns>
        [HttpGet("[controller]/{projectId}/-/create-profile")]
        public IActionResult CreateApplicationProfile(Guid projectId)
        {
            var project = _projectModel.GetById(projectId);

            if (project == null)
            {
                return NotFound($@"The project ""{projectId}"" was not found.");
            }

            var user = _authenticator.GetUser();

            if (!_projectModel.HasAccess(user, project, UserRoles.Owner))
            {
                return Unauthorized("You are not an owner of the project.");
            }

            LogAnalyticsCreateApplicationProfile(project, user);

            return NoContent();
        }

        /// <summary>
        /// Creates and sends a project invitation to a specified email.
        /// </summary>
        /// <param name="sendInvitationObject">Informations for sending an invitation. The invitation token is stored inside the URL under ".../?invitationToken={token}".</param>
        /// <returns>NoContent</returns>
        [HttpPost("[controller]/invitation")]
        public IActionResult SendInvitation([FromBody] SendInvitationObject sendInvitationObject)
        {
            var user = _authenticator.GetUser();

            if (!IsValidEmail(sendInvitationObject.Email))
            {
                return BadRequest($@"The email ""{sendInvitationObject.Email}"" is invalid.");
            }

            var project = _projectModel.GetById(sendInvitationObject.Project);

            if (project == null)
            {
                return NotFound($@"The project ""{sendInvitationObject.Project}"" was not found.");
            }

            if (_roleModel.GetById(sendInvitationObject.Role) == null)
            {
                return NotFound($@"The role ""{sendInvitationObject.Role}"" was not found.");
            }

            if (!_projectModel.HasAccess(user, project, UserRoles.Owner))
            {
                return Unauthorized("You are not an owner of the project.");
            }

            var invitations = _invitationModel.GetAllWhere(
                x => x.Project == sendInvitationObject.Project &&
                     x.InviteeEmail == sendInvitationObject.Email &&
                     x.Expiration > DateTime.UtcNow
            );

            if (invitations.Any())
            {
                return BadRequest("This invitee already has a valid invitation to this project.");
            }

            var expiredInvitations = _invitationModel.GetAllWhere(
                x => x.Project == sendInvitationObject.Project &&
                     x.InviteeEmail == sendInvitationObject.Email &&
                     x.Expiration <= DateTime.UtcNow
            );

            foreach (var expiredInvitation in expiredInvitations)
            {
                _invitationModel.Delete(expiredInvitation);
            }

            var token = _invitationModel.CreateInvitation(sendInvitationObject.Project, user.Id, sendInvitationObject.Role, sendInvitationObject.Email);

            var body = new JObject
            {
                ["Args"] = new JObject()
                {
                    ["placeholder"] = new JObject()
                    {
                        ["confirmation_link"] = $"{_configuration.GetString("coscine/local/api/additional/url")}/?invitationToken={token}"
                    }
                }
            };

            NotificationBusUtil.Send(Program.Configuration, "user_invitation", NotificationBusUtil.GetUserList(new User { EmailAddress = sendInvitationObject.Email }), sendInvitationObject.Project.ToString(), body);

            if (Request.Query != null && Request.Query["noanalyticslog"] != "true")
            {
                LogAnalyticsInviteExternalUser(project, user);
            }

            return NoContent();
        }

        /// <summary>
        /// Deletes a project invitation.
        /// </summary>
        /// <param name="invitationId">Id of an invitation</param>
        /// <returns>NoContent</returns>
        [HttpDelete("[controller]/invitation/{invitationId}")]
        public IActionResult DeleteInvitation(Guid invitationId)
        {
            var invitation = _invitationModel.GetById(invitationId);

            if (invitation == null)
            {
                return NotFound("Invitation was not found.");
            }

            var user = _authenticator.GetUser();

            if (!_projectModel.HasAccess(user, _projectModel.GetById(invitation.Project), UserRoles.Owner))
            {
                return Unauthorized("You are not an owner of this project.");
            }

            _invitationModel.Delete(invitation);

            return NoContent();
        }

        /// <summary>
        /// Resolves a project invitation for the current user.
        /// </summary>
        /// <param name="invitationToken">Token for a project invitation stored inside the URL under ".../?invitationToken={token}"</param>
        /// <returns>NoContent</returns>
        [HttpGet("[controller]/invitation/resolve/{invitationToken}")]
        public IActionResult ResolveInvitation(Guid invitationToken)
        {
            var user = _authenticator.GetUser();

            var invitation = _invitationModel.GetByToken(invitationToken);

            if (invitation == null)
            {
                return NotFound("Invitation was not found.");
            }

            if (invitation.Expiration < DateTime.UtcNow)
            {
                return BadRequest("The invitation has expired");
            }

            var project = _projectModel.GetById(invitation.Project);

            if (!_projectModel.HasAccess(_userModel.GetById(invitation.Issuer), project, UserRoles.Owner))
            {
                return Unauthorized("The issuer is not an owner of the project.");
            }

            if (_projectRoleModel.GetAllWhere(x => x.ProjectId == invitation.Project && x.UserId == user.Id).Any())
            {
                return BadRequest("The invitee is already part of the project.");
            }

            var role = _roleModel.GetById(invitation.Role);

            _emitter.EmitUserAdd(new UserEventArgs(_configuration)
            {
                Project = project,
                Role = role,
                User = user,
            });

            var projectRole = new ProjectRole()
            {
                RelationId = Guid.NewGuid(),
                ProjectId = invitation.Project,
                UserId = user.Id,
                RoleId = invitation.Role
            };

            _projectRoleModel.Insert(projectRole);

            _invitationModel.Delete(invitation);

            return NoContent();
        }

        private static bool IsValidEmail(string email)
        {
            try
            {
                return new System.Net.Mail.MailAddress(email).Address == email;
            }
            catch
            {
                return false;
            }
        }

        private void LogAnalyticsViewHome(List<string> projectIds)
        {
            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "View Home",
                    ProjectList = projectIds
                });
        }

        private void LogAnalyticsViewProject(Database.DataModel.Project project, List<ResourceObject> resources, IEnumerable<DisciplineObject> disciplines, IEnumerable<OrganizationObject> organizations, User user)
        {
            var enabledResources = ResourceTypeFactory.Instance.GetResourceTypes();
            var resourceTypes = _resourceTypeModel.GetAllWhere(r => enabledResources.Any(e => r.SpecificType.Equals(e)));

            var objects = resourceTypes.Select(x => Helpers.CreateProjectQuotaReturnObject(x, project.Id));

            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "View Project",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString(),
                    QuotaSize = objects.Select(x => $"{x.Name}: {x.Allocated.Value}/{x.Maximum.Value}").ToList(),
                    Disciplines = disciplines.Select(x => x.DisplayNameEn).ToList(),
                    Organizations = organizations.Select(x => x.DisplayName).ToList(),
                    Visibility = project.VisibilityId.HasValue ? _visibilityModel.GetById(project.VisibilityId.Value)?.DisplayName : null,
                    ResourceList = resources.ConvertAll(x => x.Id.ToString()),
                });
        }

        private void LogAnalyticsEditProject(Database.DataModel.Project project, string metadataCompletness, IEnumerable<DisciplineObject> disciplines, IEnumerable<OrganizationObject> organizations, User user)
        {
            var resourceTypes = _resourceTypeModel.GetAllWhere(x => x.Enabled == true);

            var objects = resourceTypes.Select(x => Helpers.CreateProjectQuotaReturnObject(x, project.Id));

            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "Edit Project",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString(),
                    QuotaSize = objects.Select(x => $"{x.Name}: {x.Allocated.Value}/{x.Maximum.Value}").ToList(),
                    MetadataCompleteness = metadataCompletness,
                    Disciplines = disciplines.Select(x => x.DisplayNameEn).ToList(),
                    Organizations = organizations.Select(x => x.DisplayName).ToList(),
                    Visibility = project.VisibilityId.HasValue ? _visibilityModel.GetById(project.VisibilityId.Value)?.DisplayName : null,
                });
        }

        private void LogAnalyticsAddProject(Database.DataModel.Project project, string metadataCompletness, IEnumerable<DisciplineObject> disciplines, IEnumerable<OrganizationObject> organizations, User user)
        {
            var resourceTypes = _resourceTypeModel.GetAllWhere(x => x.Enabled == true);

            var objects = resourceTypes.Select(x => Helpers.CreateProjectQuotaReturnObject(x, project.Id));

            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "Add Project",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString(),
                    QuotaSize = objects.Select(x => $"{x.Name}: {x.Allocated.Value}/{x.Maximum.Value}").ToList(),
                    MetadataCompleteness = metadataCompletness,
                    Disciplines = disciplines.Select(x => x.DisplayNameEn).ToList(),
                    Organizations = organizations.Select(x => x.DisplayName).ToList(),
                    Visibility = project.VisibilityId.HasValue ? _visibilityModel.GetById(project.VisibilityId.Value)?.DisplayName : null,
                });
        }

        private void LogAnalyticsDeleteProject(Database.DataModel.Project project, IEnumerable<DisciplineObject> disciplines, IEnumerable<OrganizationObject> organizations, User user)
        {
            var resourceTypes = _resourceTypeModel.GetAllWhere(x => x.Enabled == true);

            var objects = resourceTypes.Select(x => Helpers.CreateProjectQuotaReturnObject(x, project.Id));

            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "Delete Project",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString(),
                    QuotaSize = objects.Select(x => $"{x.Name}: {x.Allocated.Value}/{x.Maximum.Value}").ToList(),
                    Disciplines = disciplines.Select(x => x.DisplayNameEn).ToList(),
                    Organizations = organizations.Select(x => x.DisplayName).ToList(),
                    Visibility = project.VisibilityId.HasValue ? _visibilityModel.GetById(project.VisibilityId.Value)?.DisplayName : null,
                });
        }

        private void LogAnalyticsInviteExternalUser(Database.DataModel.Project project, User user)
        {
            var resourceTypes = _resourceTypeModel.GetAllWhere(x => x.Enabled == true);

            var objects = resourceTypes.Select(x => Helpers.CreateProjectQuotaReturnObject(x, project.Id));

            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "Invite External User",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString()
                });
        }

        private void LogAnalyticsCreateApplicationProfile(Database.DataModel.Project project, User user)
        {
            _coscineLogger.AnalyticsLog(
                new AnalyticsLogObject
                {
                    Type = "Action",
                    Operation = "Create Application Profile",
                    RoleId = _projectRoleModel.GetGetUserRoleForProject(project.Id, user.Id).ToString(),
                    ProjectId = project.Id.ToString()
                });
        }
    }
}