public void AddFriendshipInvitation(FriendshipInvitation invitation, User friend)
{
long invitationId = invitation.FriendshipInvitationId.Value;
if (oldInvitationIds.Contains(invitationId) || outgoingFriendInvitations.Any((IInternalOutgoingFriendInvitation i) => i.InvitationId == invitationId) || incomingFriendInvitations.Any((IInternalIncomingFriendInvitation i) => i.InvitationId == invitationId))
{
return;
}
if (invitation.IsInviter.Value)
{
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = outgoingFriendInvitations.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.Invitee.DisplayName.Text == invitation.FriendDisplayName && i.RequestTrust != invitation.IsTrusted);
if (internalOutgoingFriendInvitation != null)
{
RemoveOutgoingFriendInvitation(internalOutgoingFriendInvitation.InvitationId);
}
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(friend.DisplayName, friend.FirstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(this, invitee, invitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(invitationId);
AddOutgoingFriendInvitation(outgoingFriendInvitation);
}
else
{
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = incomingFriendInvitations.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.Inviter.DisplayName.Text == invitation.FriendDisplayName && i.RequestTrust != invitation.IsTrusted);
if (internalIncomingFriendInvitation != null)
{
RemoveIncomingFriendInvitation(internalIncomingFriendInvitation.InvitationId);
}
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(friend.DisplayName, friend.FirstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, this, invitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(invitationId);
AddIncomingFriendInvitation(incomingFriendInvitation);
}
}
private void ReconcileFriendInvitations(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <FriendshipInvitation> friendshipInvitations = response.FriendshipInvitations;
List <IInternalIncomingFriendInvitation> list = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list2 = localUser.InternalOutgoingFriendInvitations.ToList();
if (friendshipInvitations != null)
{
foreach (FriendshipInvitation friendInvitation in friendshipInvitations)
{
Func <IInternalIncomingFriendInvitation, bool> predicate = (IInternalIncomingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId;
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list.FirstOrDefault(predicate);
if (internalIncomingFriendInvitation != null)
{
if (internalIncomingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalIncomingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list.Remove(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list2.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId);
if (internalOutgoingFriendInvitation != null)
{
if (internalOutgoingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalOutgoingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list2.Remove(internalOutgoingFriendInvitation);
continue;
}
string firstName = response.Users.FirstOrDefault((User user) => user.DisplayName == friendInvitation.FriendDisplayName)?.FirstName;
if (friendInvitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, friendInvitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddOutgoingFriendInvitation(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, friendInvitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddIncomingFriendInvitation(incomingFriendInvitation);
}
}
}
foreach (IInternalIncomingFriendInvitation item in list)
{
localUser.RemoveIncomingFriendInvitation(item);
item.Rejected();
}
foreach (IInternalOutgoingFriendInvitation item2 in list2)
{
localUser.RemoveOutgoingFriendInvitation(item2);
item2.Rejected();
}
}
private void ReconcileFriends(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <IInternalFriend> list = localUser.InternalFriends.ToList();
List <IInternalIncomingFriendInvitation> list2 = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list3 = localUser.InternalOutgoingFriendInvitations.ToList();
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
string friendUserId = friendship.FriendUserId;
IInternalFriend internalFriend = list.FirstOrDefault((IInternalFriend f) => f.Swid == friendUserId);
User user = response.Users.First((User u) => u.UserId == friendUserId);
if (internalFriend != null)
{
if (internalFriend.IsTrusted != friendship.IsTrusted)
{
if (friendship.IsTrusted.Value)
{
internalFriend.ChangeTrust(isTrusted: true);
}
else
{
localUser.UntrustFriend(internalFriend);
}
}
list.Remove(internalFriend);
continue;
}
IInternalFriend internalFriend2 = RemoteUserFactory.CreateFriend(friendship.FriendUserId, friendship.IsTrusted.Value, user.DisplayName, user.FirstName, userDatabase);
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list2.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.InternalInviter.DisplayName.Text == user.DisplayName);
if (internalIncomingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalIncomingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list2.Remove(internalIncomingFriendInvitation);
localUser.RemoveIncomingFriendInvitation(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list3.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InternalInvitee.DisplayName.Text == user.DisplayName);
if (internalOutgoingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalOutgoingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list3.Remove(internalOutgoingFriendInvitation);
localUser.RemoveOutgoingFriendInvitation(internalOutgoingFriendInvitation);
}
else
{
localUser.AddFriend(internalFriend2);
}
}
}
foreach (IInternalFriend item in list)
{
localUser.RemoveFriend(item);
}
}
public void AddIncomingFriendInvitation(IInternalIncomingFriendInvitation invitation)
{
if (!incomingFriendInvitations.Any((IInternalIncomingFriendInvitation i) => i.Id == invitation.Id))
{
incomingFriendInvitations.Add(invitation);
ReceivedIncomingFriendInvitationEventArgs e = new ReceivedIncomingFriendInvitationEventArgs(invitation);
this.OnReceivedIncomingFriendInvitation(this, e);
}
}
private IInternalIncomingFriendInvitation RemoveIncomingFriendInvitation(long invitationId)
{
oldInvitationIds.Add(invitationId);
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = incomingFriendInvitations.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.InvitationId == invitationId);
if (internalIncomingFriendInvitation != null)
{
incomingFriendInvitations.Remove(internalIncomingFriendInvitation);
}
return(internalIncomingFriendInvitation);
}
public void RemoveFriendshipInvitation(long invitationId)
{
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = RemoveIncomingFriendInvitation(invitationId);
if (internalIncomingFriendInvitation != null)
{
internalIncomingFriendInvitation.Rejected();
}
else
{
RemoveOutgoingFriendInvitation(invitationId)?.Rejected();
}
}
public void AcceptFriendInvitation(IIncomingFriendInvitation invitation, bool acceptTrust, Action <IAcceptFriendInvitationResult> callback)
{
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = incomingFriendInvitations.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.Id == invitation.Id);
if (internalIncomingFriendInvitation == null)
{
logger.Critical("Friend invitation to accept not found");
callback(new AcceptFriendInvitationResult(success: false, null));
return;
}
FriendInvitationAccepter.Accept(logger, notificationQueue, mixWebCallFactory, internalIncomingFriendInvitation.InvitationId, acceptTrust, delegate(AddFriendshipNotification notification)
{
IInternalFriend friend = friends.FirstOrDefault((IInternalFriend f) => f.Swid == notification.Friend.UserId);
callback(new AcceptFriendInvitationResult(success: true, friend));
}, delegate
{
callback(new AcceptFriendInvitationResult(success: false, null));
});
}
public void RejectFriendInvitation(IIncomingFriendInvitation invitation, Action <IRejectFriendInvitationResult> callback)
{
IInternalIncomingFriendInvitation internalInvitation = incomingFriendInvitations.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.Id == invitation.Id);
if (internalInvitation == null)
{
logger.Critical("Friend invitation to reject not found");
callback(new RejectFriendInvitationResult(success: false));
return;
}
FriendInvitationRejecter.Reject(logger, notificationQueue, mixWebCallFactory, internalInvitation.InvitationId, delegate
{
RemoveIncomingFriendInvitation(internalInvitation.InvitationId);
internalInvitation.Rejected();
callback(new RejectFriendInvitationResult(success: true));
}, delegate
{
callback(new RejectFriendInvitationResult(success: false));
});
}
public void AddFriend(User domainFriend, bool isTrusted, long invitationId)
{
IInternalFriend friend = RemoteUserFactory.CreateFriend(domainFriend.UserId, isTrusted, domainFriend.DisplayName, domainFriend.FirstName, userDatabase);
IInternalFriend internalFriend = friends.FirstOrDefault((IInternalFriend f) => f.Id == friend.Id && f.IsTrusted != friend.IsTrusted);
if (internalFriend != null)
{
friends.Remove(internalFriend);
}
if (!friends.Any((IInternalFriend f) => f.Id == friend.Id))
{
friends.Add(friend);
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = RemoveIncomingFriendInvitation(invitationId);
if (internalIncomingFriendInvitation != null)
{
internalIncomingFriendInvitation.Accepted(isTrusted, friend);
}
else
{
RemoveOutgoingFriendInvitation(invitationId)?.Accepted(isTrusted, friend);
}
}
}
public void RemoveIncomingFriendInvitation(IInternalIncomingFriendInvitation invitation)
{
oldInvitationIds.Add(invitation.InvitationId);
incomingFriendInvitations.Remove(invitation);
}
