public async Task CreateManyIfNotExists(Guid userId, List <Guid> releaseIds, ReleaseRole role,
Guid createdById)
{
var alreadyExistingReleaseIds = await _contentDbContext.UserReleaseRoles
.AsQueryable()
.Where(urr =>
urr.UserId == userId &&
urr.Role == role &&
releaseIds.Contains(urr.ReleaseId))
.Select(urr => urr.ReleaseId)
.ToListAsync();
var newUserReleaseRoles = releaseIds
.Except(alreadyExistingReleaseIds)
.Select(releaseId =>
new UserReleaseRole
{
UserId = userId,
ReleaseId = releaseId,
Role = role,
Created = DateTime.UtcNow,
CreatedById = createdById,
}
).ToList();
await _contentDbContext.UserReleaseRoles.AddRangeAsync(newUserReleaseRoles);
await _contentDbContext.SaveChangesAsync();
}
public async Task CreateManyIfNotExists(List <Guid> releaseIds,
string email,
ReleaseRole releaseRole,
bool emailSent,
Guid createdById,
bool accepted = false)
{
var invites = await releaseIds
.ToAsyncEnumerable()
.WhereAwait(async releaseId => !await UserHasInvite(releaseId, email, releaseRole))
.Select(releaseId =>
new UserReleaseInvite
{
Email = email.ToLower(),
ReleaseId = releaseId,
Role = releaseRole,
EmailSent = emailSent,
Created = DateTime.UtcNow,
CreatedById = createdById,
Accepted = accepted,
}
).ToListAsync();
await _contentDbContext.AddRangeAsync(invites);
await _contentDbContext.SaveChangesAsync();
}
public async Task <bool> HasUserReleaseRole(string email, Guid releaseId, ReleaseRole role)
{
return(await _contentDbContext.UserReleaseRoles
.AsQueryable()
.AnyAsync(r =>
r.User.Email.ToLower().Equals(email.ToLower()) &&
r.ReleaseId == releaseId &&
r.Role == role));
}
public async Task <bool> HasUserReleaseRole(Guid userId, Guid releaseId, ReleaseRole role)
{
return(await _contentDbContext.UserReleaseRoles
.AsQueryable()
.AnyAsync(r =>
r.UserId == userId &&
r.ReleaseId == releaseId &&
r.Role == role));
}
public async Task <bool> UserHasInvite(Guid releaseId, string email, ReleaseRole role)
{
return(await _contentDbContext
.UserReleaseInvites
.AsQueryable()
.AnyAsync(i =>
i.ReleaseId == releaseId &&
i.Email.ToLower().Equals(email.ToLower()) &&
i.Role == role));
}
public async Task <Either <ActionResult, Unit> > RemoveByPublication(
string email,
Guid publicationId,
ReleaseRole releaseRole)
{
return(await _contentPersistenceHelper
.CheckEntityExists <Publication>(publicationId, query => query
.Include(p => p.Releases))
.OnSuccessDo(
publication => _userService.CheckCanUpdateReleaseRole(publication, releaseRole))
.OnSuccess(async publication =>
{
await _userReleaseInviteRepository.RemoveByPublication(publication, email, releaseRole);
return Unit.Instance;
}));
}
public async Task <UserReleaseRole> Create(Guid userId, Guid releaseId, ReleaseRole role, Guid createdById)
{
var userReleaseRole = new UserReleaseRole
{
UserId = userId,
ReleaseId = releaseId,
Role = role,
Created = DateTime.UtcNow,
CreatedById = createdById,
};
var created =
(await _contentDbContext.UserReleaseRoles.AddAsync(userReleaseRole)).Entity;
await _contentDbContext.SaveChangesAsync();
return(created);
}
public Either <ActionResult, Unit> SendReleaseRoleEmail(
string email,
Release release,
ReleaseRole role)
{
var uri = _configuration.GetValue <string>("AdminUri");
var template = _configuration.GetValue <string>("NotifyReleaseRoleTemplateId");
var link = role == ReleaseRole.PrereleaseViewer ? "prerelease " : "summary";
var emailValues = new Dictionary <string, dynamic>
{
{ "url", $"https://{uri}/publication/{release.Publication.Id}/release/{release.Id}/{link}" },
{ "role", role.ToString() },
{ "publication", release.Publication.Title },
{ "release", release.Title }
};
return(_emailService.SendEmail(email, template, emailValues));
}
private void SendNewReleaseRoleEmail(Guid userId, Release release,
ReleaseRole role)
{
var uri = _configuration.GetValue <string>("AdminUri");
var template = _configuration.GetValue <string>("NotifyReleaseRoleTemplateId");
var email = _usersAndRolesDbContext.Users
.First(x => x.Id == userId.ToString())
.Email;
var link = (role == ReleaseRole.PrereleaseViewer ? "prerelease " : "summary");
var emailValues = new Dictionary <string, dynamic>
{
{ "url", $"https://{uri}/publication/{release.Publication.Id}/release/{release.Id}/{link}" },
{ "role", role.ToString() },
{ "publication", release.Publication.Title },
{ "release", release.Title }
};
_emailService.SendEmail(email, template, emailValues);
}
public async Task Create(Guid releaseId,
string email,
ReleaseRole releaseRole,
bool emailSent,
Guid createdById,
bool accepted = false)
{
await _contentDbContext.AddAsync(
new UserReleaseInvite
{
Email = email.ToLower(),
ReleaseId = releaseId,
Role = releaseRole,
Accepted = accepted,
EmailSent = emailSent,
Created = DateTime.UtcNow,
CreatedById = createdById,
}
);
await _contentDbContext.SaveChangesAsync();
}
public async Task RemoveByPublication(Publication publication, string email, ReleaseRole role)
{
_contentDbContext.Update(publication);
await _contentDbContext.Entry(publication)
.Collection(p => p.Releases)
.LoadAsync();
var releaseIds = publication.Releases
.Select(r => r.Id)
.ToList();
var invites = await _contentDbContext
.UserReleaseInvites
.AsQueryable()
.Where(i =>
releaseIds.Contains(i.ReleaseId) &&
i.Email.ToLower().Equals(email.ToLower()) &&
i.Role == role)
.ToListAsync();
_contentDbContext.RemoveRange(invites);
await _contentDbContext.SaveChangesAsync();
}
public async Task <UserReleaseRole> CreateIfNotExists(Guid userId, Guid releaseId, ReleaseRole role,
Guid createdById)
{
var userReleaseRole = await GetUserReleaseRole(userId, releaseId, role);
if (userReleaseRole == null)
{
return(await Create(userId, releaseId, role, createdById));
}
return(userReleaseRole);
}
public async Task RemoveAllForPublication(Guid userId, Publication publication, ReleaseRole role,
Guid deletedById)
{
_contentDbContext.Update(publication);
await _contentDbContext
.Entry(publication)
.Collection(p => p.Releases)
.LoadAsync();
var allReleaseIds = publication
.Releases // Remove on previous release versions as well
.Select(r => r.Id)
.ToList();
var userReleaseRoles = await _contentDbContext.UserReleaseRoles
.AsQueryable()
.Where(urr =>
urr.UserId == userId &&
allReleaseIds.Contains(urr.ReleaseId) &&
urr.Role == role)
.ToListAsync();
await RemoveMany(userReleaseRoles, deletedById);
}
public async Task <List <UserReleaseRole> > ListUserReleaseRolesByPublication(ReleaseRole role,
Guid publicationId)
{
var allLatestReleases = await _publicationRepository
.ListActiveReleases(publicationId);
var allLatestReleaseIds = allLatestReleases
.Select(r => r.Id)
.ToList();
return(await _contentDbContext.UserReleaseRoles
.Include(releaseRole => releaseRole.User)
.Where(userReleaseRole =>
allLatestReleaseIds.Contains(userReleaseRole.ReleaseId) &&
userReleaseRole.Role == role)
.ToListAsync());
}
public async Task <bool> UserHasInvites(List <Guid> releaseIds, string email, ReleaseRole role)
{
var inviteReleaseIds = await _contentDbContext
.UserReleaseInvites
.AsQueryable()
.Where(i =>
releaseIds.Contains(i.ReleaseId) &&
i.Email.ToLower().Equals(email.ToLower()) &&
i.Role == role)
.Select(i => i.ReleaseId)
.ToListAsync();
return(releaseIds.All(releaseId => inviteReleaseIds.Contains(releaseId)));
}
private async Task <Either <ActionResult, Unit> > ValidateReleaseRoleCanBeAdded(Guid userId,
Guid releaseId,
ReleaseRole role)
{
if (await _userReleaseRoleRepository.HasUserReleaseRole(userId, releaseId, role))
{
return(ValidationActionResult(UserAlreadyHasResourceRole));
}
return(Unit.Instance);
}
public async Task <Either <ActionResult, Unit> > AddReleaseRole(Guid userId, Guid releaseId, ReleaseRole role)
{
return(await _contentPersistenceHelper
.CheckEntityExists <Release>(releaseId, query => query
.Include(r => r.Publication))
.OnSuccess(release =>
_userService.CheckCanUpdateReleaseRole(release.Publication, role)
.OnSuccess(async() =>
{
return await _usersAndRolesPersistenceHelper
.CheckEntityExists <ApplicationUser, string>(userId.ToString())
.OnSuccessDo(_ => ValidateReleaseRoleCanBeAdded(userId, releaseId, role))
.OnSuccess(async user =>
{
await _userReleaseRoleRepository.Create(
userId: userId,
releaseId: release.Id,
role: role,
createdById: _userService.GetUserId());
return _emailTemplateService.SendReleaseRoleEmail(user.Email, release, role);
});
})
));
}
public async Task <UserReleaseRole?> GetUserReleaseRole(Guid userId, Guid releaseId, ReleaseRole role)
{
return(await _contentDbContext.UserReleaseRoles
.AsQueryable()
.SingleOrDefaultAsync(r =>
r.UserId == userId &&
r.ReleaseId == releaseId &&
r.Role == role));
}
public static Task <Either <ActionResult, Tuple <Publication, ReleaseRole> > > CheckCanUpdateReleaseRole(
this IUserService userService, Publication publication, ReleaseRole role)
{
return(userService.CheckPolicy(TupleOf(publication, role),
SecurityPolicies.CanUpdateSpecificReleaseRole));
}
public async Task <List <UserReleaseRole> > ListUserReleaseRoles(Guid releaseId, ReleaseRole role)
{
return(await _contentDbContext.UserReleaseRoles
.AsQueryable()
.Include(urr => urr.User)
.Where(urr =>
urr.ReleaseId == releaseId &&
urr.Role == role)
.ToListAsync());
}
