public IList <IInternalFriend> ParseFriendships(GetStateResponse response, IUserDatabase userDatabase)
{
List <IInternalFriend> list = new List <IInternalFriend>();
List <User> users = response.Users;
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
string userId = friendship.FriendUserId;
bool value = friendship.IsTrusted.Value;
string displayNameText = string.Empty;
string firstName = string.Empty;
if (users != null)
{
User user = users.FirstOrDefault((User u) => u.UserId == userId);
if (user != null)
{
displayNameText = user.DisplayName;
firstName = user.FirstName;
}
}
IInternalFriend item = RemoteUserFactory.CreateFriend(userId, value, displayNameText, firstName, userDatabase);
list.Add(item);
}
}
return(list);
}
public void ParseFriendshipInvitations(GetStateResponse response, IUserDatabase userDatabase, IInternalLocalUser localUser, out IList <IInternalIncomingFriendInvitation> incomingFriendInvitations, out IList <IInternalOutgoingFriendInvitation> outgoingFriendInvitations)
{
incomingFriendInvitations = new List <IInternalIncomingFriendInvitation>();
outgoingFriendInvitations = new List <IInternalOutgoingFriendInvitation>();
if (response.FriendshipInvitations != null)
{
foreach (FriendshipInvitation invitation in response.FriendshipInvitations)
{
List <User> users = response.Users;
Func <User, bool> predicate = (User user) => user.DisplayName == invitation.FriendDisplayName;
string firstName = users.FirstOrDefault(predicate)?.FirstName;
if (invitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, invitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
outgoingFriendInvitations.Add(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, invitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
incomingFriendInvitations.Add(incomingFriendInvitation);
}
}
}
}
private static IList <IInternalFriend> CreateFriends(IUserDatabase userDatabase)
{
return(userDatabase.GetAllFriendDocuments().Select(delegate(FriendDocument friendDoc)
{
UserDocument userBySwid = userDatabase.GetUserBySwid(friendDoc.Swid);
return RemoteUserFactory.CreateFriend(friendDoc.Swid, friendDoc.IsTrusted, userBySwid.DisplayName, userBySwid.FirstName, userDatabase);
}).ToList());
}
private static IEnumerable <OutgoingFriendInvitation> GetOutgoingFriendInvitations(IUserDatabase userDatabase, IInternalLocalUser localUser)
{
return((from friendInvitationDoc in userDatabase.GetFriendInvitationDocuments(isInviter : true)
where userDatabase.GetUserByDisplayName(friendInvitationDoc.DisplayName) != null
select friendInvitationDoc).Select(delegate(FriendInvitationDocument friendInvitationDoc)
{
UserDocument userByDisplayName = userDatabase.GetUserByDisplayName(friendInvitationDoc.DisplayName);
string displayName = userByDisplayName.DisplayName;
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(displayName, userByDisplayName.FirstName, userDatabase);
bool isTrusted = friendInvitationDoc.IsTrusted;
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, isTrusted);
outgoingFriendInvitation.SendComplete(friendInvitationDoc.FriendInvitationId);
return outgoingFriendInvitation;
}).ToList());
}
public static void Search(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, string displayName, IUserDatabase userDatabase, Action <IInternalUnidentifiedUser> successCallback, Action failureCallback)
{
try
{
DisplayNameSearchRequest displayNameSearchRequest = new DisplayNameSearchRequest();
displayNameSearchRequest.DisplayName = displayName;
DisplayNameSearchRequest request = displayNameSearchRequest;
IWebCall <DisplayNameSearchRequest, DisplayNameSearchResponse> webCall = mixWebCallFactory.SearchDisplaynamePost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <DisplayNameSearchResponse> e)
{
DisplayNameSearchResponse response = e.Response;
if (ValidateResponse(response))
{
userDatabase.InsertUserDocument(new UserDocument
{
DisplayName = response.DisplayName,
FirstName = response.FirstName,
Swid = null,
HashedSwid = null
});
IInternalUnidentifiedUser obj = RemoteUserFactory.CreateUnidentifiedUser(response.DisplayName, response.FirstName, userDatabase);
successCallback(obj);
}
else
{
logger.Critical("Failed to validate display name search response: " + JsonParser.ToJson(response));
failureCallback();
}
};
webCall.OnError += delegate(object sender, WebCallErrorEventArgs e)
{
logger.Debug("Failed to find user: "******"Unhandled exception: " + arg);
failureCallback();
}
}
public static void Recommend(AbstractLogger logger, IMixWebCallFactory mixWebCallFactory, IUserDatabase userDatabase, Action <IEnumerable <IInternalUnidentifiedUser> > successCallback, Action failureCallback)
{
try
{
BaseUserRequest request = new BaseUserRequest();
IWebCall <BaseUserRequest, GetFriendshipRecommendationResponse> webCall = mixWebCallFactory.FriendshipRecommendPost(request);
webCall.OnResponse += delegate(object sender, WebCallEventArgs <GetFriendshipRecommendationResponse> e)
{
List <FriendRecommendation> friendRecommendations = e.Response.FriendRecommendations;
if (friendRecommendations == null)
{
failureCallback();
}
else
{
foreach (FriendRecommendation item in friendRecommendations)
{
userDatabase.InsertUserDocument(new UserDocument
{
DisplayName = item.DisplayName,
FirstName = item.FirstName,
Swid = null,
HashedSwid = null
});
}
IInternalUnidentifiedUser[] obj = (from item in friendRecommendations
select RemoteUserFactory.CreateUnidentifiedUser(item.DisplayName, item.FirstName, userDatabase)).ToArray();
successCallback(obj);
}
};
webCall.OnError += delegate
{
failureCallback();
};
webCall.Execute();
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
failureCallback();
}
}
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);
}
else
{
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);
}
else
{
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);
}
}
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)
{
List <IInternalIncomingFriendInvitation> source = list;
Func <IInternalIncomingFriendInvitation, bool> predicate = (IInternalIncomingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId;
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = source.FirstOrDefault(predicate);
if (internalIncomingFriendInvitation != null)
{
if (internalIncomingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalIncomingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list.Remove(internalIncomingFriendInvitation);
}
else
{
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);
}
else
{
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();
}
}
