public void RemoveUserFromGroup(GroupMemberUpdate groupMemberUpdate)
{
GroupUser groupUser = _context.GroupUsers.Include(gu => gu.User).Where(gu => gu.GroupID == groupMemberUpdate.GroupID && gu.User.Email == groupMemberUpdate.GroupMemberAddress).First();
_context.GroupUsers.Remove(groupUser);
_context.SaveChanges();
}
public void AddUserToGroup_ValidCall()
{
var users = GetSampeUsers().AsQueryable();
var groupsUsers = GetSampleGroupUsers().AsQueryable();
var mockUsersSet = new Mock <DbSet <User> >();
mockUsersSet.As <IQueryable <User> >().Setup(m => m.Provider).Returns(users.Provider);
mockUsersSet.As <IQueryable <User> >().Setup(m => m.Expression).Returns(users.Expression);
mockUsersSet.As <IQueryable <User> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockUsersSet.As <IQueryable <User> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockGroupsUsersSet = new Mock <DbSet <GroupUser> >();
mockGroupsUsersSet.As <IQueryable <GroupUser> >().Setup(m => m.Provider).Returns(groupsUsers.Provider);
mockGroupsUsersSet.As <IQueryable <GroupUser> >().Setup(m => m.Expression).Returns(groupsUsers.Expression);
mockGroupsUsersSet.As <IQueryable <GroupUser> >().Setup(m => m.ElementType).Returns(groupsUsers.ElementType);
mockGroupsUsersSet.As <IQueryable <GroupUser> >().Setup(m => m.GetEnumerator()).Returns(groupsUsers.GetEnumerator());
var mockContext = new Mock <MailBoxDBContext>();
mockContext.Setup(c => c.Users).Returns(mockUsersSet.Object);
mockContext.Setup(c => c.GroupUsers).Returns(mockGroupsUsersSet.Object);
var service = new GroupService(mockContext.Object);
GroupMemberUpdate groupMemberUpdate = new GroupMemberUpdate {
GroupID = 0, GroupMemberAddress = "*****@*****.**"
};
service.AddUserToGroup(groupMemberUpdate);
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
/// <summary>
/// Publishes a group update from a player
/// </summary>
void PublishGroupUpdateFrom(IGroupMember memberUpdated)
{
// if there is nothing to update just return
if (memberUpdated.MemberUpdateFlags == GroupMemberPropertyFlags.PROPERTY_FLAG_NONE)
{
return;
}
GroupMemberUpdate groupMemberUpdate = null;
foreach (var memberReference in memberReferences.Values)
{
// skip us
var member = memberReference.Object;
if (member.Guid == memberUpdated.Guid)
{
continue;
}
if (member.IsVisible(memberUpdated.Guid))
{
continue;
}
if (groupMemberUpdate == null)
{
groupMemberUpdate = new GroupMemberUpdate {
ObjectId = memberUpdated.Guid, Properties = memberUpdated.BuildGroupMemberProperties()
}
}
;
memberReference.Object.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
// resetting the flags so the updates can resume from the start
memberUpdated.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
}
/// <summary>
/// Called when a(n) group member has disconnected
/// </summary>
void Member_OnDisconnect(MmoGuid memberGuid)
{
this.RemoveReference(memberGuid);
}
public void ConstructorTest()
{
#region Init variables
int groupID = 0;
string groupMemberAddress = "*****@*****.**";
#endregion
GroupMemberUpdate groupUpdate = new GroupMemberUpdate
{
GroupID = groupID,
GroupMemberAddress = groupMemberAddress
};
#region Tests
Assert.NotNull(groupUpdate);
Assert.Equal(groupUpdate.GroupID, groupID);
Assert.Equal(groupUpdate.GroupMemberAddress, groupMemberAddress);
#endregion
}
public IActionResult AddUserToGroup([FromBody] GroupMemberUpdate groupMemberUpdate)
{
ErrorResponse errorResponse = new ErrorResponse();
try
{
groupService.AddUserToGroup(groupMemberUpdate);
}
catch (Exception ex)
{
errorResponse.Errors.Add(new ErrorModel {
FieldName = ex.Message, Message = ex.InnerException.Message
});
Response.StatusCode = 400;
}
return(new JsonResult(errorResponse));
}
public void WhenGroupMemberHaveCorrectAddress_ShouldNotHaveAnyError()
{
var validator = new GroupMemberUpdateValidator();
#region Init variables
int groupID = 0;
string address = "*****@*****.**";
#endregion
GroupMemberUpdate groupMemberUpdate = new GroupMemberUpdate
{
GroupID = groupID,
GroupMemberAddress = address
};
var result = validator.TestValidate(groupMemberUpdate);
#region Tests
result.ShouldNotHaveAnyValidationErrors();
#endregion
}
public void WhenGroupMemberHaveAddressWithoutDomain_ShouldHaveError()
{
var validator = new GroupMemberUpdateValidator();
#region Init variables
int groupID = 0;
string address = "wroga@ddresspl";
#endregion
GroupMemberUpdate groupMemberUpdate = new GroupMemberUpdate
{
GroupID = groupID,
GroupMemberAddress = address
};
var result = validator.TestValidate(groupMemberUpdate);
#region Tests
result.ShouldHaveValidationErrorFor(x => x.GroupMemberAddress);
#endregion
}
public void AddUserToGroup(GroupMemberUpdate groupMemberUpdate)
{
User user = _context.Users.Include(u => u.GroupUsers).Where(u => u.Email == groupMemberUpdate.GroupMemberAddress).FirstOrDefault();
if (user == null)
{
throw new Exception("GroupMemberAddress", new Exception("No such user address in database."));
}
if (user.GroupUsers.Where(gu => gu.GroupID == groupMemberUpdate.GroupID).Any())
{
throw new Exception("GroupMemberAddress", new Exception("This user is already in that group."));
}
GroupUser groupUser = new GroupUser
{
UserID = user.ID,
GroupID = groupMemberUpdate.GroupID
};
_context.GroupUsers.Add(groupUser);
_context.SaveChanges();
}
public IActionResult DeleteUserFromGroup([FromBody] GroupMemberUpdate groupMemberUpdate)
{
groupService.RemoveUserFromGroup(groupMemberUpdate);
return(Ok());
}
/// <summary>
/// Adds a(n) <see cref="IGroupMember"/> to the group.
/// </summary>
public bool AddMember(IGroupMember memberToAdd)
{
if (memberToAdd.InGroup())
{
return(false);
}
if (members.Count >= GlobalGameSettings.MAX_GROUP_MEMBERS)
{
return(false);
}
var memberInfo = new GroupMemberStructure(memberToAdd.Guid, memberToAdd.Name);
this.members.Add(memberInfo);
// this will set the member's current group to this
memberToAdd.Group = this;
// only send updates if there are more than one player in the group
// seriously what is there to send if its only one player
// a group of one means its just the leader waiting for the other player to accept the invite
if (memberReferences.Count > 0)
{
foreach (var memberReference in memberReferences.Values)
{
// skip us
var member = memberReference.Object;
var memberGuid = member.Guid;
var memberToAddGuid = memberToAdd.Guid;
if (memberGuid == memberToAddGuid)
{
continue;
}
if (!member.IsVisible(memberToAddGuid))
{
// otherwise we need to manually build the updates
memberToAdd.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_ALL;
var properties = memberToAdd.BuildGroupMemberProperties();
memberToAdd.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
// send the updates only if there is properties to send
if (properties != null)
{
var groupMemberUpdate = new GroupMemberUpdate
{
ObjectId = memberToAddGuid,
Properties = properties
};
member.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
}
if (!memberToAdd.IsVisible(memberGuid))
{
// otherwise we need to manually build the updates
member.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_ALL;
var properties = member.BuildGroupMemberProperties();
member.MemberUpdateFlags = GroupMemberPropertyFlags.PROPERTY_FLAG_NONE;
// send the updates only if there is properties to send
if (properties != null)
{
var groupMemberUpdate = new GroupMemberUpdate
{
ObjectId = memberGuid,
Properties = properties
};
memberToAdd.Peer.SendEvent(groupMemberUpdate, new MessageParameters {
ChannelId = PeerSettings.GroupEventChannel
});
}
}
}
}
// adding the member reference to send updates
this.AddReference(memberToAdd);
return(true);
}
