public async Task Validate_when_user_is_admin_of_group()
{
// Arrange
string userSub = Guid.NewGuid().ToString();
var user = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var group = new Domain.Entities.Group {
Admin = user, Name = "A group"
};
var userToGroup = new UserToGroup {
User = user, Group = group
};
await _dbContext.Users.AddAsync(user);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroup);
await _dbContext.SaveChangesAsync();
var sut = new GetGroupMembersValidator(_dbContext);
// Act
bool isValid = await sut.IsValidAsync(new GetGroupMembers(userSub, group.Id));
// Assert
isValid.ShouldBeTrue();
}
//Get: Attendee/InviteToGroup
public ActionResult InviteToGroup(int id)
{
UserToGroup UsersGroup = new UserToGroup();
UsersGroup.Group = db.Groups.Find(id);
return(View(UsersGroup));
}
public ActionResult Create(GroupCreateViewModel model)
//public ActionResult Create([Bind(Include = "Id,UserId,GroupId")] UserToGroup userToGroup)
{
if (ModelState.IsValid)
{
var newGroup = new Group {
Name = model.Group.Name
};
var newUserToGroup = new UserToGroup {
UserId = model.CurrentUserId, GroupId = newGroup.Id, AcceptedInvite = true
};
var newGroupToEvent = new GroupToEvents {
GroupId = newGroup.Id, EventId = model.Event.Id
};
db.Groups.Add(newGroup);
db.UserToGroups.Add(newUserToGroup);
db.GroupToEvents.Add(newGroupToEvent);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.GroupId = new SelectList(db.Groups, "Id", "Name");
ViewBag.EventId = new SelectList(db.Events, "Id", "Name");
return(View());
}
public async Task <string> AddUserToGroup(string groupId, string userId)
{
UserToGroup utg = new UserToGroup(userId);
var groupJson = JsonConvert.SerializeObject(utg);
string fullRequest = "/groups/" + groupId + "/members/$ref";
return(await SendGraphPostRequest(fullRequest, groupJson));
}
public ActionResult LeaveGroup(string userId, int?groupId)
{
UserToGroup userToGroupToRemove = (from row in db.UserToGroups where row.UserId == userId && row.GroupId == groupId select row).First();
db.UserToGroups.Remove(userToGroupToRemove);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task Invalidate_when_user_is_already_invited()
{
// Arrange
var sut = new InviteToGroupValidator(_dbContext);
string userSub = Guid.NewGuid().ToString();
string nonGroupUserSub = Guid.NewGuid().ToString();
var admin = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var invitedGroupUser = new User
{
FirstName = "Integration2",
LastName = "Test2",
Sub = nonGroupUserSub
};
var group = new Domain.Entities.Group
{
Admin = admin,
Name = "my group"
};
var userToGroups = new UserToGroup {
Group = group, User = admin
};
var groupInvite = new GroupInvite
{
Group = group,
InvitationReceiver = invitedGroupUser,
InvitationSender = admin
};
await _dbContext.Users.AddAsync(admin);
await _dbContext.Users.AddAsync(invitedGroupUser);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroups);
await _dbContext.GroupInvites.AddAsync(groupInvite);
await _dbContext.SaveChangesAsync();
// Act
bool isValid = await sut.IsValidAsync(new InviteToGroup(userSub, group.Id, invitedGroupUser.Id));
// Assert
isValid.ShouldBeFalse();
}
public async Task Validate_request_when_is_part_of_group()
{
// Arrange
string userSub = Guid.NewGuid().ToString();
string adminSub = Guid.NewGuid().ToString();
var user = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var admin = new User
{
FirstName = "Admin",
LastName = "User",
Sub = adminSub
};
var group = new Domain.Entities.Group
{
Admin = admin,
Name = "A group"
};
var userToGroup = new UserToGroup {
Group = group, User = user
};
var adminToGroup = new UserToGroup {
Group = group, User = admin
};
await _dbContext.Users.AddAsync(user);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroup);
await _dbContext.UsersToGroups.AddAsync(adminToGroup);
await _dbContext.SaveChangesAsync();
var sut = new GetGroupSafeLocationsValidator(_dbContext);
// Act
bool isValid = await sut.IsValidAsync(new GetGroupSafeLocations(userSub, group.Id));
// Assert
isValid.ShouldBeTrue();
}
public ActionResult Edit(GroupEditViewModel model, UserToGroup userToGroup, int?id)
{
if (ModelState.IsValid)
{
var groupToUpdate = db.Groups.Find(db.UserToGroups.Find(userToGroup.Id).GroupId);
var userToGroupToUpdate = db.UserToGroups.Find(userToGroup.Id);
userToGroupToUpdate.GroupId = groupToUpdate.Id;
groupToUpdate.Name = model.Name;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.GroupId = new SelectList(db.Groups, "Id", "Name", userToGroup.GroupId);
ViewBag.UserId = new SelectList(db.Users, "Id", "Email", userToGroup.UserId);
return(View(userToGroup));
}
public async Task Validate_when_user_is_admin_of_group_and_invited_existing_user()
{
// Arrange
var sut = new InviteToGroupValidator(_dbContext);
string userSub = Guid.NewGuid().ToString();
string nonGroupUserSub = Guid.NewGuid().ToString();
var admin = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var nonGroupUser = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = nonGroupUserSub
};
var group = new Domain.Entities.Group
{
Admin = admin,
Name = "my group"
};
var userToGroups = new UserToGroup {
Group = group, User = admin
};
await _dbContext.Users.AddAsync(admin);
await _dbContext.Users.AddAsync(nonGroupUser);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroups);
await _dbContext.SaveChangesAsync();
// Act
bool isValid = await sut.IsValidAsync(new InviteToGroup(userSub, group.Id, nonGroupUser.Id));
// Assert
isValid.ShouldBeTrue();
}
public IActionResult CreateGroup([FromBody] Group group)
{
if (group == null)
{
return(BadRequest("Invalid client request: group object was null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid user: model state not valid");
return(BadRequest("Invalid user: model state not valid"));
}
if (!group.ValidateCreateGroup())
{
return(BadRequest("Sent object was not valid!"));
}
try
{
var userMail = AuthControllerExtensions.JwtNameExtractor(Request.Headers["Authorization"]);
var dbUser = _repository.User.GetUserByEmail(userMail);
group.AdminUserId = dbUser.Id;
_repository.Group.CreateGroup(group);
_repository.Save();
var adminMembership = new UserToGroup()
{
GroupId = group.Id,
UserId = dbUser.Id
};
_repository.UserToGroup.AddMembership(adminMembership);
_repository.Save();
return(Ok(_repository.Group.GetGroupById(group.Id)));
}
catch (Exception e) {
_logger.LogError($"Something went wrong inside CreateGroup: {e.Message}");
return(BadRequest("Something went wrong while creating group, the group was not saved!"));
}
}
public async Task Invalidate_request_when_user_adds_himself_to_group()
{
// Arrange
var sut = new InviteToGroupValidator(_dbContext);
string userSub = Guid.NewGuid().ToString();
var user = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var group = new Domain.Entities.Group
{
Admin = user,
Name = "my group"
};
var userToGroups = new UserToGroup {
Group = group, User = user
};
await _dbContext.Users.AddAsync(user);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroups);
await _dbContext.SaveChangesAsync();
// Act
bool isValid = await sut.IsValidAsync(new InviteToGroup(userSub, group.Id, user.Id));
// Assert
isValid.ShouldBeFalse();
}
public async Task Invalidate_when_invited_user_not_found()
{
// Arrange
var sut = new InviteToGroupValidator(_dbContext);
string userSub = Guid.NewGuid().ToString();
var admin = new User
{
FirstName = "Integration",
LastName = "Test",
Sub = userSub
};
var group = new Domain.Entities.Group
{
Admin = admin,
Name = "my group"
};
var userToGroups = new UserToGroup {
Group = group, User = admin
};
await _dbContext.Users.AddAsync(admin);
await _dbContext.Groups.AddAsync(group);
await _dbContext.UsersToGroups.AddAsync(userToGroups);
await _dbContext.SaveChangesAsync();
// Act
bool isValid = await sut.IsValidAsync(new InviteToGroup(userSub, group.Id, Guid.NewGuid()));
// Assert
isValid.ShouldBeFalse();
}
public ActionResult InviteToGroup(UserToGroup model)
{
if (ModelState.IsValid)
{
UserToGroup userToGroup = new UserToGroup();
foreach (ApplicationUser user in db.Users)
{
if (user.Email == model.User.Email)
{
ApplicationUser invitee = user;
userToGroup.UserId = invitee.Id;
}
}
userToGroup.GroupId = model.Group.Id;
userToGroup.AcceptedInvite = false;
db.UserToGroups.Add(userToGroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
UserToGroup UsersGroup = new UserToGroup();
UsersGroup.Group = db.Groups.Find(model.Group.Id);
return(View(UsersGroup));
}
public IActionResult AddMember([FromBody] UserToGroup userToGroupParam)
{
var group = _repository.Group.GetGroupById(userToGroupParam.GroupId);
if (group == null)
{
_logger.LogError("Group was not found!");
return(BadRequest("Invalid client request: Group was not found"));
}
var userToAdd = _repository.User.FindByCondition(us => us.Id == userToGroupParam.UserId).FirstOrDefault();
if (userToAdd == null)
{
_logger.LogError("User with this id was not found!");
return(BadRequest("User with this id was not found!"));
}
var currentGroupMemberships = _repository.UserToGroup.GetMembershipsForGroup(group).ToList();
foreach (var mem in currentGroupMemberships)
{
if (mem.UserId == userToAdd.Id)
{
_logger.LogError("User is already member of this group!");
return(BadRequest("User is already member of this group!"));
}
}
try
{
if (group.IsPublic.Equals("true"))
{
var userToGroupPublic = new UserToGroup()
{
UserId = userToAdd.Id,
GroupId = group.Id
};
_repository.UserToGroup.AddMembership(userToGroupPublic);
_repository.Save();
return(Accepted());
}
var userMail = AuthControllerExtensions.JwtNameExtractor(Request.Headers["Authorization"]);
var loggedInUser = _repository.User.GetUserByEmail(userMail);
if (loggedInUser.Id != group.AdminUserId)
{
_logger.LogError("Logged in user is no admin therefore he cant add members");
return(BadRequest("Logged in user is no admin therefore he cant add members"));
}
var userToGroup = new UserToGroup()
{
UserId = userToAdd.Id,
GroupId = group.Id
};
_repository.UserToGroup.AddMembership(userToGroup);
_repository.Save();
return(Accepted());
}
catch (Exception e)
{
_logger.LogError($"Something went wrong inside AddMember: {e.Message}");
return(StatusCode(500, "Something went wrong while adding a new member"));
}
}
