GroupMember IGroupMembersInterface.Add(UGUI requestingAgent, UGI group, UGUI principal, UUID roleID, string accessToken)
{
MemoryGroupInfo info;
MemoryGroupMember mem;
if (m_Groups.TryGetValue(group.ID, out info))
{
mem = new MemoryGroupMember
{
Group = info.ID,
Principal = principal,
SelectedRoleID = roleID,
Contribution = 0,
IsListInProfile = true,
IsAcceptNotices = true,
AccessToken = accessToken
};
info.Members.Add(principal, mem);
return(new GroupMember(mem));
}
else
{
throw new KeyNotFoundException();
}
}
UUID IGroupSelectInterface.this[UGUI requestingAgent, UGI group, UGUI principal]
{
get
{
UUID id;
if (!ActiveGroup.TryGetValue(requestingAgent, group, principal, out id))
{
throw new KeyNotFoundException();
}
return(id);
}
set
{
MemoryGroupInfo info;
MemoryGroupMember mem;
if (m_Groups.TryGetValue(group.ID, out info) && info.Members.TryGetValue(principal, out mem))
{
mem.ActiveRoleID = value;
}
else
{
throw new KeyNotFoundException();
}
}
}
List <GroupInvite> IGroupInvitesInterface.this[UGUI requestingAgent, UGI group, UUID roleID, UGUI principal]
{
get
{
using (var conn = new SqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new SqlCommand("SELECT * from groupinvites WHERE PrincipalID = @principalid AND GroupID = @groupid AND RoleID = @roleid", conn))
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.Parameters.AddParameter("@groupid", group.ID);
using (SqlDataReader reader = cmd.ExecuteReader())
{
var invites = new List <GroupInvite>();
while (reader.Read())
{
GroupInvite invite = reader.ToGroupInvite();
invite.Principal = ResolveName(invite.Principal);
invite.Group = ResolveName(requestingAgent, invite.Group);
invites.Add(invite);
}
return(invites);
}
}
}
}
}
bool IGroupMembershipsInterface.TryGetValue(UGUI requestingAgent, UGI group, UGUI principal, out GroupMembership gmem)
{
gmem = null;
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new NpgsqlCommand(
"SELECT g.*, m.\"PrincipalID\", m.\"SelectedRoleID\" AS ActiveRoleID, m.\"Contribution\", m.\"ListInProfile\", m.\"AcceptNotices\", m.\"AccessToken\", " +
"r.\"RoleID\", r.\"Name\" AS RoleName, r.\"Description\" AS RoleDescription, r.\"Title\" as RoleTitle, r.\"Powers\" as RolePowers, " +
RCountQuery + "," + MCountQuery + " FROM (groupmemberships AS m INNER JOIN groups AS g ON m.\"GroupID\" = g.\"GroupID\") " +
"INNER JOIN grouproles AS r ON m.\"SelectedRoleID\" = r.\"RoleID\" " +
"WHERE m.\"PrincipalID\" = @principalid LIMIT 1", conn))
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (NpgsqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
gmem = MembershipFromReader(reader, requestingAgent);
return(true);
}
}
}
}
return(false);
}
GroupMember IGroupMembersInterface.Add(UGUI requestingAgent, UGI group, UGUI principal, UUID roleID, string accessToken)
{
var vals = new Dictionary <string, object>
{
["GroupID"] = group.ID,
["PrincipalID"] = principal.ID,
["SelectedRoleID"] = roleID,
["AccessToken"] = accessToken
};
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
conn.InsertInto("groupmemberships", vals);
}
return(new GroupMember
{
Principal = principal,
Group = group,
IsAcceptNotices = true,
IsListInProfile = true,
AccessToken = accessToken,
SelectedRoleID = roleID
});
}
void IGroupRolemembersInterface.Delete(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal)
{
bool isUnlimited = false;
if (!IsGroupOwner(group, requestingAgent))
{
try
{
VerifyAgentPowers(group, requestingAgent, GroupPowers.AssignMember);
isUnlimited = true;
}
catch (GroupInsufficientPowersException)
{
VerifyAgentPowers(group, requestingAgent, GroupPowers.AssignMemberLimited);
}
}
else
{
isUnlimited = true;
}
if (!isUnlimited && !Rolemembers.ContainsKey(requestingAgent, group, roleID, requestingAgent))
{
throw new GroupInsufficientPowersException(GroupPowers.AssignMemberLimited);
}
m_InnerService.Rolemembers.Delete(requestingAgent, group, roleID, principal);
}
List <GroupRole> IGroupRolesInterface.this[UGUI requestingAgent, UGI group]
{
get
{
var roles = new List <GroupRole>();
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT r.*," + RCountQuery + " FROM grouproles AS r WHERE r.GroupID = @groupid", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
GroupRole role = reader.ToGroupRole();
role.Group = ResolveName(requestingAgent, role.Group);
roles.Add(role);
}
}
}
}
return(roles);
}
}
void IGroupRolemembersInterface.Delete(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal)
{
if (!m_Groups[group.ID].Roles[roleID].Rolemembers.Remove(principal))
{
throw new KeyNotFoundException();
}
}
bool IGroupRolemembersInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal, out GroupRolemember grolemem)
{
MemoryGroupInfo info;
MemoryGroupRole role;
grolemem = null;
if (roleID != UUID.Zero)
{
if (m_Groups.TryGetValue(group.ID, out info) && info.Roles.TryGetValue(roleID, out role) && role.Rolemembers.ContainsKey(principal))
{
grolemem = new GroupRolemember
{
Group = info.ID,
Powers = role.Powers,
Principal = principal,
RoleID = roleID
};
}
}
else
{
if (m_Groups.TryGetValue(group.ID, out info) && info.Roles.TryGetValue(roleID, out role) && info.Members.ContainsKey(principal))
{
grolemem = new GroupRolemember
{
Group = info.ID,
Powers = role.Powers,
Principal = principal,
RoleID = roleID
};
}
}
return(grolemem != null);
}
void IGroupsInterface.Delete(UUI requestingAgent, UGI group)
{
var tablenames = new string[] { "grouproles", "grouprolememberships", "groupnotices", "groupmemberships", "groupinvites", "groups" };
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
conn.InsideTransaction((transaction) =>
{
using (var cmd = new MySqlCommand("DELETE FROM activegroup WHERE ActiveGroupID = @groupid", conn)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.ExecuteNonQuery();
}
foreach (string table in tablenames)
{
using (var cmd = new MySqlCommand("DELETE FROM " + table + " WHERE GroupID = @groupid", conn)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.ExecuteNonQuery();
}
}
});
}
}
bool IGroupsInterface.TryGetValue(UGUI requestingAgent, UUID groupID, out UGI ugi)
{
ugi = default(UGI);
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new NpgsqlCommand("SELECT \"Name\", \"Location\" FROM groups WHERE \"GroupID\" = @groupid LIMIT 1", conn))
{
cmd.Parameters.AddParameter("@groupid", groupID);
using (NpgsqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
ugi = new UGI
{
ID = groupID
};
string uri = (string)reader["Location"];
if (!string.IsNullOrEmpty(uri))
{
ugi.HomeURI = new Uri(uri, UriKind.Absolute);
}
ugi.GroupName = (string)reader["Name"];
return(true);
}
}
}
}
return(false);
}
List <GroupRole> IGroupRolesInterface.this[UGUI requestingAgent, UGI group, UGUI principal]
{
get
{
var roles = new List <GroupRole>();
using (var conn = new SqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new SqlCommand("SELECT r.*," + RCountQuery + " FROM grouprolememberships AS rm INNER JOIN grouproles AS r ON rm.GroupID AND r.GroupID AND rm.RoleID = r.RoleID WHERE r.GroupID = @groupid AND rm.PrincipalID = @principalid", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
GroupRole role = reader.ToGroupRole();
role.Group = ResolveName(requestingAgent, role.Group);
roles.Add(role);
}
}
}
}
return(roles);
}
}
List <UGI> IEstateGroupsServiceListAccessInterface.this[uint estateID]
{
get
{
var estategroups = new List <UGI>();
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT GroupID FROM estate_groups WHERE EstateID = @estateid", conn))
{
cmd.Parameters.AddParameter("@estateid", estateID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var ugi = new UGI()
{
ID = reader.GetUUID("GroupID")
};
estategroups.Add(ugi);
}
}
}
}
return(estategroups);
}
}
/* get/set active role id */
UUID IGroupSelectInterface.this[UGUI requestingAgent, UGI group, UGUI principal]
{
get
{
UUID id;
if (!ActiveGroup.TryGetValue(requestingAgent, group, principal, out id))
{
id = UUID.Zero;
}
return(id);
}
set
{
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new NpgsqlCommand("UPDATE groupmemberships SET \"SelectedRoleID\"=@roleid WHERE \"PrincipalID\" = @principalid AND \"GroupID\" = @groupid", conn))
{
cmd.Parameters.AddParameter("@roleid", value);
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@principalid", principal.ID);
cmd.ExecuteNonQuery();
}
}
}
}
bool IGroupRolemembersInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal, out GroupRolemember grolemem)
{
grolemem = default(GroupRolemember);
GroupsBrokerEntry groupsService;
return(TryGetGroupsService(group, out groupsService) && groupsService.Rolemembers.TryGetValue(requestingAgent, group, roleID, principal, out grolemem));
}
bool IGroupRolesInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, out GroupRole groupRole)
{
groupRole = default(GroupRole);
GroupsBrokerEntry groupsService;
return(TryGetGroupsService(group, out groupsService) && groupsService.Roles.TryGetValue(requestingAgent, group, roleID, out groupRole));
}
List <GroupMember> IGroupMembersInterface.this[UGUI requestingAgent, UGI group]
{
get
{
var members = new List <GroupMember>();
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new NpgsqlCommand("SELECT m.* FROM groupmemberships AS m WHERE m.\"GroupID\" = @groupid", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
using (NpgsqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
GroupMember gmem = reader.ToGroupMember();
gmem.Group = ResolveName(requestingAgent, gmem.Group);
gmem.Principal = ResolveName(gmem.Principal);
members.Add(gmem);
}
}
}
}
return(members);
}
}
bool IGroupMembershipsInterface.TryGetValue(UUI requestingAgent, UGI group, UUI principal, out GroupMembership gmem)
{
gmem = null;
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand(
"SELECT g.*, m.PrincipalID, m.SelectedRoleID AS ActiveRoleID, m.Contribution, m.ListInProfile, m.AcceptNotices, m.AccessToken, " +
"r.RoleID, r.Name AS RoleName, r.Description AS RoleDescription, r.Title as RoleTitle, r.Powers as RolePowers, " +
RCountQuery + "," + MCountQuery + " FROM (groupmemberships AS m INNER JOIN groups AS g ON m.GroupID = g.GroupID) " +
"INNER JOIN grouproles AS r ON m.SelectedRoleID = r.RoleID " +
"WHERE m.PrincipalID = @principalid", conn))
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
gmem = MembershipFromReader(reader, requestingAgent);
return(true);
}
}
}
}
return(false);
}
bool IGroupsInterface.TryGetValue(UGUI requestingAgent, UGI groupID, out GroupInfo groupInfo)
{
GroupsBrokerEntry groupsService;
groupInfo = default(GroupInfo);
return(TryGetGroupsService(groupID, out groupsService) && groupsService.Groups.TryGetValue(requestingAgent, groupID, out groupInfo));
}
bool IGroupsInterface.TryGetValue(UGUI requestingAgent, UUID groupID, out UGI ugi)
{
GroupsServiceInterface groupsService;
ugi = default(UGI);
return(TryGetGroupsService(groupID, out groupsService) && groupsService.Groups.TryGetValue(requestingAgent, groupID, out ugi));
}
public GroupRolemember(GroupRolemember src)
{
Group = new UGI(src.Group);
RoleID = src.RoleID;
Principal = new UGUI(src.Principal);
Powers = src.Powers;
}
private bool IsGroupMember(UGUI agentOwner, UGI group)
{
if (GroupsService == null || group.ID == UUID.Zero)
{
return(false);
}
GroupMember member;
try
{
member = GroupsService.Members[agentOwner, group, agentOwner];
}
catch
{
return(false);
}
/* care more for permissions by checking grid equality */
if (!member.Principal.EqualsGrid(agentOwner))
{
return(false);
}
return(true);
}
void IGroupRolesInterface.Delete(UGUI requestingAgent, UGI group, UUID roleID)
{
var tablenames = new string[] { "groupinvites", "grouprolememberships", "grouproles" };
using (var conn = new SqlConnection(m_ConnectionString))
{
conn.Open();
conn.InsideTransaction((transaction) =>
{
using (var cmd = new SqlCommand("UPDATE groupmemberships SET SelectedRoleID=@zeroid WHERE SelectedRoleID = @roleid", conn))
{
cmd.Transaction = transaction;
cmd.Parameters.AddParameter("@zeroid", UUID.Zero);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.ExecuteNonQuery();
}
foreach (string table in tablenames)
{
using (var cmd = new SqlCommand("DELETE FROM " + table + " WHERE GroupID = @groupid AND RoleID = @roleid", conn))
{
cmd.Transaction = transaction;
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.ExecuteNonQuery();
}
}
});
}
}
public override GroupPowers GetAgentPowers(UGI group, UGUI agent)
{
if (!Members.ContainsKey(agent, group, agent))
{
return(GroupPowers.None);
}
GroupPowers powers;
if (!TryGetGroupRoleRights(agent, group, UUID.Zero, out powers))
{
return(GroupPowers.None);
}
using (var conn = new NpgsqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new NpgsqlCommand(
"SELECT Powers FROM roles AS r INNER JOIN " +
"((grouprolemembers AS rm INNER JOIN groupmembers AS m ON rm.\"GroupID\" = m.\"GroupID\" AND rm.\"PrincipalID\" = m.\"PrincipalID\") ON " +
"r.\"RoleID\" = rm.\"RoleID\" WHERE rm.\"GroupID\" = @groupid AND rm.\"PrincipalID\" = @principalid", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@principalid", agent.ID);
using (NpgsqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
powers |= reader.GetEnum <GroupPowers>("Powers");
}
}
}
}
return(powers);
}
bool IGroupMembershipsInterface.TryGetValue(UGUI requestingAgent, UGI group, UGUI principal, out GroupMembership gmem)
{
gmem = default(GroupMembership);
GroupsBrokerEntry groupsService;
return(TryGetGroupsService(group, out groupsService) && groupsService.Memberships.TryGetValue(requestingAgent, group, principal, out gmem));
}
bool IGroupsInterface.TryGetValue(UUI requestingAgent, UUID groupID, out UGI ugi)
{
ugi = default(UGI);
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT `Name`, Location FROM groups WHERE GroupID = @groupid", conn))
{
cmd.Parameters.AddParameter("@groupid", groupID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
ugi = new UGI()
{
ID = groupID
};
string uri = reader.GetString("Location");
if (!string.IsNullOrEmpty(uri))
{
ugi.HomeURI = new Uri(uri, UriKind.Absolute);
}
ugi.GroupName = reader.GetString("Name");
return(true);
}
}
}
}
return(false);
}
public GroupMember AddAgentToGroup(UGUI requestingAgent, UGI group, UUID roleid, UGUI agent, string accessToken)
{
bool alreadyInGroup;
GroupMember gmem;
alreadyInGroup = Members.TryGetValue(requestingAgent, group, agent, out gmem);
if (!alreadyInGroup)
{
gmem = Members.Add(requestingAgent, group, agent, roleid, accessToken);
}
try
{
if (!Rolemembers.ContainsKey(requestingAgent, group, UUID.Zero, agent))
{
var rolemember = new GroupRolemember
{
Group = group,
Principal = agent,
RoleID = UUID.Zero
};
Rolemembers.Add(requestingAgent, rolemember);
}
if (UUID.Zero != roleid)
{
var rolemember = new GroupRolemember
{
Group = group,
Principal = agent,
RoleID = roleid
};
Rolemembers.Add(requestingAgent, rolemember);
}
try
{
var invites = Invites[requestingAgent, group, roleid, agent];
foreach (var invite in invites)
{
invites.Remove(invite);
}
}
catch
{
/* intentionally ignored */
}
}
catch
{
if (!alreadyInGroup)
{
Members.Delete(requestingAgent, group, agent);
}
}
return(gmem);
}
GroupMember IGroupMembersInterface.Add(UGUI requestingAgent, UGI group, UGUI principal, UUID roleID, string accessToken)
{
if (Invites[requestingAgent, group, roleID, principal].Count == 0)
{
VerifyAgentPowers(group, requestingAgent, GroupPowers.Invite);
}
return(m_InnerService.Members.Add(requestingAgent, group, principal, roleID, accessToken));
}
protected RezRestoreObjectHandler(SceneInterface scene, UUID assetid, AssetServiceInterface source, UGUI rezzingagent, UGI rezzinggroup, InventoryItem sourceItem)
: base(scene.AssetService, source, assetid, ReferenceSource.Destination)
{
m_Scene = scene;
m_RezzingAgent = rezzingagent;
m_RezzingGroup = rezzinggroup;
m_SourceItem = sourceItem;
}
void IGroupsInterface.Delete(UGUI requestingAgent, UGI group)
{
if (!IsGroupOwner(group, requestingAgent))
{
throw new GroupInsufficientPowersException(GroupPowers.OwnerPowers);
}
m_InnerService.Groups.Delete(requestingAgent, group);
}
