public async Task <IActionResult> UpdateGroupInvitation([FromBody] GroupInvitationViewModel model)
{
try
{
if (ModelState.IsValid)
{
GroupInvitation invitation = new GroupInvitation()
{
GroupId = model.GroupId,
ContactInfo = model.ContactInfo,
ContactPreference = model.ContactPreference,
IsAccepted = model.IsAccepted,
CreatedAt = model.CreatedAt
};
await _groupManager.UpdateGroupInvitation(invitation);
return(Ok(ApiResponse(ApiResponseStatus.Success, invitation, $@"group invitation successfully updated.")));
}
return(BadRequest(ApiResponse(ApiResponseStatus.Fail, GetModelStateErrors(ModelState), "Model validation failure.")));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(HandleException("1", e, "An error occurred while updating record. Please try again later."));
}
}
public void CreateGroupInvitation(GroupInvitation GroupInvitation)
{
var oldgroup = GetGroupInvitations().Where(g => g.ToUserId == GroupInvitation.ToUserId && g.GroupId == GroupInvitation.GroupId);
if (oldgroup.Count() == 0)
{
GroupInvitationRepository.Add(GroupInvitation);
SaveGroupInvitation();
}
}
public PartialViewResult InviteUser(int id, string UserId)
{
GroupInvitation newInvitation = new GroupInvitation()
{
GroupId = id,
FromUserId = User.Identity.GetUserId(),
ToUserId = UserId,
SentDate = DateTime.Now
};
groupInvitationService.CreateGroupInvitation(newInvitation);
return(PartialView(userService.GetUser(UserId)));
}
public bool UpdateGroupInvitation(GroupInvitation groupInvitation)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
_groupInvitationRepository.Update(groupInvitation);
_unitOfWork.SaveChanges();
scope.Complete();
return(true);
}//end scope
}
catch (Exception ex)
{
_loggingService.Write(GetType().Name, nameof(UpdateGroupInvitation), ex);
return(false);
}
}
public Task DeleteGroupInvitation(GroupInvitation groupinvitation)
{
_groupinvitation.Remove(groupinvitation);
return(_dbContext.SaveChangesAsync());
}
public Task UpdateGroupInvitation(GroupInvitation groupinvitation)
{
_groupinvitation.Update(groupinvitation);
return(_dbContext.SaveChangesAsync());
}
public async Task <IActionResult> InviteToGroup(string userEmail, Guid forAssignment)
{
var asg = await _context.Assignments
.Include(a => a.Course)
.ThenInclude(c => c.Affiliates)
.Include(a => a.Groups)
.ThenInclude(grp => grp.Members)
.SingleOrDefaultAsync(a => a.ID == forAssignment);
if (asg == null)
{
return(NotFound());
}
var user = await _userManager.GetUserAsync(User);
if (!(asg.Course.RoleFor(user) == CourseJoinTag.ROLE_STUDENT))
{
return(NotFound());
}
var otherUser = await _userManager.FindByEmailAsync(userEmail);
if (otherUser == null || asg.Course.RoleFor(otherUser) != CourseJoinTag.ROLE_STUDENT)
{
return(RedirectToAction(nameof(GroupSetup), new
{
forAssignment = forAssignment,
error = "That user does not exist or is not a member of this course."
}));
}
else if (asg.GroupFor(otherUser) != null)
{
return(RedirectToAction(nameof(GroupSetup), new
{
forAssignment = forAssignment,
error = "That user is already in a group!"
}));
}
Group g = asg.GroupFor(user);
if (g == null)
{
// User does not already have a group, so create one
var members = new List <GroupJoinTag>();
g = new Group
{
ID = Guid.NewGuid(),
Assignment = asg,
Members = members,
CurrentStage = Assignment.START_STAGE,
};
members.Add(new GroupJoinTag
{
Group = g,
ApplicationUser = user,
});
asg.Groups.Add(g);
_context.Update(asg);
}
if (user.Id != otherUser.Id)
{
var invite = new GroupInvitation
{
Group = g,
ApplicationUser = otherUser,
};
_context.GroupInvitations.Add(invite);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(GroupSetup), new { forAssignment = forAssignment }));
}
