public List <GroupRolesData> GetGroupRoles(GroupRequestID requestID, UUID GroupID)
{
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroupRoles", param);
List <GroupRolesData> Roles = new List <GroupRolesData>();
if (respData.Contains("error"))
{
return(Roles);
}
foreach (Hashtable role in respData.Values)
{
GroupRolesData data = new GroupRolesData();
data.Description = (string)role["Description"];
data.Members = int.Parse((string)role["Members"]);
data.Name = (string)role["Name"];
data.Powers = ulong.Parse((string)role["Powers"]);
data.RoleID = new UUID((string)role["RoleID"]);
data.Title = (string)role["Title"];
Roles.Add(data);
}
return(Roles);
}
// Returns null on error, empty list if not in any groups.
public List <UUID> GetAgentGroupList(GroupRequestID requestID, UUID AgentID)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getAgentGroupMemberships", param);
if (respData.Contains("error"))
{
return(null);
}
List <UUID> groups = new List <UUID>();
foreach (object membership in respData.Values)
{
Hashtable data = (Hashtable)membership;
UUID groupID = new UUID((string)data["GroupID"]);
groups.Add(groupID);
}
return(groups);
}
public List <GroupMembersData> GetGroupMembers(GroupRequestID requestID, UUID GroupID, bool ownersOnly)
{
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroupMembers", param);
List <GroupMembersData> members = new List <GroupMembersData>();
if (respData.Contains("error"))
{
return(members);
}
foreach (Hashtable membership in respData.Values)
{
GroupMembersData data = new GroupMembersData();
data.AcceptNotices = ((string)membership["AcceptNotices"]) == "1";
data.AgentID = new UUID((string)membership["AgentID"]);
data.Contribution = int.Parse((string)membership["Contribution"]);
data.IsOwner = ((string)membership["IsOwner"]) == "1";
data.ListInProfile = ((string)membership["ListInProfile"]) == "1";
data.AgentPowers = ulong.Parse((string)membership["AgentPowers"]);
data.Title = (string)membership["Title"];
if (data.IsOwner)
{
members.Add(data);
}
}
return(members);
}
public List <GroupNoticeData> GetGroupNotices(GroupRequestID requestID, UUID GroupID)
{
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroupNotices", param);
List <GroupNoticeData> values = new List <GroupNoticeData>();
if (!respData.Contains("error"))
{
foreach (Hashtable value in respData.Values)
{
GroupNoticeData data = new GroupNoticeData();
data.NoticeID = UUID.Parse((string)value["NoticeID"]);
data.Timestamp = uint.Parse((string)value["Timestamp"]);
data.FromName = (string)value["FromName"];
data.Subject = (string)value["Subject"];
data.HasAttachment = false;
data.AssetType = 0;
values.Add(data);
}
}
return(values);
}
public GroupNoticeInfo GetGroupNotice(GroupRequestID requestID, UUID noticeID)
{
Hashtable param = new Hashtable();
param["NoticeID"] = noticeID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroupNotice", param);
if (respData.Contains("error"))
{
return(null);
}
GroupNoticeInfo data = new GroupNoticeInfo();
data.GroupID = UUID.Parse((string)respData["GroupID"]);
data.Message = (string)respData["Message"];
data.BinaryBucket = Utils.HexStringToBytes((string)respData["BinaryBucket"], true);
data.noticeData.NoticeID = UUID.Parse((string)respData["NoticeID"]);
data.noticeData.Timestamp = uint.Parse((string)respData["Timestamp"]);
data.noticeData.FromName = (string)respData["FromName"];
data.noticeData.Subject = (string)respData["Subject"];
data.noticeData.HasAttachment = false;
data.noticeData.AssetType = 0;
if (data.Message == null)
{
data.Message = String.Empty;
}
return(data);
}
public List <DirGroupsReplyData> FindGroups(GroupRequestID requestID, string search)
{
Hashtable param = new Hashtable();
param["Search"] = search;
Hashtable respData = XmlRpcCall(requestID, "groups.findGroups", param);
List <DirGroupsReplyData> findings = new List <DirGroupsReplyData>();
if (!respData.Contains("error"))
{
Hashtable results = (Hashtable)respData["results"];
foreach (Hashtable groupFind in results.Values)
{
DirGroupsReplyData data = new DirGroupsReplyData();
data.groupID = new UUID((string)groupFind["GroupID"]);;
data.groupName = (string)groupFind["Name"];
data.members = int.Parse((string)groupFind["Members"]);
// data.searchOrder = order;
findings.Add(data);
}
}
return(findings);
}
public void RemoveAgentToGroupInvite(GroupRequestID requestID, UUID inviteID)
{
Hashtable param = new Hashtable();
param["InviteID"] = inviteID.ToString();
XmlRpcCall(requestID, "groups.removeAgentToGroupInvite", param);
}
public void SetAgentActiveGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
XmlRpcCall(requestID, "groups.setAgentActiveGroup", param);
}
public void RemoveGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID)
{
Hashtable param = new Hashtable();
param["GroupID"] = groupID.ToString();
param["RoleID"] = roleID.ToString();
XmlRpcCall(requestID, "groups.removeRoleFromGroup", param);
}
public void RemoveAgentFromGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
param["RoleID"] = RoleID.ToString();
XmlRpcCall(requestID, "groups.removeAgentFromGroupRole", param);
}
public void AddAgentToGroupRole(GroupRequestID requestID, UUID RequesterID, UUID AgentID, UUID GroupID, UUID RoleID, bool bypassChecks)
{
Hashtable param = new Hashtable();
param["RequesterID"] = RequesterID.ToString();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
param["RoleID"] = RoleID.ToString();
XmlRpcCall(requestID, "groups.addAgentToGroupRole", param);
}
public void SetAgentGroupInfo(GroupRequestID requestID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
param["AcceptNotices"] = AcceptNotices ? "1" : "0";
param["ListInProfile"] = ListInProfile ? "1" : "0";
XmlRpcCall(requestID, "groups.setAgentGroupInfo", param);
}
public bool AddAgentToGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID, bool skipPermissionChecks)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
param["RoleID"] = RoleID.ToString();
XmlRpcCall(requestID, "groups.addAgentToGroup", param);
return(true);
}
public int RemoveAgentFromGroup(GroupRequestID requestID, UUID RequesterID, UUID AgentID, UUID GroupID)
{
Hashtable param = new Hashtable();
param["RequesterID"] = RequesterID.ToString();
param["AgentID"] = AgentID.ToString();
param["GroupID"] = GroupID.ToString();
XmlRpcCall(requestID, "groups.removeAgentFromGroup", param);
return((int)Constants.GenericReturnCodes.SUCCESS);
}
public int AddAgentToGroupInvite(GroupRequestID requestID, UUID inviterID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID, out string reason)
{
Hashtable param = new Hashtable();
param["InviterID"] = inviterID.ToString();
param["InviteID"] = inviteID.ToString();
param["AgentID"] = agentID.ToString();
param["RoleID"] = roleID.ToString();
param["GroupID"] = groupID.ToString();
XmlRpcCall(requestID, "groups.addAgentToGroupInvite", param);
reason = "The user has been invited into the group.";
return((int)Constants.GenericReturnCodes.SUCCESS);
}
public void AddGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description,
string title, ulong powers, bool skipPermissionChecks)
{
Hashtable param = new Hashtable();
param["GroupID"] = groupID.ToString();
param["RoleID"] = roleID.ToString();
param["Name"] = name;
param["Description"] = description;
param["Title"] = title;
param["Powers"] = powers.ToString();
XmlRpcCall(requestID, "groups.addRoleToGroup", param);
}
public GroupMembershipData GetAgentActiveMembership(GroupRequestID requestID, UUID AgentID)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getAgentActiveMembership", param);
if (respData.Contains("error"))
{
return(null);
}
return(HashTableToGroupMembershipData(respData));
}
public void UpdateGroup(GroupRequestID requestID, UUID groupID, string charter, bool showInList,
UUID insigniaID, int membershipFee, bool openEnrollment,
bool allowPublish, bool maturePublish)
{
Hashtable param = new Hashtable();
param["GroupID"] = groupID.ToString();
param["Charter"] = charter;
param["ShowInList"] = showInList == true ? 1 : 0;
param["InsigniaID"] = insigniaID.ToString();
param["MembershipFee"] = membershipFee;
param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;
param["AllowPublish"] = allowPublish == true ? 1 : 0;
param["MaturePublish"] = maturePublish == true ? 1 : 0;
XmlRpcCall(requestID, "groups.updateGroup", param);
}
public bool AddGroupNotice(GroupRequestID requestID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
{
string binBucket = OpenMetaverse.Utils.BytesToHexString(binaryBucket, String.Empty);
Hashtable param = new Hashtable();
param["GroupID"] = groupID.ToString();
param["NoticeID"] = noticeID.ToString();
param["FromName"] = fromName;
param["Subject"] = subject;
param["Message"] = message;
param["BinaryBucket"] = binBucket;
param["TimeStamp"] = ((uint)Util.UnixTimeSinceEpoch()).ToString();
XmlRpcCall(requestID, "groups.addGroupNotice", param);
return(true);
}
public OpenMetaverse.UUID CreateGroup(GroupRequestID requestID, string name, string charter, bool showInList, OpenMetaverse.UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish, OpenMetaverse.UUID founderID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return UUID.Zero;
UUID groupID = UUID.Random();
UUID ownerRoleID = UUID.Random();
// Would this be cleaner as (GroupPowers)ulong.MaxValue;
GroupPowers ownerPowers = (GroupPowers)ulong.MaxValue;
string query
= "INSERT INTO osgroup " +
"(GroupID, Name, Charter, InsigniaID, FounderID, MembershipFee, OpenEnrollment, " +
"ShowInList, AllowPublish, MaturePublish, OwnerRoleID) " +
"VALUES(?groupid, ?name, ?charter, ?insigniaID, ?founderID, ?membershipFee, " +
"?openEnrollment, ?showInList, ?allowPublish, ?maturePublish, ?ownerRoleID)";
Dictionary<string, object> parms = new Dictionary<string,object>();
parms.Add("?groupid", groupID);
parms.Add("?name", name);
parms.Add("?charter", charter);
parms.Add("?insigniaID", insigniaID);
parms.Add("?founderID", founderID);
parms.Add("?membershipFee", membershipFee.ToString());
parms.Add("?openEnrollment", openEnrollment);
parms.Add("?showInList", showInList);
parms.Add("?allowPublish", allowPublish);
parms.Add("?maturePublish", maturePublish);
parms.Add("?ownerRoleID", ownerRoleID);
db.QueryNoResults(query, parms);
this.AddGroupRole(requestID, groupID, EVERYONE_ROLEID, "Everyone", "Everyone in the group is in the everyone role.", "Member of " + name, (ulong)Constants.DefaultEveryonePowers, true);
this.AddGroupRole(requestID, groupID, ownerRoleID, "Owners", "Owners of " + name, "Owner of " + name, (ulong) ownerPowers, true);
this.AddAgentToGroup(requestID, founderID, groupID, ownerRoleID, true);
this.SetAgentGroupSelectedRole(db, founderID, groupID, ownerRoleID);
this.SetAgentActiveGroup(requestID, founderID, groupID);
return groupID;
}
}
public List <GroupMembershipData> GetAgentGroupMemberships(GroupRequestID requestID, UUID AgentID)
{
Hashtable param = new Hashtable();
param["AgentID"] = AgentID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getAgentGroupMemberships", param);
List <GroupMembershipData> memberships = new List <GroupMembershipData>();
if (!respData.Contains("error"))
{
foreach (object membership in respData.Values)
{
memberships.Add(HashTableToGroupMembershipData((Hashtable)membership));
}
}
return(memberships);
}
/// <summary>
/// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.
/// </summary>
public UUID CreateGroup(GroupRequestID requestID, string name, string charter, bool showInList, UUID insigniaID,
int membershipFee, bool openEnrollment, bool allowPublish,
bool maturePublish, UUID founderID)
{
UUID GroupID = UUID.Random();
UUID OwnerRoleID = UUID.Random();
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
param["Name"] = name;
param["Charter"] = charter;
param["ShowInList"] = showInList == true ? 1 : 0;
param["InsigniaID"] = insigniaID.ToString();
param["MembershipFee"] = 0;
param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;
param["AllowPublish"] = allowPublish == true ? 1 : 0;
param["MaturePublish"] = maturePublish == true ? 1 : 0;
param["FounderID"] = founderID.ToString();
param["EveryonePowers"] = ((ulong)Constants.DefaultEveryonePowers).ToString();
param["OwnerRoleID"] = OwnerRoleID.ToString();
// Would this be cleaner as (GroupPowers)ulong.MaxValue;
GroupPowers OwnerPowers = (GroupPowers)ulong.MaxValue;
param["OwnersPowers"] = ((ulong)OwnerPowers).ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.createGroup", param);
if (respData.Contains("error"))
{
// UUID is not nullable
return(UUID.Zero);
}
return(UUID.Parse((string)respData["GroupID"]));
}
/// <summary>
/// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.
/// </summary>
public UUID CreateGroup(GroupRequestID requestID, string name, string charter, bool showInList, UUID insigniaID,
int membershipFee, bool openEnrollment, bool allowPublish,
bool maturePublish, UUID founderID)
{
UUID GroupID = UUID.Random();
UUID OwnerRoleID = UUID.Random();
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
param["Name"] = name;
param["Charter"] = charter;
param["ShowInList"] = showInList == true ? 1 : 0;
param["InsigniaID"] = insigniaID.ToString();
param["MembershipFee"] = 0;
param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;
param["AllowPublish"] = allowPublish == true ? 1 : 0;
param["MaturePublish"] = maturePublish == true ? 1 : 0;
param["FounderID"] = founderID.ToString();
param["EveryonePowers"] = ((ulong)Constants.DefaultEveryonePowers).ToString();
param["OwnerRoleID"] = OwnerRoleID.ToString();
// Would this be cleaner as (GroupPowers)ulong.MaxValue;
GroupPowers OwnerPowers = (GroupPowers)ulong.MaxValue;
param["OwnersPowers"] = ((ulong)OwnerPowers).ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.createGroup", param);
if (respData.Contains("error"))
{
// UUID is not nullable
return UUID.Zero;
}
return UUID.Parse((string)respData["GroupID"]);
}
public GroupProfileData GetMemberGroupProfile(GroupRequestID requestID, UUID GroupID, UUID AgentID)
{
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroup", param);
if (respData.Contains("error"))
{
// GroupProfileData is not nullable
return(new GroupProfileData());
}
GroupMembershipData MemberInfo = GetAgentGroupMembership(requestID, AgentID, GroupID);
GroupProfileData MemberGroupProfile = GroupProfileHashtableToGroupProfileData(respData);
MemberGroupProfile.MemberTitle = MemberInfo.GroupTitle;
MemberGroupProfile.PowersMask = MemberInfo.GroupPowers;
return(MemberGroupProfile);
}
public GroupInviteInfo GetAgentToGroupInvite(GroupRequestID requestID, UUID inviteID)
{
Hashtable param = new Hashtable();
param["InviteID"] = inviteID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getAgentToGroupInvite", param);
if (respData.Contains("error"))
{
return(null);
}
GroupInviteInfo inviteInfo = new GroupInviteInfo();
inviteInfo.InviteID = inviteID;
inviteInfo.GroupID = UUID.Parse((string)respData["GroupID"]);
inviteInfo.RoleID = UUID.Parse((string)respData["RoleID"]);
inviteInfo.AgentID = UUID.Parse((string)respData["AgentID"]);
return(inviteInfo);
}
public GroupRecord GetGroupRecord(GroupRequestID requestID, UUID GroupID, string GroupName)
{
Hashtable param = new Hashtable();
if (GroupID != UUID.Zero)
{
param["GroupID"] = GroupID.ToString();
}
if (!String.IsNullOrEmpty(GroupName))
{
param["Name"] = GroupName.ToString();
}
Hashtable respData = XmlRpcCall(requestID, "groups.getGroup", param);
if (respData.Contains("error"))
{
return(null);
}
return(GroupProfileHashtableToGroupRecord(respData));
}
public void UpdateGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description,
string title, ulong powers)
{
Hashtable param = new Hashtable();
param["GroupID"] = groupID.ToString();
param["RoleID"] = roleID.ToString();
if (name != null)
{
param["Name"] = name;
}
if (description != null)
{
param["Description"] = description;
}
if (title != null)
{
param["Title"] = title;
}
param["Powers"] = powers.ToString();
XmlRpcCall(requestID, "groups.updateGroupRole", param);
}
public List <GroupRoleMembersData> GetGroupRoleMembers(GroupRequestID requestID, UUID GroupID)
{
Hashtable param = new Hashtable();
param["GroupID"] = GroupID.ToString();
Hashtable respData = XmlRpcCall(requestID, "groups.getGroupRoleMembers", param);
List <GroupRoleMembersData> members = new List <GroupRoleMembersData>();
if (!respData.Contains("error"))
{
foreach (Hashtable membership in respData.Values)
{
GroupRoleMembersData data = new GroupRoleMembersData();
data.MemberID = new UUID((string)membership["AgentID"]);
data.RoleID = new UUID((string)membership["RoleID"]);
members.Add(data);
}
}
return(members);
}
public List<OpenSim.Framework.DirGroupsReplyData> FindGroups(GroupRequestID requestID, string search)
{
List<OpenSim.Framework.DirGroupsReplyData> replyData = new List<OpenSim.Framework.DirGroupsReplyData>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return replyData;
string query = " SELECT osgroup.GroupID, osgroup.Name, count(osgroupmembership.AgentID) as Members " +
" FROM osgroup " +
"LEFT JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID) " +
/*" WHERE MATCH (osgroup.name) AGAINST (?search IN BOOLEAN MODE) " +*/
" WHERE osgroup.name LIKE ?likeSearch " +
" OR osgroup.name REGEXP ?search " +
" OR osgroup.charter LIKE ?likeSearch " +
" OR osgroup.charter REGEXP ?search " +
" GROUP BY osgroup.GroupID, osgroup.Name ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?search", search);
parms.Add("?likeSearch", "%" + search + "%");
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
replyData.Add(MapGroupReplyDataFromResult(result));
}
}
return replyData;
}
public int RemoveAgentFromGroup(GroupRequestID requestID, OpenMetaverse.UUID RequesterID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID)
{
// Extra check needed for group owner removals - cannot remove the Owner role unless you are the user
GroupRecord groupRec = GetGroupRecord(requestID, GroupID, null);
if (groupRec == null) return (int)Constants.GenericReturnCodes.PARAMETER;
// Is this the last owner in a group? Don't let group managers shoot themselves in the foot.
List<UUID> groupOwners = GetGroupMembersWithRole(requestID, GroupID, groupRec.OwnerRoleID);
if (groupOwners.Contains(AgentID))
{
// Sorry Dave, I can't allow you to remove yourself if you are the only owner.
if (groupOwners.Count < 2)
{
m_log.WarnFormat("[GROUPS]: {0} Cannot remove the only owner {1} in group {2}", RequesterID, AgentID, GroupID);
return (int)Constants.GenericReturnCodes.PERMISSION;
}
// An owner can only be removed by themselves...
if (RequesterID != AgentID)
{
m_log.WarnFormat("[GROUPS]: {0} Cannot remove owner {1} of group {2}", RequesterID, AgentID, GroupID);
return (int)Constants.GenericReturnCodes.PERMISSION;
}
}
//user can always remove themselves from a group so skip tests in that case
if (RequesterID != AgentID)
{
if (!this.TestForPower(requestID, RequesterID, GroupID, (ulong)GroupPowers.Eject))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to remove {1} from group {2}", RequesterID, AgentID, GroupID);
return (int)Constants.GenericReturnCodes.PERMISSION;
}
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return (int)Constants.GenericReturnCodes.ERROR;
if (!IsAgentMemberOfGroup(db, AgentID, GroupID))
{
m_log.WarnFormat("[GROUPS]: {0} Cannot remove non-member {1} from group {2}", requestID.AgentID, AgentID, GroupID);
return (int)Constants.GenericReturnCodes.PERMISSION;
}
string query = " UPDATE osagent " +
" SET ActiveGroupID = '" + UUID.Zero.ToString() + "' " +
" WHERE AgentID = ?agentID AND ActiveGroupID = ?groupID";
Dictionary<string, object> parms = new Dictionary<string,object>();
parms.Add("?agentID", AgentID);
parms.Add("?groupID", GroupID);
db.QueryNoResults(query, parms);
query = " DELETE FROM osgroupmembership " +
" WHERE AgentID = ?agentID AND GroupID = ?groupID";
db.QueryNoResults(query, parms);
query = " DELETE FROM osgrouprolemembership " +
" WHERE AgentID = ?agentID AND GroupID = ?groupID";
db.QueryNoResults(query, parms);
}
return (int)Constants.GenericReturnCodes.SUCCESS;
}
public void SetAgentActiveGroup(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID)
{
//only the agent making the call can change their own group
if (requestID.AgentID != AgentID)
{
m_log.WarnFormat("[GROUPS]: User {0} No permission to change the active group for {1}", requestID.AgentID, AgentID);
return;
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return;
//test to see if the user even exists in osagent
if (AgentHasActiveGroup(db, AgentID))
{
string query
= "UPDATE osagent " +
"SET ActiveGroupID = ?activeGroupID " +
"WHERE AgentID = ?agentID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?activeGroupID", GroupID);
parms.Add("?agentID", AgentID);
db.QueryNoResults(query, parms);
}
else
{
string query
= "INSERT INTO osagent (ActiveGroupID, AgentID) " +
"VALUES(?groupID, ?agentID)";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
parms.Add("?agentID", AgentID);
db.QueryNoResults(query, parms);
}
}
}
public int AddAgentToGroupInvite(GroupRequestID requestID, OpenMetaverse.UUID inviterID, OpenMetaverse.UUID inviteID, OpenMetaverse.UUID groupID,
OpenMetaverse.UUID roleID, OpenMetaverse.UUID agentID, out string reason)
{
if (!this.TestForPower(requestID, inviterID, groupID, (ulong)GroupPowers.Invite))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to invite {1} to group {2}", inviterID, agentID, groupID);
reason = "You do not have permission to invite others into that group.";
return (int)Constants.GenericReturnCodes.PERMISSION;
}
if (roleID != EVERYONE_ROLEID)
{
if (!CanAddAgentToRole(requestID, inviterID, agentID, groupID, roleID, false))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to assign new role for user {1} in group {2}.", inviterID, agentID, groupID);
reason = "You do not have permission to invite others into that group role.";
return (int)Constants.GenericReturnCodes.PERMISSION;
}
}
// In case they didn't get the IM or just closed it, offer them the invite again even if it's redundant.
// if (AgentHasBeenInvitedToGroup(agentID, groupID, roleID))
// return (int)Constants.GenericReturnCodes.NOCHANGE; // redundant request
using (ISimpleDB db = GetConnection())
{
if (db == null)
{
reason = "MySQL connection failed";
return (int)Constants.GenericReturnCodes.ERROR;
}
if (IsAgentMemberOfGroup(db, agentID, groupID))
{
// The target user is already a member of the group. See if they are already in that role.
if (roleID == EVERYONE_ROLEID)
{
reason = "That user is already a member of the group.";
return (int)Constants.GenericReturnCodes.NOCHANGE; // redundant request
}
// See if they are already in that role.
if (IsAgentInRole(db, agentID, groupID, roleID))
{
reason = "The user is already in that group with that role.";
return (int)Constants.GenericReturnCodes.NOCHANGE; // redundant request
}
// Otherwise, add the specified role.
AddAgentToGroupRole(requestID, inviterID, agentID, groupID, roleID, true);
reason = "The user has been assigned an additional new group role.";
return (int)Constants.GenericReturnCodes.SUCCESS; // agent's group membership updated with specified role
}
// Remove any existing invites for this agent to this group
string query = " DELETE FROM osgroupinvite" +
" WHERE osgroupinvite.AgentID = ?agentID AND osgroupinvite.GroupID = ?groupID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?agentID", agentID);
parms.Add("?groupID", groupID);
db.QueryNoResults(query, parms);
// Add new invite for this agent to this group for the specifide role
query = " INSERT INTO osgroupinvite (InviteID, GroupID, RoleID, AgentID) " +
" VALUES (?inviteID, ?groupID, ?roleID, ?agentID)";
parms.Add("?inviteID", inviteID);
parms.Add("?roleID", roleID);
db.QueryNoResults(query, parms);
}
reason = "The user has been invited into the group.";
return (int)Constants.GenericReturnCodes.SUCCESS;
}
public bool AddGroupNotice(GroupRequestID requestID, OpenMetaverse.UUID groupID, OpenMetaverse.UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
{
if (!this.TestForPower(requestID, requestID.AgentID, groupID, (ulong)GroupPowers.SendNotices))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to send notices for group {1}", requestID.AgentID, groupID);
return false;
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return false;
string binBucketString = OpenMetaverse.Utils.BytesToHexString(binaryBucket, "");
string query = " INSERT INTO osgroupnotice" +
" (GroupID, NoticeID, Timestamp, FromName, Subject, Message, BinaryBucket)" +
" VALUES " +
" (?groupID, ?noticeID, ?timeStamp, ?fromName, ?subject, ?message, ?binaryBucket)";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", groupID);
parms.Add("?noticeID", noticeID);
parms.Add("?timeStamp", ((uint)Util.UnixTimeSinceEpoch()).ToString());
parms.Add("?fromName", fromName);
parms.Add("?subject", subject);
parms.Add("?message", message);
parms.Add("?binaryBucket", binBucketString);
db.QueryNoResults(query, parms);
}
return true;
}
// This fetches a summary list of all notices in the group.
public List<OpenSim.Framework.GroupNoticeData> GetGroupNotices(GroupRequestID requestID, OpenMetaverse.UUID GroupID)
{
List<OpenSim.Framework.GroupNoticeData> foundNotices = new List<OpenSim.Framework.GroupNoticeData>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return foundNotices;
string query
= " SELECT GroupID, NoticeID, Timestamp, FromName, Subject, Message, BinaryBucket" +
" FROM osgroupnotice" +
" WHERE osgroupnotice.GroupID = ?groupID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
foundNotices.Add(this.MapGroupNoticeDataFromResult(result));
}
}
return foundNotices;
}
public void RemoveGroupRole(GroupRequestID requestID, OpenMetaverse.UUID groupID, OpenMetaverse.UUID roleID)
{
if (!TestForPower(requestID, requestID.AgentID, groupID, (ulong)GroupPowers.DeleteRole))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to remove group roles", requestID.AgentID);
return;
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return;
Dictionary<string, object> parms = new Dictionary<string,object>();
parms.Add("?groupID", groupID);
parms.Add("?roleID", roleID);
string query = "DELETE FROM osgrouprolemembership WHERE GroupID = ?groupID AND RoleID = ?roleID";
db.QueryNoResults(query, parms);
query = "UPDATE osgroupmembership SET SelectedRoleID = '" +
EVERYONE_ROLEID.ToString() + "' WHERE GroupID = ?groupID AND SelectedRoleID = ?roleID";
db.QueryNoResults(query, parms);
query = "DELETE FROM osrole WHERE GroupID = ?groupID AND RoleID = ?roleID";
db.QueryNoResults(query, parms);
}
}
public List<OpenSim.Framework.GroupRolesData> GetGroupRoles(GroupRequestID requestID, OpenMetaverse.UUID GroupID)
{
List<OpenSim.Framework.GroupRolesData> foundRoles = new List<OpenSim.Framework.GroupRolesData>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return foundRoles;
string query
= " SELECT osrole.RoleID, osrole.Name, osrole.Title, osrole.Description, osrole.Powers, " +
" count(osgrouprolemembership.AgentID) as Members " +
" FROM osrole " +
" LEFT JOIN osgrouprolemembership ON (osrole.GroupID = osgrouprolemembership.GroupID " +
" AND osrole.RoleID = osgrouprolemembership.RoleID) " +
" WHERE osrole.GroupID = ?groupID " +
" GROUP BY osrole.RoleID, osrole.Name, osrole.Title, osrole.Description, osrole.Powers ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
foundRoles.Add(this.MapGroupRolesDataFromResult(result));
}
}
return foundRoles;
}
public List<UUID> GetGroupMembersWithRole(GroupRequestID requestID, UUID GroupID, UUID RoleID)
{
string query = " SELECT * FROM osgrouprolemembership WHERE GroupID = ?groupID AND RoleID = ?roleID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
parms.Add("?roleID", RoleID);
List<UUID> roleMembersData = new List<UUID>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return roleMembersData;
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
roleMembersData.Add(new UUID(result["AgentID"]));
}
return roleMembersData;
}
public bool AgentHasOwnerRole(ISimpleDB db, GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID)
{
GroupRecord groupInfo = GetGroupRecord(requestID, GroupID, null);
if (groupInfo == null) return false;
return IsAgentInRole(db, AgentID, GroupID, groupInfo.OwnerRoleID);
}
public List<OpenSim.Framework.GroupRolesData> GetAgentGroupRoles(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID)
{
List<OpenSim.Framework.GroupRolesData> foundGroupRoles = new List<OpenSim.Framework.GroupRolesData>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return foundGroupRoles;
string query
= " SELECT osrole.RoleID, osrole.GroupID, osrole.Title, osrole.Name, osrole.Description, osrole.Powers" +
" , CASE WHEN osgroupmembership.SelectedRoleID = osrole.RoleID THEN 1 ELSE 0 END AS Selected" +
" FROM osgroupmembership " +
" JOIN osgrouprolemembership ON (osgroupmembership.GroupID = osgrouprolemembership.GroupID AND osgroupmembership.AgentID = osgrouprolemembership.AgentID)" +
" JOIN osrole ON ( osgrouprolemembership.RoleID = osrole.RoleID AND osgrouprolemembership.GroupID = osrole.GroupID)" +
" LEFT JOIN osagent ON (osagent.AgentID = osgroupmembership.AgentID)" +
" WHERE osgroupmembership.AgentID = ?agentID ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?agentID", AgentID);
if (GroupID != UUID.Zero)
{
query += " AND osgroupmembership.GroupID = ?groupID ";
parms.Add("?groupID", GroupID);
}
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
foundGroupRoles.Add(this.MapGroupRolesDataFromResult(result));
}
}
return foundGroupRoles;
}
public List<OpenSim.Framework.GroupRoleMembersData> GetGroupRoleMembers(GroupRequestID requestID, OpenMetaverse.UUID GroupID)
{
string query
= " SELECT osrole.RoleID, osgrouprolemembership.AgentID " +
" FROM osrole " +
" INNER JOIN osgrouprolemembership ON (osrole.GroupID = osgrouprolemembership.GroupID " +
" AND osrole.RoleID = osgrouprolemembership.RoleID)" +
" WHERE osrole.GroupID = ?groupID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
List<OpenSim.Framework.GroupRoleMembersData> foundMembersData = new List<OpenSim.Framework.GroupRoleMembersData>();
using (ISimpleDB db = GetConnection())
{
if (db == null)
return foundMembersData;
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
foundMembersData.Add(this.MapFoundMembersDataFromResult(result));
}
}
return foundMembersData;
}
public OpenSim.Framework.GroupRecord GetGroupRecord(GroupRequestID requestID, OpenMetaverse.UUID GroupID, string GroupName)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return null;
string query = " SELECT osgroup.GroupID, osgroup.Name, Charter, InsigniaID, FounderID, MembershipFee, " +
"OpenEnrollment, ShowInList, AllowPublish, MaturePublish, OwnerRoleID " +
" , count(osrole.RoleID) as GroupRolesCount, count(osgroupmembership.AgentID) as GroupMembershipCount " +
" FROM osgroup " +
" LEFT JOIN osrole ON (osgroup.GroupID = osrole.GroupID)" +
" LEFT JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID)" +
" WHERE ";
Dictionary<string, object> parms = new Dictionary<string,object>();
if (GroupID != UUID.Zero)
{
query += " osgroup.GroupID = ?groupID ";
parms.Add("?groupID", GroupID);
}
else if ((GroupName != null) && (GroupName != string.Empty))
{
query += " osgroup.Name = ?groupName ";
parms.Add("?groupName", GroupName);
}
else
{
throw new InvalidOperationException("Group name, or group id must be specified");
}
query += " GROUP BY osgroup.GroupID, osgroup.name, charter, insigniaID, founderID, membershipFee, openEnrollment, showInList, allowPublish, maturePublish, ownerRoleID ";
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
if (results.Count == 1 && results[0].ContainsKey("GroupID"))
{
return this.MapGroupRecordFromResult(results[0]);
}
// string trace = Environment.StackTrace;
// m_log.WarnFormat("[GROUPS]: GetGroupRecord: Could not find exact match for {0} '{1}':", GroupID, GroupName);
// m_log.Warn(trace);
return null;
}
}
public void UpdateGroup(GroupRequestID requestID, OpenMetaverse.UUID groupID, string charter, bool showInList, OpenMetaverse.UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
{
if (!TestForPower(requestID, requestID.AgentID, groupID, (ulong)GroupPowers.ChangeIdentity))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to change group options", requestID.AgentID);
return;
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return;
string query
= "UPDATE osgroup " +
"SET " +
" Charter = ?charter" +
" , InsigniaID = ?insigniaID" +
" , MembershipFee = ?membershipFee" +
" , OpenEnrollment= ?openEnrollment" +
" , ShowInList = ?showInList" +
" , AllowPublish = ?allowPublish" +
" , MaturePublish = ?maturePublish" +
" WHERE " +
" GroupID = ?groupID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?charter", charter);
parms.Add("?insigniaID", insigniaID);
parms.Add("?membershipFee", membershipFee);
parms.Add("?openEnrollment", openEnrollment);
parms.Add("?showInList", showInList);
parms.Add("?allowPublish", allowPublish);
parms.Add("?maturePublish", maturePublish);
parms.Add("?groupID", groupID);
db.QueryNoResults(query, parms);
}
}
bool TestForPower(GroupRequestID requestID, OpenMetaverse.UUID agentID, OpenMetaverse.UUID groupID, ulong power)
{
GroupMembershipData membershipData = GetAgentGroupMembership(requestID, agentID, groupID);
if (membershipData == null)
{
return false;
}
if ((membershipData.GroupPowers & power) == 0)
{
return false;
}
return true;
}
// WARNING: This method does not initialize all notice fields, namely the fields stored in the binary bucket.
// See FlexiGroups.cs method InitializeNoticeFromBucket() for an example.
public GroupNoticeInfo GetGroupNotice(GroupRequestID requestID, OpenMetaverse.UUID noticeID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return null;
string query
= " SELECT GroupID, NoticeID, Timestamp, FromName, Subject, Message, BinaryBucket" +
" FROM osgroupnotice" +
" WHERE osgroupnotice.NoticeID = ?noticeID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?noticeID", noticeID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
if (results.Count == 0)
{
return null;
}
else
{
return this.MapGroupNoticeFromResult(results[0]);
}
}
}
public void SetAgentGroupInfo(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID, bool AcceptNotices, bool ListInProfile)
{
//the agent making the reuqest must be the target agent
if (requestID.AgentID != AgentID)
{
m_log.WarnFormat("[GROUPS]: {0} No permission to change group info for {1}", requestID.AgentID, AgentID);
return;
}
string query =
"UPDATE osgroupmembership " +
"SET AcceptNotices = ?acceptNotices, " +
"ListInProfile = ?listInProfile " +
"WHERE osgroupmembership.GroupID = ?groupID " +
"AND osgroupmembership.AgentID = ?agentID ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?acceptNotices", AcceptNotices);
parms.Add("?listInProfile", ListInProfile);
parms.Add("?groupID", GroupID);
parms.Add("?agentID", AgentID);
using (ISimpleDB db = GetConnection())
{
if (db != null)
db.QueryNoResults(query, parms);
}
}
public List<OpenSim.Framework.GroupMembershipData> GetAgentGroupMemberships(GroupRequestID requestID, OpenMetaverse.UUID AgentID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return new List<OpenSim.Framework.GroupMembershipData>();
string query = " SELECT osgroup.GroupID, osgroup.Name as GroupName, osgroup.Charter, osgroup.InsigniaID, osgroup.FounderID, osgroup.MembershipFee, osgroup.OpenEnrollment, osgroup.ShowInList, osgroup.AllowPublish, osgroup.MaturePublish" +
" , osgroupmembership.Contribution, osgroupmembership.ListInProfile, osgroupmembership.AcceptNotices" +
" , osgroupmembership.SelectedRoleID, osrole.Title" +
" , IFNULL(osagent.ActiveGroupID, '" + UUID.Zero + "') AS ActiveGroupID" +
" FROM osgroup JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID)" +
" JOIN osrole ON (osgroupmembership.SelectedRoleID = osrole.RoleID AND osgroupmembership.GroupID = osrole.GroupID)" +
" LEFT JOIN osagent ON (osagent.AgentID = osgroupmembership.AgentID)" +
" WHERE osgroupmembership.AgentID = ?agentID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?agentID", AgentID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
//map the group data first into a dict so that it'll be easy to search to fill
//the group powers
Dictionary<string, OpenSim.Framework.GroupMembershipData> membershipData = new Dictionary<string, OpenSim.Framework.GroupMembershipData>();
foreach (Dictionary<string, string> result in results)
{
membershipData.Add(result["GroupID"], this.MapGroupMembershipDataFromResult(result, null));
}
//now, assign the group powers returned
query = " SELECT BIT_OR(osrole.Powers) AS GroupPowers, osgrouprolemembership.GroupID" +
" FROM osgrouprolemembership JOIN osrole ON (osgrouprolemembership.GroupID = osrole.GroupID AND osgrouprolemembership.RoleID = osrole.RoleID)" +
" WHERE osgrouprolemembership.AgentID = ?agentID " +
" GROUP BY GroupID ";
results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
if (result.ContainsKey("GroupID") && membershipData.ContainsKey(result["GroupID"]))
{
OpenSim.Framework.GroupMembershipData currMembershipData = membershipData[result["GroupID"]];
currMembershipData.GroupPowers = ulong.Parse(result["GroupPowers"]);
}
}
return new List<OpenSim.Framework.GroupMembershipData>(membershipData.Values);
}
}
private bool AgentCanJoinGroup(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID, OpenMetaverse.UUID RoleID)
{
GroupRecord record = GetGroupRecord(requestID, GroupID, null);
if (record == null)
{
return false;
}
//is the group open enrollment?
if (record.OpenEnrollment && RoleID == EVERYONE_ROLEID)
{
return true;
}
//has the agent been invited?
if (this.AgentHasBeenInvitedToGroup(AgentID, GroupID, RoleID))
{
return true;
}
//no way, agent can't join
return false;
}
public OpenSim.Framework.GroupMembershipData GetAgentGroupMembership(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID)
{
//TODO? Refactor? This is very similar to another method, just different params and queries
using (ISimpleDB db = GetConnection())
{
if (db == null)
return null;
string query
= " SELECT osgroup.GroupID, osgroup.Name as GroupName, osgroup.Charter, osgroup.InsigniaID, " +
"osgroup.FounderID, osgroup.MembershipFee, osgroup.OpenEnrollment, osgroup.ShowInList, " +
"osgroup.AllowPublish, osgroup.MaturePublish, osgroupmembership.Contribution, " +
"osgroupmembership.ListInProfile, osgroupmembership.AcceptNotices, " +
"osgroupmembership.SelectedRoleID, osrole.Title" +
" FROM osgroup JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID)" +
" JOIN osrole ON (osgroupmembership.SelectedRoleID = osrole.RoleID AND osgroupmembership.GroupID = osrole.GroupID)" +
" WHERE osgroup.GroupID = ?groupID AND osgroupmembership.AgentID = ?agentID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
parms.Add("?agentID", AgentID);
List<Dictionary<string, string>> groupResults = db.QueryWithResults(query, parms);
if (groupResults.Count == 0)
{
// no groups, etc?
return null;
}
Dictionary<string, string> powersResult = FindGroupPowersForAgent(db, GroupID, AgentID);
OpenSim.Framework.GroupMembershipData foundMembership
= this.MapGroupMembershipDataFromResult(groupResults[0], powersResult);
return foundMembership;
}
}
public void UpdateGroupRole(GroupRequestID requestID, OpenMetaverse.UUID groupID, OpenMetaverse.UUID roleID,
string name, string description, string title, ulong powers)
{
if (!TestForPower(requestID, requestID.AgentID, groupID, (ulong)GroupPowers.RoleProperties))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to change group roles", requestID.AgentID);
return;
}
string query = "UPDATE osrole SET RoleID = ?roleID ";
Dictionary<string, object> parms = new Dictionary<string,object>();
if (name != null)
{
query += ", Name = ?name ";
parms.Add("?name", name);
}
if (description != null)
{
query += ", Description = ?description ";
parms.Add("?description", description);
}
if (title != null)
{
query += ", Title = ?title ";
parms.Add("?title", title);
}
query += ", Powers = ?powers ";
parms.Add("?powers", powers);
query += " WHERE GroupID = ?groupID AND RoleID = ?roleID";
parms.Add("?groupID", groupID);
parms.Add("?roleID", roleID);
using (ISimpleDB db = GetConnection())
{
if (db != null)
db.QueryNoResults(query, parms);
}
}
public void SetAgentActiveGroupRole(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID, OpenMetaverse.UUID RoleID)
{
//make sure the agent actually has the role they want to activate
List<GroupRolesData> roles = GetAgentGroupRoles(requestID, AgentID, GroupID);
bool foundRole = false;
foreach (GroupRolesData role in roles)
{
if (role.RoleID == RoleID)
{
foundRole = true;
}
}
if (!foundRole)
{
//they are not in the role they selected
return;
}
string query =
"UPDATE osgroupmembership " +
"SET SelectedRoleID = ?roleID " +
"WHERE osgroupmembership.GroupID = ?groupID " +
"AND osgroupmembership.AgentID = ?agentID ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?roleID", RoleID);
parms.Add("?groupID", GroupID);
parms.Add("?agentID", AgentID);
using (ISimpleDB db = GetConnection())
{
if (db != null)
db.QueryNoResults(query, parms);
}
}
public void AddGroupRole(GroupRequestID requestID, OpenMetaverse.UUID groupID, OpenMetaverse.UUID roleID, string name,
string description, string title, ulong powers, bool skipPermissionTests)
{
if (!skipPermissionTests)
{
if (!TestForPower(requestID, requestID.AgentID, groupID, (ulong)GroupPowers.CreateRole))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to add group roles", requestID.AgentID);
return;
}
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return;
string query
= "INSERT INTO osrole (GroupID, RoleID, Name, Description, Title, Powers) " +
"VALUES(?groupID, ?roleID, ?name, ?desc, ?title, ?powers)";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", groupID);
parms.Add("?roleID", roleID);
parms.Add("?name", name);
parms.Add("?desc", description);
parms.Add("?title", title);
parms.Add("?powers", powers);
db.QueryNoResults(query, parms);
}
}
public OpenSim.Framework.GroupMembershipData GetAgentActiveMembership(GroupRequestID requestID, OpenMetaverse.UUID AgentID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return null;
string query
= " SELECT osgroup.GroupID, osgroup.Name as GroupName, osgroup.Charter, osgroup.InsigniaID, " +
"osgroup.FounderID, osgroup.MembershipFee, osgroup.OpenEnrollment, osgroup.ShowInList, " +
"osgroup.AllowPublish, osgroup.MaturePublish, osgroupmembership.Contribution, " +
"osgroupmembership.ListInProfile, osgroupmembership.AcceptNotices, osgroupmembership.SelectedRoleID, osrole.Title" +
" , osagent.ActiveGroupID " +
" FROM osagent JOIN osgroup ON (osgroup.GroupID = osagent.ActiveGroupID)" +
" JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID AND osagent.AgentID = osgroupmembership.AgentID)" +
" JOIN osrole ON (osgroupmembership.SelectedRoleID = osrole.RoleID AND osgroupmembership.GroupID = osrole.GroupID)" +
" WHERE osagent.AgentID = ?agentID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?agentID", AgentID);
List<Dictionary<string, string>> groupResults = db.QueryWithResults(query, parms);
if (groupResults.Count == 0)
{
//no active group? no groups, etc
return null;
}
UUID groupID = new UUID(groupResults[0]["GroupID"]);
Dictionary<string, string> powersResult = FindGroupPowersForAgent(db, groupID, AgentID);
OpenSim.Framework.GroupMembershipData foundMembership
= this.MapGroupMembershipDataFromResult(groupResults[0], powersResult);
return foundMembership;
}
}
public List<OpenSim.Framework.GroupMembersData> GetGroupMembers(GroupRequestID requestID, OpenMetaverse.UUID GroupID, bool ownersOnly)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return new List<OpenSim.Framework.GroupMembersData>();
string query = " SELECT osgroupmembership.AgentID" +
" , osgroupmembership.Contribution, osgroupmembership.ListInProfile, osgroupmembership.AcceptNotices" +
" , osgroupmembership.SelectedRoleID, osrole.Title" +
" , CASE WHEN OwnerRoleMembership.AgentID IS NOT NULL THEN 1 ELSE 0 END AS IsOwner " +
" , agents.agentOnline AS OnlineStatus, agents.logoutTime as LastLogout " +
" FROM osgroup JOIN osgroupmembership ON (osgroup.GroupID = osgroupmembership.GroupID)" +
" JOIN osrole ON (osgroupmembership.SelectedRoleID = osrole.RoleID AND osgroupmembership.GroupID = osrole.GroupID)" +
" JOIN osrole AS OwnerRole ON (osgroup.OwnerRoleID = OwnerRole.RoleID AND osgroup.GroupID = OwnerRole.GroupID)" +
" LEFT JOIN osgrouprolemembership AS OwnerRoleMembership ON (osgroup.OwnerRoleID = OwnerRoleMembership.RoleID " +
" AND (osgroup.GroupID = OwnerRoleMembership.GroupID) " +
" AND (osgroupmembership.AgentID = OwnerRoleMembership.AgentID))" +
" INNER JOIN agents ON agents.uuid = osgroupmembership.AgentID " +
" WHERE osgroup.GroupID = ?groupID ";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?groupID", GroupID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
//map the group member data first into a dict so that it'll be easy to search to fill
//the agent powers
Dictionary<string, OpenSim.Framework.GroupMembersData> memberData = new Dictionary<string, OpenSim.Framework.GroupMembersData>();
foreach (Dictionary<string, string> result in results)
{
GroupMembersData member = this.MapGroupMemberFromResult(result);
if (member.IsOwner || !ownersOnly)
memberData.Add(result["AgentID"], member);
}
//now, assign the agent powers returned
query = " SELECT BIT_OR(osrole.Powers) AS AgentPowers, osgrouprolemembership.AgentID " +
" FROM osgrouprolemembership " +
"JOIN osrole ON (osgrouprolemembership.GroupID = osrole.GroupID AND osgrouprolemembership.RoleID = osrole.RoleID) " +
" WHERE osgrouprolemembership.GroupID = ?groupID " +
" GROUP BY osgrouprolemembership.AgentID ";
results = db.QueryWithResults(query, parms);
foreach (Dictionary<string, string> result in results)
{
if (memberData.ContainsKey(result["AgentID"]))
{
OpenSim.Framework.GroupMembersData currMemberData = memberData[result["AgentID"]];
currMemberData.AgentPowers = ulong.Parse(result["AgentPowers"]);
memberData[result["AgentID"]] = currMemberData;
}
}
return new List<OpenSim.Framework.GroupMembersData>(memberData.Values);
}
}
public GroupInviteInfo GetAgentToGroupInvite(GroupRequestID requestID, OpenMetaverse.UUID inviteID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return null;
string query = " SELECT GroupID, RoleID, InviteID, AgentID FROM osgroupinvite" +
" WHERE osgroupinvite.InviteID = ?inviteID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?inviteID", inviteID);
List<Dictionary<string, string>> results = db.QueryWithResults(query, parms);
if (results.Count == 1)
{
return this.MapGroupInviteInfoFromResult(results[0]);
}
else
{
return null;
}
}
}
public bool AddAgentToGroup(GroupRequestID requestID, OpenMetaverse.UUID AgentID, OpenMetaverse.UUID GroupID,
OpenMetaverse.UUID RoleID, bool skipPermissionTests)
{
if (GroupID == UUID.Zero)
return false; // not a valid group
if (!skipPermissionTests)
{
if (!AgentCanJoinGroup(requestID, AgentID, GroupID, RoleID))
{
m_log.WarnFormat("[GROUPS]: {0} No permission to join group {1}", AgentID, GroupID);
return false;
}
}
using (ISimpleDB db = GetConnection())
{
if (db == null)
return false;
uint numGroups = GetAgentGroupCount(AgentID);
if (numGroups >= Constants.MaxGroups)
{
m_log.WarnFormat("[GROUPS]: {0} Already in {1} groups, cannot join group {2}", AgentID, numGroups, GroupID);
return false;
}
if (!IsAgentMemberOfGroup(db, AgentID, GroupID))
{
this.DoInsertGroupMembership(db, AgentID, GroupID, RoleID);
}
//add to everyone role
this.AddAgentToGroupRole(requestID, requestID.AgentID, AgentID, GroupID, EVERYONE_ROLEID, true);
if (RoleID != EVERYONE_ROLEID)
{
//specified role
this.AddAgentToGroupRole(requestID, requestID.AgentID, AgentID, GroupID, RoleID, true);
}
}
return true;
}
private Hashtable XmlRpcCall(GroupRequestID requestID, string function, Hashtable param)
{
if (requestID == null)
{
requestID = new GroupRequestID();
}
param.Add("RequestingAgentID", requestID.AgentID.ToString());
param.Add("RequestingAgentUserService", requestID.UserServiceURL);
param.Add("RequestingSessionID", requestID.SessionID.ToString());
param.Add("ReadKey", m_groupReadKey);
param.Add("WriteKey", m_groupWriteKey);
IList parameters = new ArrayList();
parameters.Add(param);
XmlRpcResponse resp = null;
try
{
XmlRpcRequest req;
/*
* if (!m_disableKeepAlive)
* req = new XmlRpcRequest(function, parameters);
* else
* // This seems to solve a major problem on some windows servers
* req = new NoKeepAliveXmlRpcRequest(function, parameters);
*/
req = new XmlRpcRequest(function, parameters);
resp = req.Send(Util.XmlRpcRequestURI(m_serviceURL, function), 10000);
}
catch (Exception e)
{
m_log.ErrorFormat("[XMLRPCGROUPDATA]: An error has occured while attempting to access the XmlRpcGroups server method: {0}", function);
m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0} ", e.ToString());
foreach (string key in param.Keys)
{
m_log.WarnFormat("[XMLRPCGROUPDATA]: {0} :: {1}", key, param[key].ToString());
}
Hashtable respData = new Hashtable();
respData.Add("error", e.ToString());
return(respData);
}
if (resp.Value is Hashtable)
{
Hashtable respData = (Hashtable)resp.Value;
if (respData.Contains("error") && !respData.Contains("succeed"))
{
LogRespDataToConsoleError(respData);
}
return(respData);
}
m_log.ErrorFormat("[XMLRPCGROUPDATA]: The XmlRpc server returned a {1} instead of a hashtable for {0}", function, resp.Value.GetType().ToString());
if (resp.Value is ArrayList)
{
ArrayList al = (ArrayList)resp.Value;
m_log.ErrorFormat("[XMLRPCGROUPDATA]: Contains {0} elements", al.Count);
foreach (object o in al)
{
m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0} :: {1}", o.GetType().ToString(), o.ToString());
}
}
else
{
m_log.ErrorFormat("[XMLRPCGROUPDATA]: Function returned: {0}", resp.Value.ToString());
}
Hashtable error = new Hashtable();
error.Add("error", "invalid return value");
return(error);
}
public void RemoveAgentToGroupInvite(GroupRequestID requestID, OpenMetaverse.UUID inviteID)
{
using (ISimpleDB db = GetConnection())
{
if (db == null)
return;
string query = " DELETE FROM osgroupinvite " +
" WHERE osgroupinvite.InviteID = ?inviteID";
Dictionary<string, object> parms = new Dictionary<string, object>();
parms.Add("?inviteID", inviteID);
db.QueryNoResults(query, parms);
}
}
