public uint Count(uint estateID, RegionFlags flags)
{
IEstateConnector estates = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
if (estates == null)
{
return(0);
}
EstateSettings es = estates.GetEstateIDSettings((int)estateID);
QueryFilter filter = new QueryFilter();
filter.andBitfieldAndFilters ["Flags"] = (uint)flags;
List <GridRegion> query = ParseQuery(null, m_GD.Query(new string [] { "*" }, m_realm, filter, null, null, null));
uint count = 0;
query.ForEach(delegate(GridRegion region) {
if (region.EstateOwner == es.EstateOwner &&
estates.GetRegionEstateID(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> GetList(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.GetEstateIDSettings((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, m_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.GetRegionEstateID(region.RegionID) == es.EstateID)
{
resp.Add(region);
}
});
start += limit;
}
return(resp);
}
/// <summary>
/// Checks for a valid system estate. Adds or corrects if required
/// </summary>
/// <param name="estateID">Estate I.</param>
/// <param name="estateName">Estate name.</param>
/// <param name="ownerUUID">Owner UUI.</param>
void CheckSystemEstateInfo(int estateID, string estateName, UUID ownerUUID)
{
// these should have already been checked but just make sure...
if (m_estateConnector == null)
{
return;
}
if (m_estateConnector.RemoteCalls())
{
return;
}
ISystemAccountService sysAccounts = m_registry.RequestModuleInterface <ISystemAccountService> ();
EstateSettings ES;
// check for existing estate name in case of estate ID change
ES = m_estateConnector.GetEstateSettings(estateName);
if (ES != null)
{
// ensure correct ID
if (ES.EstateID != estateID)
{
UpdateSystemEstates(m_estateConnector, ES, estateID);
}
}
ES = m_estateConnector.GetEstateIDSettings(estateID);
if ((ES != null) && (ES.EstateID != 0))
{
// ensure correct owner
if (ES.EstateOwner != ownerUUID)
{
ES.EstateOwner = ownerUUID;
m_estateConnector.SaveEstateSettings(ES);
MainConsole.Instance.Info("[EstateService]: The system Estate owner has been updated to " +
sysAccounts.GetSystemEstateOwnerName(estateID));
}
// in case of configuration changes
if (ES.EstateName != estateName)
{
ES.EstateName = estateName;
m_estateConnector.SaveEstateSettings(ES);
MainConsole.Instance.Info("[EstateService]: The system Estate name has been updated to " + estateName);
}
return;
}
// Create a new estate
ES = new EstateSettings();
ES.EstateName = estateName;
ES.EstateOwner = ownerUUID;
ES.EstateID = (uint)m_estateConnector.CreateNewEstate(ES);
if (ES.EstateID == 0)
{
MainConsole.Instance.Warn("There was an error in creating the system estate: " + ES.EstateName);
//EstateName holds the error. See LocalEstateConnector for more info.
}
else
{
MainConsole.Instance.InfoFormat("[EstateService]: The estate '{0}' owned by '{1}' has been created.",
ES.EstateName, sysAccounts.GetSystemEstateOwnerName(estateID));
}
}
/// <summary>
/// Fixes missing region owners command.
/// </summary>
/// <param name="scene">Scene.</param>
/// <param name="cmd">Cmd.</param>
void FixMissingRegionOwners(IScene scene, string [] cmd)
{
QueryFilter filter = new QueryFilter();
filter.andFilters ["OwnerUUID"] = UUID.Zero;
List <GridRegion> borked = ParseQuery(null, m_GD.Query(new string [] { "*" }, m_realm, filter, null, null, null));
if (borked.Count < 1)
{
MainConsole.Instance.Info("[LocalGridConnector] No regions found with missing owners.");
return;
}
IEstateConnector estatePlugin = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
if (estatePlugin == null)
{
MainConsole.Instance.Error("[LocalGridConnector] " + borked.Count +
" regions found with missing owners, but could not get IEstateConnector plugin.");
return;
}
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.GetRegionEstateID(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.GetEstateIDSettings(estateID);
if ((es == null) || (es.EstateID == 0))
{
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;
}
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);
}
}
}
}
