public async Task <Guid> CreateInviteAsync(GroupInviteViewModel model, CancellationToken cancellationToken)
{
var invite = new GroupInvite()
{
EmailAddress = model.EmailAddress,
GroupId = model.GroupId,
IsDeleted = model.IsDeleted
};
_context.GroupInvite.Add(invite);
await _context.SaveChangesAsync(cancellationToken);
return(invite.Id);
}
public async Task <ActionResult> InviteMemberAsync(string slug, Guid groupId, bool success = false, CancellationToken cancellationToken = default(CancellationToken))
{
if (!await IsCurrentUserAGroupAdministratorAsync(cancellationToken))
{
return(RedirectToRoute("GroupUrls", new { slug = slug }));
}
ViewBag.HideSideBar = true;
var model = new GroupInviteViewModel
{
GroupId = groupId,
Slug = slug,
Success = success
};
return(View(model));
}
public async Task <ActionResult> InviteMemberAsync(GroupInviteViewModel model, CancellationToken cancellationToken)
{
ViewBag.HideSideBar = true;
model.Success = false;
if (!ModelState.IsValid)
{
return(View(model));
}
var inviteMailAddress = new MailAddress(model.EmailAddress);
//check if a user is already in the group
if (await _inviteService.MemberExistsInGroupAsync(model.GroupId.Value, inviteMailAddress, cancellationToken))
{
ModelState.AddModelError(nameof(model.EmailAddress), "A user with that email address is already a member of this group");
return(View(model));
}
//check if a user has is already in the system
if (await _inviteService.MemberExistsInSystemAsync(inviteMailAddress, cancellationToken))
{
ModelState.AddModelError(nameof(model.EmailAddress), "A user with that email address is already registered on the platform - you may add them to your group");
return(View(model));
}
//check if a user already has an invite for this group
if (await _inviteService.InviteExistsForGroupAsync(model.GroupId.Value, inviteMailAddress, cancellationToken))
{
ModelState.AddModelError(nameof(model.EmailAddress), "This email address has already been invited to this group");
return(View(model));
}
var result = await _inviteService.CreateInviteAsync(model, cancellationToken);
if (result == Guid.Empty)
{
ModelState.AddModelError("EmailSendError", "Failed to send email");
return(View(model));
}
return(RedirectToAction("InviteMember", new { slug = model.Slug, groupId = model.GroupId, success = true }));
}
public async Task Handles_ValidPostRequest_InviteMemberAsync()
{
var groupInviteViewModel = new GroupInviteViewModel()
{
EmailAddress = EmailValid,
ConfirmEmailAddress = EmailValid,
GroupId = GroupIdValid,
Slug = GroupSlugValid
};
var controller = new GroupInviteController(_mockGroupInviteService.Object, _mockGroupAddMemberService.Object);
SetUserInContext.SetContext("admin");
var result = await controller.InviteMemberAsync(groupInviteViewModel, CancellationToken.None);
Assert.IsInstanceOf <RedirectToRouteResult>(result);
Assert.AreEqual(GroupSlugValid, (result as RedirectToRouteResult).RouteValues["slug"]);
Assert.AreEqual(GroupIdValid, (result as RedirectToRouteResult).RouteValues["groupId"]);
Assert.AreEqual(true, (result as RedirectToRouteResult).RouteValues["success"]);
}
public async Task <Guid> CreateInviteAsync(GroupInviteViewModel model, CancellationToken cancellationToken)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
if (string.IsNullOrWhiteSpace(model.EmailAddress))
{
throw new ArgumentNullException(nameof(model.EmailAddress));
}
MailAddress to = new MailAddress(model.EmailAddress);
if (!await _emailService.SendInvitationAsync(to, cancellationToken))
{
return(Guid.Empty);
}
return(await _inviteCommand.CreateInviteAsync(model, cancellationToken));
}
public async Task Handles_InvalidPostRequest_InviteMemberAsync()
{
var controller = new GroupInviteController(_mockGroupInviteService.Object, _mockGroupAddMemberService.Object);
SetUserInContext.SetContext("admin");
controller.ModelState.AddModelError("error", "invalid state");
var groupInviteViewModel = new GroupInviteViewModel()
{
EmailAddress = EmailInvalid,
ConfirmEmailAddress = ConfimEmailInvalid,
GroupId = GroupIdInvalid,
Slug = GroupSlugValid
};
var result = await controller.InviteMemberAsync(groupInviteViewModel, CancellationToken.None) as ViewResult;
Assert.IsInstanceOf <ActionResult>(result);
Assert.IsInstanceOf <GroupInviteViewModel>(result.Model);
Assert.AreEqual(GroupSlugValid, (result.Model as GroupInviteViewModel).Slug);
Assert.AreEqual(GroupIdInvalid, (result.Model as GroupInviteViewModel).GroupId);
Assert.AreEqual(EmailInvalid, (result.Model as GroupInviteViewModel).EmailAddress);
Assert.AreEqual(ConfimEmailInvalid, (result.Model as GroupInviteViewModel).ConfirmEmailAddress);
}
public Result <GroupInviteViewModel> GetInviteViewModel(string groupId)
{
_logger.LogInformation($"Getting Group. GroupId {groupId}");
SelectSpecification <GroupEntity, GroupInviteViewModel> selectSpecification = new SelectSpecification <GroupEntity, GroupInviteViewModel>();
selectSpecification.AddFilter(x => x.Id == groupId);
selectSpecification.AddSelect(x => new GroupInviteViewModel(
x.Id,
x.Name));
GroupInviteViewModel groupInviteView = _groupStore.Get(selectSpecification);
if (groupInviteView == null)
{
_logger.LogError($"No Group. GroupId {groupId}");
return(Result.Fail <GroupInviteViewModel>("no_group", "No Group"));
}
groupInviteView.CanAssignRoles = _groupUserStore.CanAssigneGroupRoles();
return(Result.Ok(groupInviteView));
}
public async Task <IActionResult> InviteMember([FromBody] GroupInviteViewModel vm)
{
string rv = "";
var user = await getUser();
if (user == null)
{
return(BadRequest("You must be logged in to do that"));
}
try
{
var group = _context.Groups.FirstOrDefault(x => x.id == vm.groupId);
if (group == null)
{
return(BadRequest("Group not found!"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var invite = new GroupInvite()
{
group = group,
invitedBy = user.Id,
dateInvited = DateTime.Now,
emailAddress = vm.emailAddress,
guid = Guid.NewGuid().ToString(),
message = vm.message,
status = Enums.GroupInviteStatus.Pending,
userId = "",
dateAccepted = null,
dateDeclined = null
};
var invitee = await _userManager.FindByEmailAsync(invite.emailAddress);
if (invitee != null)
{
invite.userId = invitee.Id;
}
if (!_context.GroupInvites.Any(x => x.emailAddress.Equals(invite.emailAddress) && invite.group == x.group))
{
await _context.GroupInvites.AddAsync(invite);
await _context.SaveChangesAsync();
var subject = MessageBuilder.buildGroupInviteSubject(group, invite, user);
var msg = MessageBuilder.buildGroupInviteMessage(group, invite, user, url);
await _emailSender.SendEmailAsync(vm.emailAddress, subject, msg);
rv = "Success: Invite sent";
}
}
catch (Exception ex)
{
return(BadRequest(ex));
}
return(Ok(rv));
}
