public string GetUUI(UUID userID, UUID targetUserID)
{
// Let's see if it's a local user
UserAccount account = m_UserAccountService.GetUserAccount(null, targetUserID);
if (account != null)
{
return(targetUserID.ToString() + ";" + m_GridName + ";" + account.FirstName + " " + account.LastName);
}
// Let's try the list of friends
List <FriendInfo> friends = m_FriendsService.GetFriends(userID);
if (friends != null && friends.Count > 0)
{
foreach (FriendInfo f in friends)
{
if (f.Friend.StartsWith(targetUserID.ToString()))
{
// Let's remove the secret
UUID id;
string tmp = string.Empty, secret = string.Empty;
if (HGUtil.ParseUniversalUserIdentifier(f.Friend, out id, out tmp, out tmp, out tmp, out secret))
{
return(f.Friend.Replace(secret, "0"));
}
}
}
}
return(string.Empty);
}
public override bool StoreFriend(UUID PrincipalID, string Friend, int flags)
{
IUserAccountService userAccountService = m_registry.RequestModuleInterface <IUserAccountService> ();
UserAccount agentAccount = userAccountService.GetUserAccount(null, PrincipalID);
UUID FriendUUID;
if (!UUID.TryParse(Friend, out FriendUUID))
{
return(base.StoreFriend(PrincipalID, Friend, flags));//Already set to a UUI
}
else
{
UserAccount friendAccount = userAccountService.GetUserAccount(null, FriendUUID);
if (agentAccount == null || friendAccount == null)
{
// remote grid users
ICapsService capsService = m_registry.RequestModuleInterface <ICapsService> ();
IClientCapsService FriendCaps = capsService.GetClientCapsService(UUID.Parse(Friend));
if (FriendCaps != null && FriendCaps.GetRootCapsService() != null)
{
Friend = HGUtil.ProduceUserUniversalIdentifier(FriendCaps.GetRootCapsService().CircuitData);
}
}
return(base.StoreFriend(PrincipalID, Friend, flags));
}
}
public List <UUID> GetOnlineFriends(UUID foreignUserID, List <string> friends)
{
List <UUID> online = new List <UUID> ();
if (m_FriendsService == null || m_PresenceService == null)
{
MainConsole.Instance.WarnFormat("[USER AGENT SERVICE]: Unable to get online friends because friends or presence services are missing");
return(online);
}
MainConsole.Instance.DebugFormat("[USER AGENT SERVICE]: Foreign user {0} wants to know status of {1} local friends", foreignUserID, friends.Count);
// First, let's double check that the reported friends are, indeed, friends of that user
// And let's check that the secret matches and the rights
List <string> usersToBeNotified = new List <string> ();
foreach (string uui in friends)
{
UUID localUserID;
string secret = string.Empty, tmp = string.Empty;
if (HGUtil.ParseUniversalUserIdentifier(uui, out localUserID, out tmp, out tmp, out tmp, out secret))
{
List <FriendInfo> friendInfos = m_FriendsService.GetFriends(localUserID);
foreach (FriendInfo finfo in friendInfos)
{
if (finfo.Friend.StartsWith(foreignUserID.ToString()) && finfo.Friend.EndsWith(secret) &&
(finfo.TheirFlags & (int)FriendRights.CanSeeOnline) != 0 && (finfo.TheirFlags != -1))
{
// great!
usersToBeNotified.Add(localUserID.ToString());
}
}
}
}
// Now, let's find out their status
MainConsole.Instance.DebugFormat("[USER AGENT SERVICE]: GetOnlineFriends: user has {0} local friends with status rights", usersToBeNotified.Count);
// First, let's send notifications to local users who are online in the home grid
List <UserInfo> friendSessions = m_PresenceService.GetUserInfos(usersToBeNotified);
if (friendSessions != null && friendSessions.Count > 0)
{
foreach (UserInfo pi in friendSessions)
{
UUID presenceID;
if (UUID.TryParse(pi.UserID, out presenceID))
{
online.Add(presenceID);
}
}
}
return(online);
}
public bool RemoteStatusNotification(FriendInfo friend, UUID userID, bool online)
{
string url, first, last, secret;
UUID FriendToInform;
if (HGUtil.ParseUniversalUserIdentifier(friend.Friend, out FriendToInform, out url, out first, out last, out secret))
{
UserAgentServiceConnector connector = new UserAgentServiceConnector(url);
List <UUID> informedFriends = connector.StatusNotification(new List <string> (new string[1] {
FriendToInform.ToString()
}),
userID, online);
return(informedFriends.Count > 0);
}
return(false);
}
byte[] NewFriendship(Dictionary <string, object> request)
{
if (!VerifyServiceKey(request))
{
return(FailureResult());
}
// OK, can proceed
FriendInfo friend = new FriendInfo(request);
UUID friendID;
string tmp = string.Empty;
if (!HGUtil.ParseUniversalUserIdentifier(friend.Friend, out friendID, out tmp, out tmp, out tmp, out tmp))
{
return(FailureResult());
}
MainConsole.Instance.DebugFormat("[HGFRIENDS HANDLER]: New friendship {0} {1}", friend.PrincipalID, friend.Friend);
// If the friendship already exists, return fail
List <FriendInfo> finfos = m_FriendsService.GetFriends(friend.PrincipalID);
foreach (FriendInfo finfo in finfos)
{
if (finfo.Friend.StartsWith(friendID.ToString()))
{
return(FailureResult());
}
}
// the user needs to confirm when he gets home
bool success = m_FriendsService.StoreFriend(friend.PrincipalID, friend.Friend, 0);
if (success)
{
return(SuccessResult());
}
else
{
return(FailureResult());
}
}
public void OfflineFriendRequest(IClientAPI client)
{
// Barrowed a few lines from SendFriendsOnlineIfNeeded() above.
UUID agentID = client.AgentId;
FriendInfo[] friends = FriendsService.GetFriendsRequest(agentID).ToArray();
GridInstantMessage im = new GridInstantMessage(client.Scene, UUID.Zero, String.Empty, agentID,
(byte)InstantMessageDialog.FriendshipOffered,
"Will you be my friend?", true, Vector3.Zero);
foreach (FriendInfo fi in friends)
{
if (fi.MyFlags == 0)
{
UUID fromAgentID;
string url = "", first = "", last = "", secret = "";
if (!UUID.TryParse(fi.Friend, out fromAgentID))
{
if (
!HGUtil.ParseUniversalUserIdentifier(fi.Friend, out fromAgentID, out url, out first, out last, out secret))
{
continue;
}
}
UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(client.Scene.RegionInfo.AllScopeIDs, fromAgentID);
im.fromAgentID = fromAgentID;
if (account != null)
{
im.fromAgentName = account.Name;
}
else
{
im.fromAgentName = first + " " + last;
}
im.offline = 1;
im.imSessionID = im.fromAgentID;
LocalFriendshipOffered(agentID, im);
}
}
}
private void OnDenyFriendRequest(IClientAPI client, UUID agentID, UUID friendID, List <UUID> callingCardFolders)
{
MainConsole.Instance.DebugFormat("[FRIENDS]: {0} denied friendship to {1}", agentID, friendID);
FriendInfo[] friends = FriendsService.GetFriendsRequest(agentID).ToArray();
foreach (FriendInfo fi in friends)
{
if (fi.MyFlags == 0)
{
UUID fromAgentID;
string url = "", first = "", last = "", secret = "";
if (!UUID.TryParse(fi.Friend, out fromAgentID))
{
if (
!HGUtil.ParseUniversalUserIdentifier(fi.Friend, out fromAgentID, out url, out first, out last, out secret))
{
continue;
}
}
if (fromAgentID == friendID)//Get those pesky HG travelers as well
{
FriendsService.Delete(agentID, fi.Friend);
}
}
}
FriendsService.Delete(friendID, agentID.ToString());
//
// Notify the friend
//
// Try local
if (LocalFriendshipDenied(agentID, client.Name, friendID))
{
return;
}
SyncMessagePosterService.Post(SyncMessageHelper.FriendshipDenied(
agentID, client.Name, friendID, m_Scenes[0].RegionInfo.RegionHandle),
m_Scenes[0].RegionInfo.RegionHandle);
}
public List <UUID> StatusNotification(List <string> friends, UUID foreignUserID, bool online)
{
if (m_FriendsService == null || m_PresenceService == null)
{
MainConsole.Instance.WarnFormat("[USER AGENT SERVICE]: Unable to perform status notifications because friends or presence services are missing");
return(new List <UUID> ());
}
List <UUID> localFriendsOnline = new List <UUID> ();
MainConsole.Instance.DebugFormat("[USER AGENT SERVICE]: Status notification: foreign user {0} wants to notify {1} local friends", foreignUserID, friends.Count);
// First, let's double check that the reported friends are, indeed, friends of that user
// And let's check that the secret matches
List <string> usersToBeNotified = new List <string> ();
foreach (string uui in friends)
{
UUID localUserID;
string secret = string.Empty, tmp = string.Empty;
if (HGUtil.ParseUniversalUserIdentifier(uui, out localUserID, out tmp, out tmp, out tmp, out secret))
{
List <FriendInfo> friendInfos = m_FriendsService.GetFriends(localUserID);
foreach (FriendInfo finfo in friendInfos)
{
if (finfo.Friend.StartsWith(foreignUserID.ToString()) && finfo.Friend.EndsWith(secret))
{
// great!
usersToBeNotified.Add(localUserID.ToString());
}
}
}
}
// Now, let's send the notifications
MainConsole.Instance.DebugFormat("[USER AGENT SERVICE]: Status notification: user has {0} local friends", usersToBeNotified.Count);
// First, let's send notifications to local users who are online in the home grid
//Send "" because if we pass the UUID, it will get the locations for all friends, even on the grid they came from
List <UserInfo> friendSessions = m_PresenceService.GetUserInfos(usersToBeNotified);
foreach (UserInfo friend in friendSessions)
{
if (friend.IsOnline)
{
GridRegion ourRegion = m_GridService.GetRegionByUUID(null, friend.CurrentRegionID);
if (ourRegion != null)
{
m_asyncPostService.Post(ourRegion.RegionHandle,
SyncMessageHelper.AgentStatusChange(foreignUserID, UUID.Parse(friend.UserID), true));
}
}
}
// Lastly, let's notify the rest who may be online somewhere else
foreach (string user in usersToBeNotified)
{
UUID id = new UUID(user);
if (m_TravelingAgents.ContainsKey(id) && m_TravelingAgents[id].GridExternalName != m_GridName)
{
string url = m_TravelingAgents[id].GridExternalName;
// forward
MainConsole.Instance.WarnFormat("[USER AGENT SERVICE]: User {0} is visiting {1}. HG Status notifications still not implemented.", user, url);
}
}
// and finally, let's send the online friends
if (online)
{
return(localFriendsOnline);
}
else
{
return(new List <UUID> ());
}
}
