public void Delete(RegionInfo region)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["RegionID"] = region.RegionID;
GD.Delete("simulator", filter);
}
public bool AddClassified(Classified classified)
{
object remoteValue = DoRemote(classified);
if (remoteValue != null || m_doRemoteOnly)
{
return(remoteValue == null ? false : (bool)remoteValue);
}
if (GetUserProfile(classified.CreatorUUID) == null)
{
return(false);
}
//It might be updating, delete the old
QueryFilter filter = new QueryFilter();
filter.andFilters["ClassifiedUUID"] = classified.ClassifiedUUID;
GD.Delete("userclassifieds", filter);
List <object> values = new List <object> {
classified.Name.MySqlEscape(),
classified.Category,
classified.SimName.MySqlEscape(),
classified.CreatorUUID,
classified.ScopeID,
classified.ClassifiedUUID,
OSDParser.SerializeJsonString(classified.ToOSD())
};
return(GD.Insert("userclassifieds", values.ToArray()));
}
public void SchedulerRemove(string id)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["id"] = id;
m_Gd.Delete("scheduler", filter);
}
/// <summary>
/// Delete a parcel from the database
/// </summary>
/// <param name = "RegionID"></param>
/// <param name = "ParcelID"></param>
public void RemoveLandObject(UUID RegionID, UUID ParcelID)
{
//Remove both the generic and the parcel access list
GenericUtils.RemoveGenericByKeyAndType(RegionID, "LandData", ParcelID.ToString(), GD);
QueryFilter filter = new QueryFilter();
filter.andFilters["ParcelID"] = ParcelID;
GD.Delete("parcelaccess", filter);
}
public bool Store(UUID PrincipalID, string Friend, int Flags, int Offered)
{
GD.Delete(m_realm, new string[2] {
"PrincipalID", "Friend"
}, new object[2] {
PrincipalID, Friend
});
return(GD.Insert(m_realm, new string[] { "PrincipalID", "Friend", "Flags", "Offered" },
new object[] { PrincipalID, Friend, Flags, Offered }));
}
public bool Store(AuthData data)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["UUID"] = data.PrincipalID;
filter.andFilters["accountType"] = data.AccountType;
GD.Delete(m_realm, filter);
Dictionary<string, object> row = new Dictionary<string, object>(4);
row["UUID"] = data.PrincipalID;
row["passwordHash"] = data.PasswordHash;
row["passwordSalt"] = data.PasswordSalt;
row["accountType"] = data.AccountType;
return GD.Insert(m_realm, row);
}
public bool StoreFolder(InventoryFolderBase folder)
{
GD.Delete(m_foldersrealm, new string[1] {
"folderID"
}, new object[1] {
folder.ID
});
return(GD.Insert(m_foldersrealm, new string[6] {
"folderName", "type", "version", "folderID", "agentID", "parentFolderID"
},
new object[6] {
folder.Name, folder.Type, folder.Version, folder.ID, folder.Owner, folder.ParentID
}));
}
public bool DelinkRegion(UUID regionID)
{
if (m_doRemoteOnly)
{
object remoteValue = DoRemote(regionID);
return(remoteValue != null ? (bool)remoteValue : false);
}
QueryFilter filter = new QueryFilter();
filter.andFilters ["RegionID"] = regionID;
GD.Delete(m_estateRegionsTable, filter);
return(true);
}
public bool Store(UUID PrincipalID, string Friend, int Flags, int Offered)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["PrincipalID"] = PrincipalID;
filter.andFilters["Friend"] = Friend;
GD.Delete(m_realm, filter);
Dictionary <string, object> row = new Dictionary <string, object>(4);
row["PrincipalID"] = PrincipalID;
row["Friend"] = Friend;
row["Flags"] = Flags;
row["Offered"] = Offered;
return(GD.Insert(m_realm, row));
}
public bool Store(UUID PrincipalID, AvatarData data)
{
GD.Delete(m_realm, new string[1] {
"PrincipalID"
}, new object[1] {
PrincipalID
});
for (int i = 0; i < data.Data.Count; i++)
{
GD.Insert(m_realm, new object[3] {
PrincipalID, data.Data.ElementAt(i).Key, data.Data.ElementAt(i).Value
});
}
return(true);
}
/// <summary>
/// Removes a generic from the database
/// </summary>
/// <param name="OwnerID">ID of the entity that owns the generic data</param>
/// <param name="Type"></param>
/// <param name="GD"></param>
public static void RemoveGenericByType(UUID OwnerID, string Type, IGenericData GD)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["OwnerID"] = OwnerID;
filter.andFilters["Type"] = Type;
GD.Delete("generics", filter);
}
/// <summary>
/// Removes a generic from the database
/// </summary>
/// <param name="OwnerID">ID of the entity that owns the generic data</param>
/// <param name="Key"></param>
/// <param name="GD"></param>
public static void RemoveGenericByKey(UUID OwnerID, string Key, IGenericData GD)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["OwnerID"] = OwnerID;
filter.andFilters["`Key`"] = Key;
GD.Delete("generics", filter);
}
public bool Delete(UUID id, bool ignoreFlags)
{
try {
if (!ignoreFlags)
{
AssetBase asset = GetAsset(id, false);
if (asset == null)
{
return(false);
}
if ((asset.Flags & AssetFlags.Maptile) != 0 || //Deprecated, use Deletable instead
(asset.Flags & AssetFlags.Deletable) != 0)
{
ignoreFlags = true;
}
asset.Dispose();
}
if (ignoreFlags)
{
QueryFilter filter = new QueryFilter();
filter.andFilters ["id"] = id;
m_Gd.Delete("assets", filter);
}
} catch (Exception e) {
if (MainConsole.Instance != null)
{
MainConsole.Instance.Error("[LocalAssetDatabase] Error while deleting asset " + e);
}
}
return(true);
}
public bool Set(UserInfo info)
{
object[] values = new object[14];
values[0] = info.UserID;
values[1] = info.CurrentRegionID;
values[2] = Util.ToUnixTime(DateTime.Now.ToUniversalTime());
//Convert to binary so that it can be converted easily
values[3] = info.IsOnline ? 1 : 0;
values[4] = Util.ToUnixTime(info.LastLogin);
values[5] = Util.ToUnixTime(info.LastLogout);
values[6] = OSDParser.SerializeJsonString(info.Info);
values[7] = info.CurrentRegionID.ToString();
values[8] = info.CurrentPosition.ToString();
values[9] = info.CurrentLookAt.ToString();
values[10] = info.HomeRegionID.ToString();
values[11] = info.HomePosition.ToString();
values[12] = info.HomeLookAt.ToString();
values[13] = info.CurrentRegionURI;
QueryFilter filter = new QueryFilter();
filter.andFilters["UserID"] = info.UserID;
GD.Delete(m_realm, filter);
return(GD.Insert(m_realm, values));
}
public bool Delete(UUID PrincipalID)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["PrincipalID"] = PrincipalID;
return(GD.Delete(m_realm, filter));
}
private bool Delete(UUID id, bool ignoreFlags)
{
try
{
if (!ignoreFlags)
{
AssetBase asset = GetAsset(id, false);
if (asset == null)
{
return(false);
}
if ((int)(asset.Flags & AssetFlags.Maptile) != 0 || //Depriated, use Deletable instead
(int)(asset.Flags & AssetFlags.Deletable) != 0)
{
ignoreFlags = true;
}
}
if (ignoreFlags)
{
m_Gd.Delete("assets", "id = '" + id + "'");
}
}
catch (Exception e)
{
MainConsole.Instance.Error("[LocalAssetDatabase] Error while deleting asset " + e);
}
return(true);
}
/// <summary>
/// Removes the telehub if it exists.
/// </summary>
/// <param name="regionID"></param>
public void RemoveTelehub(UUID regionID, ulong regionHandle)
{
//Look for a telehub first.
if (FindTelehub(regionID, 0) != null)
{
GD.Delete("telehubs", new string[] { "RegionID" }, new object[] { regionID });
}
}
public bool DelinkRegion(UUID regionID)
{
object remoteValue = DoRemote(regionID);
if (remoteValue != null)
{
return((bool)remoteValue);
}
GD.Delete("estateregions", new[] { "RegionID" },
new object[]
{
regionID
});
return(true);
}
public void ClearRegion(UUID regionID)
{
GD.Delete("searchparcel", new string[1] {
"RegionID"
}, new object[1] {
regionID
});
}
public void RemoveRoleFromGroup(UUID requestingAgentID, UUID RoleID, UUID GroupID)
{
if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong)GroupPowers.DeleteRole))
{
return;
}
data.Delete("osgrouprolemembership", new string[] {
"GroupID",
"RoleID"
}, new object[] {
GroupID,
RoleID
});
data.Update("osgroupmembership", new object[] { UUID.Zero }, new string[] { "SelectedRoleID" }, new string[] {
"GroupID",
"SelectedRoleID"
}, new object[] {
GroupID,
RoleID
});
data.Delete("osrole", new string[] {
"GroupID",
"RoleID"
}, new object[] {
GroupID,
RoleID
});
}
/// <summary>
/// Removes a generic from the database
/// </summary>
/// <param name="ownerID">ID of the entity that owns the generic data</param>
/// <param name="type"></param>
/// <param name="genData"></param>
public static void RemoveGenericByType(UUID ownerID, string type, IGenericData genData)
{
QueryFilter filter = new QueryFilter();
filter.andFilters ["OwnerID"] = ownerID;
filter.andFilters ["Type"] = type;
genData.Delete("generics", filter);
}
public bool Delete(UUID principalID)
{
lock (m_lock) {
QueryFilter filter = new QueryFilter();
filter.andFilters ["PrincipalID"] = principalID;
return(m_GD.Delete(m_realm, filter));
}
}
/// <summary>
/// Removes a generic from the database
/// </summary>
/// <param name="ownerID">ID of the entity that owns the generic data</param>
/// <param name="key"></param>
/// <param name="genData"></param>
public static void RemoveGenericByKey(UUID ownerID, string key, IGenericData genData)
{
QueryFilter filter = new QueryFilter();
filter.andFilters ["OwnerID"] = ownerID;
filter.andFilters ["`Key`"] = key;
genData.Delete("generics", filter);
}
public bool Store(AuthData data)
{
GD.Delete(m_realm, new string[2] {
"UUID", "accountType"
}, new object[2] {
data.PrincipalID, data.AccountType
});
return(GD.Insert(m_realm, new[]
{
"UUID", "passwordHash", "passwordSalt",
"accountType"
}, new object[]
{
data.PrincipalID,
data.PasswordHash.MySqlEscape(1024), data.PasswordSalt.MySqlEscape(1024),
data.AccountType.MySqlEscape(32)
}));
}
public bool Store(UUID PrincipalID, AvatarData data)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["PrincipalID"] = PrincipalID;
GD.Delete(m_realm, filter);
List <object[]> insertList = new List <object[]>();
foreach (KeyValuePair <string, string> kvp in data.Data)
{
insertList.Add(new object[3] {
PrincipalID,
kvp.Key.MySqlEscape(32),
kvp.Key == "Textures" ? kvp.Value : kvp.Value.MySqlEscape()
});
}
GD.InsertMultiple(m_realm, insertList);
return(true);
}
public bool AddClassified(Classified classified)
{
if (m_doRemoteOnly)
{
object remoteValue = DoRemote(classified);
return(remoteValue != null && (bool)remoteValue);
}
if (GetUserProfile(classified.CreatorUUID) == null)
{
return(false);
}
string keywords = classified.Description;
if (keywords.Length > 512)
{
keywords = keywords.Substring(keywords.Length - 512, 512);
}
// It might be updating, delete the old
QueryFilter filter = new QueryFilter();
filter.andFilters ["ClassifiedUUID"] = classified.ClassifiedUUID;
genData.Delete(m_userClassifiedsTable, filter);
List <object> values = new List <object>
{
classified.Name,
classified.Category,
classified.SimName,
classified.CreatorUUID,
classified.ScopeID,
classified.ClassifiedUUID,
OSDParser.SerializeJsonString(classified.ToOSD()),
classified.PriceForListing,
keywords
};
return(genData.Insert(m_userClassifiedsTable, values.ToArray()));
}
public bool Store(UUID PrincipalID, AvatarData data)
{
lock (m_locks[PrincipalID])
{
QueryFilter filter = new QueryFilter();
filter.andFilters["PrincipalID"] = PrincipalID;
GD.Delete(m_realm, filter);
List <object[]> insertList = new List <object[]>();
foreach (KeyValuePair <string, string> kvp in data.Data)
{
insertList.Add(new object[3] {
PrincipalID,
kvp.Key,
kvp.Value
});
}
GD.InsertMultiple(m_realm, insertList);
}
return(true);
}
public bool Store(AuthData data)
{
GD.Delete(m_realm, new string[1] {
"UUID"
}, new object[1] {
data.PrincipalID
});
return(GD.Insert(m_realm, new string[] { "UUID", "passwordHash", "passwordSalt",
"webLoginKey", "accountType" }, new object[] { data.PrincipalID,
data.PasswordHash, data.PasswordSalt, data.WebLoginKey, data.AccountType }));
}
public bool Store(UUID PrincipalID, AvatarData data)
{
GD.Delete(m_realm, new string[1] {
"PrincipalID"
}, new object[1] {
PrincipalID
});
List <object[]> insertList = new List <object[]>();
foreach (KeyValuePair <string, string> kvp in data.Data)
{
insertList.Add(new object[3]
{
PrincipalID,
kvp.Key.MySqlEscape(32),
kvp.Key == "Textures" ? kvp.Value : kvp.Value.MySqlEscape()
});
}
GD.InsertMultiple(m_realm, insertList);
return(true);
}
public void StoreRegionSettings(RegionSettings rs)
{
//Delete the original
GD.Delete(m_regionSettingsRealm, new string[1] {
"regionUUID"
}, new object[1] {
rs.RegionUUID
});
//Now replace with the new
GD.Insert(m_regionSettingsRealm, new object[] { rs.RegionUUID, rs.BlockTerraform, rs.BlockFly, rs.AllowDamage,
rs.RestrictPushing, rs.AllowLandResell, rs.AllowLandJoinDivide, rs.BlockShowInSearch, rs.AgentLimit, rs.ObjectBonus,
rs.Maturity, rs.DisableScripts, rs.DisableCollisions, rs.DisablePhysics, rs.TerrainTexture1,
rs.TerrainTexture2, rs.TerrainTexture3, rs.TerrainTexture4, rs.Elevation1NW, rs.Elevation2NW,
rs.Elevation1NE, rs.Elevation2NE, rs.Elevation1SE, rs.Elevation2SE, rs.Elevation1SW, rs.Elevation2SW,
rs.WaterHeight, rs.TerrainRaiseLimit, rs.TerrainLowerLimit, rs.UseEstateSun, rs.FixedSun, rs.SunPosition,
rs.Covenant, rs.Sandbox, rs.SunVector.X, rs.SunVector.Y, rs.SunVector.Z, rs.LoadedCreationID, rs.LoadedCreationDateTime,
rs.TerrainMapImageID, rs.TerrainImageID, rs.MinimumAge, rs.CovenantLastUpdated, OSDParser.SerializeJsonString(rs.Generic) });
}
