public uint Count(uint estateID, RegionFlags flags)
{
IEstateConnector estates = Aurora.DataManager.DataManager.RequestPlugin <IEstateConnector>();
if (estates == null)
{
return(0);
}
EstateSettings es = estates.GetEstateSettings((int)estateID);
QueryFilter filter = new QueryFilter();
filter.andBitfieldAndFilters["Flags"] = (uint)flags;
List <GridRegion> query = ParseQuery(null, GD.Query(new string[] { "*" }, m_realm, filter, null, null, null));
uint count = 0;
query.ForEach(delegate(GridRegion region)
{
if (region.EstateOwner == es.EstateOwner && estates.GetEstateID(region.RegionID) == es.EstateID)
{
++count;
}
});
return(count);
}
/// <summary>
/// Shows details of all estates.
/// </summary>
/// <param name="scene">Scene.</param>
/// <param name="cmd">Cmd.</param>
void ShowEstatesCommand(IScene scene, string [] cmd)
{
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService> ();
string estateInfo;
var estates = estateConnector.GetEstateNames();
// headings
estateInfo = string.Format("{0, -20}", "Estate");
estateInfo += string.Format("{0, -20}", "Owner");
estateInfo += string.Format("{0, -10}", "Regions");
estateInfo += string.Format("{0, -10}", "Voice");
estateInfo += string.Format("{0, -10}", "Price/M");
estateInfo += string.Format("{0, -10}", "Public");
estateInfo += string.Format("{0, -10}", "Tax Free");
estateInfo += string.Format("{0, -10}", "Direct Tp");
MainConsole.Instance.CleanInfo(estateInfo);
MainConsole.Instance.CleanInfo("--------------------------------------------------------------------------------------------------");
foreach (string estate in estates)
{
var estateID = estateConnector.GetEstateID(estate);
EstateSettings ES = estateConnector.GetEstateIDSettings(estateID);
if (ES != null)
{
//var regInfo = scene.RegionInfo;
UserAccount EstateOwner = accountService.GetUserAccount(null, ES.EstateOwner);
var regions = estateConnector.GetRegions(estateID);
// todo ... change hardcoded field sizes to public constants
estateInfo = string.Format("{0, -20}", ES.EstateName);
estateInfo += string.Format("{0, -20}", EstateOwner.Name);
estateInfo += string.Format("{0, -10}", regions.Count);
estateInfo += string.Format("{0, -10}", (ES.AllowVoice) ? "Yes" : "No");
estateInfo += string.Format("{0, -10}", ES.PricePerMeter);
estateInfo += string.Format("{0, -10}", (ES.PublicAccess) ? "Yes" : "No");
estateInfo += string.Format("{0, -10}", (ES.TaxFree) ? "Yes" : "No");
estateInfo += string.Format("{0, -10}", (ES.AllowDirectTeleport) ? "Yes" : "No");
MainConsole.Instance.CleanInfo(estateInfo);
}
}
MainConsole.Instance.CleanInfo("\n");
}
public List <GridRegion> Get(uint start, uint count, uint estateID, RegionFlags flags,
Dictionary <string, bool> sort)
{
List <GridRegion> resp = new List <GridRegion>();
IEstateConnector estates = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector>();
if (count == 0 || estates == null)
{
return(resp);
}
EstateSettings es = estates.GetEstateSettings((int)estateID);
QueryFilter filter = new QueryFilter();
filter.andBitfieldAndFilters["Flags"] = (uint)flags;
while (resp.Count < count)
{
uint limit = count - (uint)resp.Count;
List <GridRegion> query = ParseQuery(null,
GD.Query(new string[] { "*" }, m_realm, filter, sort, start, count));
if (query.Count == 0)
{
break;
}
query.ForEach(delegate(GridRegion region)
{
if (region.EstateOwner == es.EstateOwner &&
estates.GetEstateID(region.RegionID) == es.EstateID)
{
resp.Add(region);
}
});
start += limit;
}
return(resp);
}
private void FixMissingRegionOwners()
{
QueryFilter filter = new QueryFilter();
filter.andFilters["OwnerUUID"] = UUID.Zero;
List <GridRegion> borked = ParseQuery(null, GD.Query(new string[1] {
"*"
}, m_realm, filter, null, null, null));
if (borked.Count < 1)
{
MainConsole.Instance.Debug("[LocalGridConnector] No regions found with missing owners.");
}
IEstateConnector estatePlugin = Aurora.DataManager.DataManager.RequestPlugin <IEstateConnector>();
if (estatePlugin == null)
{
MainConsole.Instance.Error("[LocalGridConnector] " + borked.Count + " regions found with missing owners, but could not get IEstateConnector plugin.");
return;
}
else
{
MainConsole.Instance.Error("[LocalGridConnector] " + borked.Count + " regions found with missing owners, attempting fix.");
}
Dictionary <int, List <GridRegion> > borkedByEstate = new Dictionary <int, List <GridRegion> >();
foreach (GridRegion region in borked)
{
int estateID = estatePlugin.GetEstateID(region.RegionID);
if (!borkedByEstate.ContainsKey(estateID))
{
borkedByEstate[estateID] = new List <GridRegion>();
}
borkedByEstate[estateID].Add(region);
}
Dictionary <int, UUID> estateOwnerIDs = new Dictionary <int, UUID>();
uint estateFail = 0;
foreach (int estateID in borkedByEstate.Keys)
{
EstateSettings es = estatePlugin.GetEstateSettings(estateID);
if (es == null)
{
MainConsole.Instance.Error("[LocalGridConnector] Cannot fix missing owner for regions in Estate " + estateID + ", could not get estate settings.");
}
else if (es.EstateOwner == UUID.Zero)
{
MainConsole.Instance.Error("[LocalGridConnector] Cannot fix missing owner for regions in Estate " + estateID + ", Estate Owner is also missing.");
}
if (es == null || es.EstateOwner == UUID.Zero)
{
++estateFail;
continue;
}
estateOwnerIDs[estateID] = es.EstateOwner;
}
if (estateFail > 0)
{
if (estateFail == borkedByEstate.Count)
{
MainConsole.Instance.Error("[LocalGridConnector] " + borked.Count + " regions found with missing owners, could not locate any estate settings from IEstateConnector plugin.");
return;
}
else
{
MainConsole.Instance.Error("[LocalGridConnector] " + borked.Count + " regions found with missing owners, could not locate estate settings for " + estateFail + " estates.");
}
}
uint storeSuccess = 0;
uint storeFail = 0;
int borkedCount = borked.Count;
foreach (KeyValuePair <int, UUID> kvp in estateOwnerIDs)
{
List <GridRegion> regions = borkedByEstate[kvp.Key];
foreach (GridRegion region in regions)
{
region.EstateOwner = kvp.Value;
if (!Store(region))
{
MainConsole.Instance.Error("[LocalGridConnector] Failed to fix missing region for " + region.RegionName + " (" + region.RegionID + ")");
++storeFail;
}
else
{
++storeSuccess;
borked.Remove(region);
}
}
}
if (storeFail > 0)
{
MainConsole.Instance.Error("[LocalGridConnector] " + borkedCount + " regions found with missing owners, fix failed on " + storeFail + " regions, fix attempted on " + storeSuccess + " regions.");
}
else if (storeSuccess != borked.Count)
{
MainConsole.Instance.Error("[LocalGridConnector] " + borkedCount + " regions found with missing owners, fix attempted on " + storeSuccess + " regions.");
}
else
{
MainConsole.Instance.Info("[LocalGridConnector] All regions found with missing owners should have their owners restored.");
}
if (borked.Count > 0)
{
List <string> blurbs = new List <string>(borked.Count);
foreach (GridRegion region in borked)
{
blurbs.Add(region.RegionName + " (" + region.RegionID + ")");
}
MainConsole.Instance.Info("[LocalGridConnector] Failed to fix missing region owners for regions " + string.Join(", ", blurbs.ToArray()));
}
}
/// <summary>
/// Changes the region estate.
/// </summary>
/// <param name="scene">Scene.</param>
/// <param name="cmd">Cmd parameters.</param>
protected void ChangeRegionEstate(IScene scene, string [] cmd)
{
var conScenes = MainConsole.Instance.ConsoleScenes;
IScene regScene = scene;
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
if (estateConnector == null)
{
MainConsole.Instance.Error("[Estate]: Unable to obtain estate connector for update");
return;
}
string regionName;
if (regScene == null)
{
regionName = cmd.Length > 2 ? cmd [2] : MainConsole.Instance.Prompt("The region you wish to change?");
if (string.IsNullOrEmpty(regionName))
{
return;
}
// find the required region/scene
regionName = regionName.ToLower();
foreach (IScene scn in conScenes)
{
if (scn.RegionInfo.RegionName.ToLower() == regionName)
{
regScene = scn;
break;
}
}
if (regScene == null)
{
MainConsole.Instance.Error("[Estate]: The region '" + regionName + "' could not be found.");
return;
}
}
else
{
regionName = regScene.RegionInfo.RegionName;
}
// check for mainland regions
if (regScene.RegionInfo.RegionType.ToLower().StartsWith("m", System.StringComparison.Ordinal))
{
var sysEstates = regScene.RequestModuleInterface <ISystemEstateService> ();
var mainlandEstate = sysEstates.MainlandEstateName;
MainConsole.Instance.InfoFormat("[Estate]: {0} is a Mainland region and is automatically part of the '{1}' estate",
regionName, mainlandEstate);
return;
}
var regionID = regScene.RegionInfo.RegionID;
var oldOwnerID = regScene.RegionInfo.EstateSettings.EstateOwner;
// get the new estate name
string estateName = cmd.Length > 3
? cmd [3]
: MainConsole.Instance.Prompt("The new estate for " + regionName + " (? for more options)");
if (string.IsNullOrEmpty(estateName))
{
return;
}
int newEstateId = 0;
if (estateName != "?")
{
newEstateId = estateConnector.GetEstateID(estateName);
}
if (newEstateId == 0)
{
if (estateName != "?")
{
MainConsole.Instance.Warn("[Estate]: The estate '" + estateName + "' matches no known estate.");
}
// try the long way...
newEstateId = GetUserEstateID(regScene, estateConnector);
if (newEstateId == 0)
{
return;
}
var estate = estateConnector.GetEstateIDSettings(newEstateId);
if (estate != null)
{
estateName = estate.EstateName;
}
}
// we have a region & estate name
bool deLinkEstate = true;
if (cmd.Length == 3)
{
var resp = MainConsole.Instance.Prompt(
"Are you sure you want to change '" + regionName + "' to the '" + estateName + "' estate? (yes/no)", "yes");
deLinkEstate = (resp.StartsWith("y", System.StringComparison.Ordinal));
}
if (!deLinkEstate)
{
return;
}
// good to go
if (!estateConnector.DelinkRegion(regionID))
{
MainConsole.Instance.Warn("[Estate]: Aborting - Unable to remove this region from the current estate.");
return;
}
// check for'Mainland'
string regType = regScene.RegionInfo.RegionType.ToLower();
if (regType.StartsWith("m", System.StringComparison.Ordinal))
{
if (newEstateId == Constants.MainlandEstateID)
{
MainConsole.Instance.Info("[Estate]: This region is already part of the Mainland estate");
return;
}
// link this region to the mainland
MainConsole.Instance.Info("[Estate]: Mainland type regions must be part of the Mainland estate");
LinkSystemEstate(regionID, Constants.MainlandEstateID);
return;
}
var newEstate = LinkRegionEstate(regionID, newEstateId);
if (newEstate != null)
{
regScene.RegionInfo.EstateSettings = newEstate;
// Linking was successful, change any previously owned parcels to the new owner
if (oldOwnerID != UUID.Zero)
{
IParcelManagementModule parcelManagement = regScene.RequestModuleInterface <IParcelManagementModule> ();
if (parcelManagement != null)
{
parcelManagement.ReclaimParcels(oldOwnerID, newEstate.EstateOwner);
}
}
}
}
