public bool HasGroupPower(UGUI agentOwner, UGI group, GroupPowers power) => (GetGroupPowers(agentOwner, group) & power) != 0;
/* check access when doing QueryAccess * These checks are informational only to the arriving agent and * cannot be granted to be validating correctly at all times. */ /* throws NotAuthorizedException when not allowed */ public abstract void QueryAccess(UGUI agent, UUID regionID);
bool IGroupRolemembersInterface.ContainsKey(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal)
{
if (UUID.Zero == roleID)
{
return(Members.ContainsKey(requestingAgent, group, principal));
}
else
{
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT rm.GroupID FROM grouprolememberships AS rm INNER JOIN grouproles AS r ON rm.GroupID = r.GroupID AND rm.RoleID = r.RoleID WHERE rm.GroupID = @groupid AND rm.RoleID = @roleid and rm.PrincipalID = @principalid LIMIT 1", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
return(reader.Read());
}
}
}
}
}
bool IGroupRolesInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, out GroupRole groupRole) => m_InnerService.Roles.TryGetValue(requestingAgent, group, roleID, out groupRole);
List <GroupRole> IGroupRolesInterface.this[UGUI requestingAgent, UGI group, UGUI principal] => m_InnerService.Roles[requestingAgent, group, principal];
public abstract void Logout(UGUI agentID, UUID sessionID, UUID secureSessionID);
/** <summary> Start a transaction for paying another user by a user</summary> * <exception cref="InsufficientFundsException">this exception is thrown when not enough funds are available</exception> */ public abstract IActiveTransaction BeginTransferTransaction(UGUI sourceID, UGUI destinationID, BaseTransaction transactionData, int amount);
List <GroupRolemembership> IGroupRolemembersInterface.this[UGUI requestingAgent, UGUI principal] => m_InnerService.Rolemembers[requestingAgent, principal];
List <GroupRolemember> IGroupRolemembersInterface.this[UGUI requestingAgent, UGI group] => m_InnerService.Rolemembers[requestingAgent, group];
bool IGroupRolemembersInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal, out GroupRolemember grolemem) => m_InnerService.Rolemembers.TryGetValue(requestingAgent, group, roleID, principal, out grolemem);
bool IGroupRolemembersInterface.ContainsKey(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal) => m_InnerService.Rolemembers.ContainsKey(requestingAgent, group, roleID, principal);
List <GroupRolemembership> IGroupRolemembersInterface.this[UGUI requestingAgent, UGUI principal]
{
get
{
var rolemembers = new List <GroupRolemembership>();
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT rm.*, r.Powers, r.Title FROM grouprolememberships AS rm INNER JOIN grouproles AS r ON rm.GroupID = r.GroupID AND rm.RoleID = r.RoleID WHERE rm.PrincipalID = @principalid", conn))
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
GroupRolemembership grolemem = reader.ToGroupRolemembership();
grolemem.Principal = ResolveName(grolemem.Principal);
grolemem.Group = ResolveName(requestingAgent, grolemem.Group);
rolemembers.Add(grolemem);
}
}
}
using (var cmd = new MySqlCommand("SELECT * FROM groupmemberships WHERE rm.PrincipalID = @principalid", conn))
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var group = new UGI(reader.GetUUID("GroupID"));
GroupRole groupRole;
if (Roles.TryGetValue(requestingAgent, group, UUID.Zero, out groupRole))
{
GroupRolemembership grolemem = reader.ToGroupRolemembershipEveryone(groupRole.Powers);
grolemem.Principal = ResolveName(grolemem.Principal);
grolemem.Group = ResolveName(requestingAgent, grolemem.Group);
grolemem.GroupTitle = groupRole.Title;
rolemembers.Add(grolemem);
}
}
}
}
}
return(rolemembers);
}
}
bool IGroupRolemembersInterface.TryGetValue(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal, out GroupRolemember grolemem)
{
grolemem = null;
if (UUID.Zero == roleID)
{
GroupMember gmem;
GroupRole role;
if (Members.TryGetValue(requestingAgent, group, principal, out gmem) &&
Roles.TryGetValue(requestingAgent, group, UUID.Zero, out role))
{
grolemem = new GroupRolemember
{
Powers = role.Powers,
Principal = ResolveName(principal),
RoleID = UUID.Zero,
Group = gmem.Group
};
return(true);
}
}
else
{
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
using (var cmd = new MySqlCommand("SELECT rm.*, r.Powers FROM grouprolememberships AS rm INNER JOIN grouproles AS r ON rm.GroupID = r.GroupID AND rm.RoleID = r.RoleID WHERE rm.GroupID = @groupid AND rm.RoleID = @roleid and rm.PrincipalID = @principalid LIMIT 1", conn))
{
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.Parameters.AddParameter("@principalid", principal.ID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
grolemem = reader.ToGroupRolemember();
grolemem.Principal = ResolveName(grolemem.Principal);
grolemem.Group = ResolveName(requestingAgent, grolemem.Group);
return(true);
}
}
}
}
}
return(false);
}
void IGroupRolemembersInterface.Delete(UGUI requestingAgent, UGI group, UUID roleID, UGUI principal)
{
if (UUID.Zero == roleID)
{
throw new NotSupportedException();
}
else
{
var tablenames = new string[] { "groupinvites", "grouprolememberships" };
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
conn.InsideTransaction((transaction) =>
{
using (var cmd = new MySqlCommand("UPDATE groupmemberships SET SelectedRoleID=@zeroid WHERE SelectedRoleID = @roleid AND GroupID = @groupid AND PrincipalID = @principalid", conn)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@zeroid", UUID.Zero);
cmd.Parameters.AddParameter("@principalid", principal.ID);
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.ExecuteNonQuery();
}
foreach (string table in tablenames)
{
using (var cmd = new MySqlCommand("DELETE FROM " + table + " WHERE GroupID = @groupid AND RoleID = @roleid AND PrincipalID = @principalid", conn)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@principalid", principal.ID);
cmd.Parameters.AddParameter("@groupid", group.ID);
cmd.Parameters.AddParameter("@roleid", roleID);
cmd.ExecuteNonQuery();
}
}
});
}
}
}
public abstract CurrencyQuote GetCurrencyQuote(UGUI sourceID, string language, int currencyToBuy);
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);
}
public abstract void BuyCurrency(UGUI sourceID, string language, CurrencyBuy quote);
public bool IsRegionOwner(UGUI agent) => agent.EqualsGrid(Owner);
/** <summary> Start a transaction for paying a grid service</summary> * <exception cref="InsufficientFundsException">this exception is thrown when not enough funds are available</exception> */ public abstract IActiveTransaction BeginChargeTransaction(UGUI agentID, BaseTransaction transactionData, int amount);
private bool IsInGodAgents(UGUI agent)
{
RwLockedList <UGUI> activeList = m_GodAgentsSetToLocal ? m_GodAgentsLocal : m_GodAgentsGlobal;
return(activeList.Find((e) => agent.EqualsGrid(e)) != null);
}
/** <summary> Start a transaction for paying a group by a user</summary>
* <exception cref="InsufficientFundsException">this exception is thrown when not enough funds are available</exception>
* <exception cref="NotSupportedException">this exception is thrown when the economy service does not support group accounts</exception>
*/
public virtual IActiveTransaction BeginTransferTransaction(UGUI sourceID, UGI destinationID, BaseTransaction transactionData, int amount)
{
throw new NotSupportedException();
}
public bool IsPossibleGod(UGUI agent) => agent.EqualsGrid(Owner) || (EstateManagerIsGod && IsEstateManager(agent)) || IsInGodAgents(agent);
bool IGroupRolesInterface.ContainsKey(UGUI requestingAgent, UGI group, UUID roleID) => m_InnerService.Roles.ContainsKey(requestingAgent, group, roleID);
public bool CanRez(UUID rezzerid, UGUI agent, Vector3 location) => CanRez(rezzerid, agent, location, UUID.Zero, UUID.Zero);
void IGroupRolesInterface.Add(UGUI requestingAgent, GroupRole role)
{
VerifyAgentPowers(role.Group, requestingAgent, GroupPowers.CreateRole);
m_InnerService.Roles.Add(requestingAgent, role);
}
public bool CanMove(IAgent agent, ObjectGroup group, Vector3 location)
{
UGUI agentOwner = agent.Owner;
UGUI groupOwner = group.Owner;
if (IsPossibleGod(agentOwner))
{
if (group.RootPart.IsLocked && groupOwner.EqualsGrid(agentOwner))
{
return(false);
}
return(true);
}
/* deny modification of admin objects by non-admins */
else if (IsPossibleGod(groupOwner))
{
return(false);
}
/* check locked state */
if (group.RootPart.IsLocked)
{
return(false);
}
/* check object owner */
if (agentOwner.EqualsGrid(groupOwner))
{
return(true);
}
else if (group.IsAttached)
{
/* others should not be able to edit attachments */
return(false);
}
#warning Add Friends Rights to CanMove
if (group.RootPart.CheckPermissions(agentOwner, agent.Group, InventoryPermissionsMask.Move))
{
return(true);
}
else if ((group.RootPart.EveryoneMask & InventoryPermissionsMask.Move) != 0)
{
return(true);
}
if (HasGroupPower(agent.Owner, group.Group, GroupPowers.ObjectManipulate))
{
return(true);
}
ParcelInfo pinfo;
if (Parcels.TryGetValue(location, out pinfo))
{
if (pinfo.Owner.EqualsGrid(agentOwner))
{
return(true);
}
if (HasGroupPower(agent.Owner, pinfo.Group, GroupPowers.ObjectManipulate))
{
return(true);
}
}
return(false);
}
public static void RaiseSphere(UGUI agentOwner, SceneInterface scene, ModifyLand modify, ModifyLand.Data data)
{
var changed = new List <LayerPatch>();
int xFrom = (int)(data.West - data.BrushSize + 0.5);
int xTo = (int)(data.West + data.BrushSize + 0.5);
int yFrom = (int)(data.South - data.BrushSize + 0.5);
int yTo = (int)(data.South + data.BrushSize + 0.5);
if (xFrom < 0)
{
xFrom = 0;
}
if (yFrom < 0)
{
yFrom = 0;
}
if (xTo >= scene.SizeX)
{
xTo = (int)scene.SizeX - 1;
}
if (yTo >= scene.SizeY)
{
yTo = (int)scene.SizeY - 1;
}
#if DEBUG
m_Log.DebugFormat("Terraforming {0},{1} RaiseSphere {2}-{3} / {4}-{5}", data.West, data.South, xFrom, xTo, yFrom, yTo);
#endif
for (int x = xFrom; x <= xTo; x++)
{
for (int y = yFrom; y <= yTo; y++)
{
var pos = new Vector3(x, y, 0);
if (!scene.CanTerraform(agentOwner, pos))
{
continue;
}
// Calculate a cos-sphere and add it to the heightmap
double r = Math.Sqrt((x - data.West) * (x - data.West) + ((y - data.South) * (y - data.South)));
double z = Math.Cos(r * Math.PI / (data.BrushSize * 2));
if (z > 0.0)
{
LayerPatch lp = scene.Terrain.AdjustTerrain((uint)x, (uint)y, z * modify.Seconds);
if (lp != null && !changed.Contains(lp))
{
changed.Add(lp);
}
}
}
}
if (changed.Count != 0)
{
foreach (LayerPatch lp in changed)
{
lp.IncrementSerial();
scene.Terrain.UpdateTerrainListeners(lp);
}
scene.Terrain.UpdateTerrainDataToClients();
}
}
public override GroupPowers GetAgentPowers(UGI group, UGUI agent) => m_InnerService.GetAgentPowers(group, agent);
