/// <summary>
/// Saves the estate settings to an archive.
/// </summary>
/// <param name="writer">Writer.</param>
/// <param name="scene">Scene.</param>
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene)
{
MainConsole.Instance.Debug("[Archive]: Writing estates to archive");
EstateSettings settings = scene.RegionInfo.EstateSettings;
if (settings == null)
{
return;
}
writer.WriteDir("estatesettings");
writer.WriteFile("estatesettings/" + scene.RegionInfo.RegionName,
OSDParser.SerializeLLSDBinary(settings.ToOSD()));
MainConsole.Instance.Debug("[Archive]: Finished writing estates to archive");
MainConsole.Instance.Debug("[Archive]: Writing region info to archive");
writer.WriteDir("regioninfo");
RegionInfo regionInfo = scene.RegionInfo;
writer.WriteFile("regioninfo/" + scene.RegionInfo.RegionName,
OSDParser.SerializeLLSDBinary(regionInfo.PackRegionInfoData()));
MainConsole.Instance.Debug("[Archive]: Finished writing region info to archive");
}
public int CreateNewEstate(EstateSettings es)
{
if (m_doRemoteOnly)
{
object remoteValue = DoRemote(es.ToOSD());
return(remoteValue != null ? (int)remoteValue : 0); // 0 is 'no estate'
}
int estateID = GetEstate(es.EstateOwner, es.EstateName);
if (estateID > 0)
{
return(estateID);
}
// check for system or user estates
if ((es.EstateOwner == (UUID)Constants.GovernorUUID)) // Mainland?
{
es.EstateID = Constants.MainlandEstateID;
}
else if ((es.EstateOwner == (UUID)Constants.RealEstateOwnerUUID)) // System Estate?
{
es.EstateID = Constants.SystemEstateID;
}
else // must be a new user estate then
{
es.EstateID = GetNewEstateID();
}
SaveEstateSettings(es, true);
return((int)es.EstateID);
}
public int CreateNewEstate(EstateSettings es, UUID RegionID)
{
object remoteValue = DoRemote(es.ToOSD(), RegionID);
if (remoteValue != null || m_doRemoteOnly)
{
return((int)remoteValue);
}
int estateID = GetEstate(es.EstateOwner, es.EstateName);
if (estateID > 0)
{
if (LinkRegion(RegionID, estateID))
{
return(estateID);
}
return(0);
}
es.EstateID = GetNewEstateID();
SaveEstateSettings(es, true);
LinkRegion(RegionID, (int)es.EstateID);
return((int)es.EstateID);
}
public int CreateNewEstate(EstateSettings es)
{
object remoteValue = DoRemote(es.ToOSD());
if (remoteValue != null || m_doRemoteOnly)
{
return((int)remoteValue);
}
int estateID = GetEstate(es.EstateOwner, es.EstateName);
if (estateID > 0)
{
return(estateID);
}
// check for system user/estate
if ((es.EstateOwner == (UUID)Constants.RealEstateOwnerUUID)) // We probably do not need to check both :)
{
es.EstateID = (uint)Constants.SystemEstateID; // Default Mainland estate #
}
else
{
es.EstateID = GetNewEstateID();
}
SaveEstateSettings(es, true);
return((int)es.EstateID);
}
protected void SaveEstateSettings(EstateSettings es, bool doInsert)
{
string[] keys = new string[5]
{
"EstateID",
"EstateName",
"EstateOwner",
"ParentEstateID",
"Settings"
};
object[] values = new object[5]
{
es.EstateID,
es.EstateName,
es.EstateOwner,
es.ParentEstateID,
OSDParser.SerializeJsonString(es.ToOSD())
};
if (!doInsert)
{
GD.Update(m_estateTable, values, keys, new string[1] {
"EstateID"
}, new object[1] {
es.EstateID
});
}
else
{
GD.Insert(m_estateTable, keys, values);
}
}
public void SaveEstateSettings(EstateSettings es)
{
if (m_doRemoteOnly)
{
DoRemote(es.ToOSD());
return;
}
SaveEstateSettings(es, false);
}
public void SaveEstateSettings(EstateSettings es)
{
object remoteValue = DoRemote(es.ToOSD());
if (remoteValue != null || m_doRemoteOnly)
{
return;
}
SaveEstateSettings(es, false);
}
public List <EstateSettings> GetEstates(UUID OwnerID, Dictionary <string, bool> boolFields)
{
object remoteValue = DoRemote(OwnerID, boolFields);
if (remoteValue != null || m_doRemoteOnly)
{
return((List <EstateSettings>)remoteValue);
}
List <EstateSettings> settings = new List <EstateSettings>();
QueryFilter filter = new QueryFilter();
filter.andFilters["EstateOwner"] = OwnerID;
List <int> retVal =
GD.Query(new string[1] {
"EstateID"
}, m_estateTable, filter, null, null, null)
.ConvertAll(x => int.Parse(x));
foreach (int estateID in retVal)
{
bool Add = true;
EstateSettings es = GetEstate(estateID);
if (boolFields.Count > 0)
{
OSDMap esmap = es.ToOSD();
foreach (KeyValuePair <string, bool> field in boolFields)
{
if (esmap.ContainsKey(field.Key) && esmap[field.Key].AsBoolean() != field.Value)
{
Add = false;
break;
}
}
}
if (Add)
{
settings.Add(ReturnEstateSettings(es));
}
}
return(settings);
}
public int CreateNewEstate(EstateSettings es, UUID RegionID)
{
object remoteValue = DoRemote(es.ToOSD(), RegionID);
if (remoteValue != null || m_doRemoteOnly)
return (int) remoteValue;
int estateID = GetEstate(es.EstateOwner, es.EstateName);
if (estateID > 0)
{
if (LinkRegion(RegionID, estateID))
return estateID;
return 0;
}
es.EstateID = GetNewEstateID();
SaveEstateSettings(es, true);
LinkRegion(RegionID, (int) es.EstateID);
return (int) es.EstateID;
}
protected void SaveEstateSettings(EstateSettings es, bool doInsert)
{
Dictionary <string, object> values = new Dictionary <string, object> (5);
values ["EstateID"] = es.EstateID;
values ["EstateName"] = es.EstateName;
values ["EstateOwner"] = es.EstateOwner;
values ["ParentEstateID"] = es.ParentEstateID;
values ["Settings"] = OSDParser.SerializeJsonString(es.ToOSD());
if (!doInsert)
{
QueryFilter filter = new QueryFilter();
filter.andFilters ["EstateID"] = es.EstateID;
GD.Update(m_estateSettingsTable, values, null, filter, null, null);
}
else
{
GD.Insert(m_estateSettingsTable, values);
}
}
public override void FinishedMigration(IDataConnector genericData)
{
if (!genericData.TableExists("estates"))
{
return;
}
DataReaderConnection dr = genericData.QueryData("WHERE `Key` = 'EstateID'", "estates",
"`ID`, `Key`, `Value`");
if (dr != null)
{
try
{
while (dr.DataReader.Read())
{
try
{
UUID ID = UUID.Parse(dr.DataReader["ID"].ToString());
string value = dr.DataReader["Value"].ToString();
QueryFilter filter = new QueryFilter();
filter.andFilters["`ID`"] = value;
filter.andFilters["`Key`"] = "EstateSettings";
List <string> results = genericData.Query(new string[1] {
"`Value`"
}, "estates", filter, null,
null, null);
if ((results != null) && (results.Count >= 1))
{
EstateSettings es = new EstateSettings();
es.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(results[0]));
genericData.Insert("estateregions", new object[] { ID, value });
filter = new QueryFilter();
filter.andFilters["`EstateID`"] = value;
List <string> exist = genericData.Query(new string[1] {
"`EstateID`"
}, "estatesettings",
filter, null, null, null);
if (exist == null || exist.Count == 0)
{
genericData.Insert("estatesettings",
new object[]
{
value, es.EstateName, es.EstateOwner, es.ParentEstateID,
es.ToOSD()
});
}
}
}
catch
{
}
}
}
catch
{
}
finally
{
dr.DataReader.Close();
genericData.CloseDatabase(dr);
}
}
}
protected void SaveEstateSettings(EstateSettings es, bool doInsert)
{
Dictionary<string, object> values = new Dictionary<string, object>(5);
values["EstateID"] = es.EstateID;
values["EstateName"] = es.EstateName;
values["EstateOwner"] = es.EstateOwner;
values["ParentEstateID"] = es.ParentEstateID;
values["Settings"] = OSDParser.SerializeJsonString(es.ToOSD());
if (!doInsert)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["EstateID"] = es.EstateID;
GD.Update(m_estateTable, values, null, filter, null, null);
}
else
{
GD.Insert(m_estateTable, values);
}
}
public void SaveEstateSettings(EstateSettings es)
{
object remoteValue = DoRemote(es.ToOSD());
if (remoteValue != null || m_doRemoteOnly)
return;
SaveEstateSettings(es, false);
}
public EstateSettings CreateEstate(EstateSettings es, UUID RegionID)
{
int EstateID = 0;
List<string> QueryResults = GD.Query("`Key`", "EstateID", "estates", "`Value`", " ORDER BY `Value` DESC");
if (QueryResults.Count == 0)
EstateID = 99;
else
EstateID = int.Parse(QueryResults[0]);
if (EstateID == 0)
EstateID = 99;
//Check for other estates with the same name
List<int> Estates = GetEstates(es.EstateName);
if (Estates != null)
{
foreach (int otherEstateID in Estates)
{
EstateSettings otherEstate = this.LoadEstateSettings(otherEstateID);
if (otherEstate.EstateName == es.EstateName)
{ //Cant have two estates with the same name.
//We set the estate name so that the region can get the error and so we don't have to spit out more junk to find it.
return new EstateSettings()
{
EstateID = 0,
EstateName = "Duplicate Estate Name. Please Change."
};
}
}
}
EstateID++;
es.EstateID = (uint)EstateID;
List<object> Values = new List<object>();
Values.Add(es.EstateID);
Values.Add("EstateSettings");
OSD map = es.ToOSD(true);
Values.Add(OSDParser.SerializeLLSDXmlString(map));
GD.Insert("estates", Values.ToArray());
GD.Insert("estates", new object[] {
RegionID,
"EstateID",
EstateID
});
es.OnSave += SaveEstateSettings;
return es;
}
public void SaveEstateSettings(EstateSettings es)
{
List<string> query = null;
try
{
query = GD.Query(new[] {"ID", "`Key`"}, new object[] {es.EstateID, "EstateSettings"}, "estates",
"`Value`");
}
catch
{
}
if (query == null || query.Count == 0)
return; //Couldn't find it, return default then.
OSDMap estateInfo = (OSDMap) OSDParser.DeserializeLLSDXml(query[0]);
if (estateInfo["EstatePass"].AsString() != es.EstatePass)
{
MainConsole.Instance.Warn("[ESTATE SERVICE]: Wrong estate password in updating of estate " + es.EstateName +
"! Possible attempt to hack this estate!");
return;
}
List<string> Keys = new List<string> {"Value"};
List<object> Values = new List<object> {OSDParser.SerializeLLSDXmlString(es.ToOSD(true))};
GD.Update("estates", Values.ToArray(), Keys.ToArray(), new[] {"ID", "`Key`"},
new object[] {es.EstateID, "EstateSettings"});
SaveBanList(es);
SaveUUIDList(es.EstateID, "EstateManagers", es.EstateManagers);
SaveUUIDList(es.EstateID, "EstateAccess", es.EstateAccess);
SaveUUIDList(es.EstateID, "EstateGroups", es.EstateGroups);
m_registry.RequestModuleInterface<ISimulationBase>().EventManager.FireGenericEventHandler("EstateUpdated",
es);
}
