public void AddCacheItemAsync(InventoryItemBase item)
{
if (item == null)
return;
lock (_tempItemCache)
{
if (!_tempItemCache.ContainsKey(item.ID))
_tempItemCache.Add(item.ID, item);
}
}
public void AddCacheItemAsync(InventoryItemBase item)
{
if (item == null)
return;
lock (_tempItemCache)
{
if (!_tempItemCache.ContainsKey(item.ID))
_tempItemCache.Add(item.ID, item);
}
//_addInventoryItemQueue.Add(item.Owner, new AddInventoryItemStore(item, success));
}
/// <summary>
/// Deserialize item
/// </summary>
/// <param name="serialization"></param>
/// <returns></returns>
/// <exception cref="System.Xml.XmlException"></exception>
public static InventoryItemBase Deserialize(byte [] serialization)
{
InventoryItemBase item = new InventoryItemBase ();
StringReader reader = new StringReader (Encoding.ASCII.GetString (serialization, 0, serialization.Length));
XmlReader xtr = XmlReader.Create (reader);
//Uses byte[] directly... should be used once issues with it are fixed
//MemoryStream mr = new MemoryStream (serialization);
//StreamReader sr = new StreamReader (mr, Encoding.ASCII);
//XmlReader xtr = XmlTextReader.Create (sr);
xtr.ReadStartElement ("InventoryItem");
item.Name = xtr.ReadElementString ("Name");
item.ID = UUID.Parse (xtr.ReadElementString ("ID"));
item.InvType = Convert.ToInt32 (xtr.ReadElementString ("InvType"));
item.CreatorId = xtr.ReadElementString ("CreatorUUID");
try {
item.CreatorData = xtr.ReadElementString ("CreatorData");
} catch {
}
item.CreationDate = Convert.ToInt32 (xtr.ReadElementString ("CreationDate"));
item.Owner = UUID.Parse (xtr.ReadElementString ("Owner"));
item.Description = xtr.ReadElementString ("Description");
item.AssetType = Convert.ToInt32 (xtr.ReadElementString ("AssetType"));
item.AssetID = UUID.Parse (xtr.ReadElementString ("AssetID"));
item.SaleType = Convert.ToByte (xtr.ReadElementString ("SaleType"));
item.SalePrice = Convert.ToInt32 (xtr.ReadElementString ("SalePrice"));
item.BasePermissions = Convert.ToUInt32 (xtr.ReadElementString ("BasePermissions"));
item.CurrentPermissions = Convert.ToUInt32 (xtr.ReadElementString ("CurrentPermissions"));
item.EveryOnePermissions = Convert.ToUInt32 (xtr.ReadElementString ("EveryOnePermissions"));
item.NextPermissions = Convert.ToUInt32 (xtr.ReadElementString ("NextPermissions"));
item.Flags = Convert.ToUInt32 (xtr.ReadElementString ("Flags"));
item.GroupID = UUID.Parse (xtr.ReadElementString ("GroupID"));
item.GroupOwned = Convert.ToBoolean (xtr.ReadElementString ("GroupOwned"));
xtr.ReadEndElement ();
xtr.Close ();
return item;
}
public override void FromOSD(OSDMap map)
{
OSDArray items = (OSDArray) map["Items"];
Items = items.ConvertAll<InventoryItemBase>((osd) =>
{
InventoryItemBase item = new InventoryItemBase();
item.FromOSD((OSDMap) osd);
return item;
}
);
OSDArray folders = (OSDArray) map["Folders"];
Folders = folders.ConvertAll<InventoryFolderBase>((osd) =>
{
InventoryFolderBase folder =
new InventoryFolderBase();
folder.FromOSD((OSDMap) osd);
return folder;
}
);
UserID = map["UserID"];
FolderID = map["FolderID"];
}
public virtual bool StoreItem(InventoryItemBase item)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["inventoryID"] = item.ID;
GD.Delete(m_itemsrealm, filter);
Dictionary<string, object> row = new Dictionary<string, object>(20);
row["assetID"] = item.AssetID;
row["assetType"] = item.AssetType;
row["inventoryName"] = item.Name;
row["inventoryDescription"] = item.Description;
row["inventoryNextPermissions"] = item.NextPermissions;
row["inventoryCurrentPermissions"] = item.CurrentPermissions;
row["invType"] = item.InvType;
row["creatorID"] = item.CreatorIdentification;
row["inventoryBasePermissions"] = item.BasePermissions;
row["inventoryEveryOnePermissions"] = item.EveryOnePermissions;
row["salePrice"] = item.SalePrice;
row["saleType"] = item.SaleType;
row["creationDate"] = item.CreationDate;
row["groupID"] = item.GroupID;
row["groupOwned"] = item.GroupOwned ? "1" : "0";
row["flags"] = item.Flags;
row["inventoryID"] = item.ID;
row["avatarID"] = item.Owner;
row["parentFolderID"] = item.Folder;
row["inventoryGroupPermissions"] = item.GroupPermissions;
return GD.Insert(m_itemsrealm, row);
}
InventoryItemBase GiveInventoryItem (UUID senderId, UUID recipient, InventoryItemBase item,
InventoryFolderBase parentFolder)
{
InventoryItemBase itemCopy = new InventoryItemBase {
Owner = recipient,
CreatorId = item.CreatorId,
CreatorData = item.CreatorData,
ID = UUID.Random (),
AssetID = item.AssetID,
Description = item.Description,
Name = item.Name,
AssetType = item.AssetType,
InvType = item.InvType,
Folder = UUID.Zero,
NextPermissions = (uint)PermissionMask.All,
GroupPermissions = (uint)PermissionMask.All,
EveryOnePermissions = (uint)PermissionMask.All,
CurrentPermissions = (uint)PermissionMask.All
};
//Give full permissions for them
if (parentFolder == null) {
InventoryFolderBase folder = inventoryService.GetFolderForType (recipient, InventoryType.Unknown,
(FolderType)itemCopy.AssetType);
if (folder != null)
itemCopy.Folder = folder.ID;
else {
InventoryFolderBase root = inventoryService.GetRootFolder (recipient);
if (root != null)
itemCopy.Folder = root.ID;
else
return null; // No destination
}
} else
itemCopy.Folder = parentFolder.ID; //We already have a folder to put it in
itemCopy.GroupID = UUID.Zero;
itemCopy.GroupOwned = false;
itemCopy.Flags = item.Flags;
itemCopy.SalePrice = item.SalePrice;
itemCopy.SaleType = item.SaleType;
inventoryService.AddItem (itemCopy);
return itemCopy;
}
/// <summary>
/// Deserialize settings
/// </summary>
/// <param name="serialization"></param>
/// <returns></returns>
/// <exception cref="System.Xml.XmlException"></exception>
public static InventoryItemBase Deserialize(string serialization)
{
InventoryItemBase item = new InventoryItemBase();
StringReader sr = new StringReader(serialization);
XmlTextReader xtr = new XmlTextReader(sr);
xtr.ReadStartElement("InventoryItem");
item.Name = xtr.ReadElementString("Name");
item.ID = UUID.Parse(xtr.ReadElementString("ID"));
item.InvType = Convert.ToInt32(xtr.ReadElementString("InvType"));
item.CreatorId = xtr.ReadElementString("CreatorUUID");
item.CreatorData = xtr.ReadElementString("CreatorData");
item.CreationDate = Convert.ToInt32(xtr.ReadElementString("CreationDate"));
item.Owner = UUID.Parse(xtr.ReadElementString("Owner"));
item.Description = xtr.ReadElementString("Description");
item.AssetType = Convert.ToInt32(xtr.ReadElementString("AssetType"));
item.AssetID = UUID.Parse(xtr.ReadElementString("AssetID"));
item.SaleType = Convert.ToByte(xtr.ReadElementString("SaleType"));
item.SalePrice = Convert.ToInt32(xtr.ReadElementString("SalePrice"));
item.BasePermissions = Convert.ToUInt32(xtr.ReadElementString("BasePermissions"));
item.CurrentPermissions = Convert.ToUInt32(xtr.ReadElementString("CurrentPermissions"));
item.EveryOnePermissions = Convert.ToUInt32(xtr.ReadElementString("EveryOnePermissions"));
item.NextPermissions = Convert.ToUInt32(xtr.ReadElementString("NextPermissions"));
item.Flags = Convert.ToUInt32(xtr.ReadElementString("Flags"));
item.GroupID = UUID.Parse(xtr.ReadElementString("GroupID"));
item.GroupOwned = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));
xtr.ReadEndElement();
xtr.Close();
return item;
}
private void CompleteCreateItem(uint callbackID)
{
m_Scene.AssetService.Store(m_asset);
InventoryItemBase item = new InventoryItemBase();
item.Owner = ourClient.AgentId;
item.CreatorId = ourClient.AgentId.ToString();
item.ID = UUID.Random();
item.AssetID = m_asset.ID;
item.Description = m_description;
item.Name = m_name;
item.AssetType = type;
item.InvType = invType;
item.Folder = InventFolder;
item.BasePermissions = 0x7fffffff;
item.CurrentPermissions = 0x7fffffff;
item.GroupPermissions = 0;
item.EveryOnePermissions = 0;
item.NextPermissions = nextPerm;
item.Flags = (uint) wearableType;
item.CreationDate = Util.UnixTimeSinceEpoch();
m_Scene.InventoryService.AddItemAsync(item,
(itm) => ourClient.SendInventoryItemCreateUpdate(itm, callbackID));
m_transactions.RemoveXferUploader(m_transactionID);
}
protected virtual ISceneEntity CreateObjectFromInventory(IClientAPI remoteClient, UUID itemID, UUID assetID,
out XmlDocument doc, InventoryItemBase item)
{
byte[] rezAsset = m_scene.AssetService.GetData(assetID.ToString());
if (rezAsset != null)
{
string xmlData = Utils.BytesToString(rezAsset);
doc = new XmlDocument();
try
{
doc.LoadXml(xmlData);
}
catch
{
return null;
}
if (doc.FirstChild.OuterXml.StartsWith("<groups>") ||
(doc.FirstChild.NextSibling != null &&
doc.FirstChild.NextSibling.OuterXml.StartsWith("<groups>")))
{
//We don't do multiple objects here
return null;
}
string xml = "";
if (doc.FirstChild.NodeType == XmlNodeType.XmlDeclaration)
{
if (doc.FirstChild.NextSibling != null) xml = doc.FirstChild.NextSibling.OuterXml;
}
else
xml = doc.FirstChild.OuterXml;
ISceneEntity group
= SceneEntitySerializer.SceneObjectSerializer.FromOriginalXmlFormat(itemID, xml, m_scene);
if (group == null)
return null;
group.IsDeleted = false;
foreach (ISceneChildEntity part in group.ChildrenEntities())
{
//AR: Could be changed by user in inventory, so restore from inventory not asset on rez
if (item != null)
{
part.EveryoneMask = item.EveryOnePermissions;
part.GroupMask = item.GroupPermissions;
part.NextOwnerMask = item.NextPermissions;
}
part.IsLoading = false;
}
return group;
}
doc = null;
return null;
}
protected void SaveInvItem(InventoryItemBase inventoryItem, string path)
{
// Check For Permissions Filter Flags
if (!CanUserArchiveObject(m_userInfo.PrincipalID, inventoryItem))
{
MainConsole.Instance.InfoFormat(
"[INVENTORY ARCHIVER]: Insufficient permissions, skipping inventory item {0} {1} at {2}",
inventoryItem.Name, inventoryItem.ID, path);
// Count Items Excluded
CountFiltered++;
return;
}
string filename = path + CreateArchiveItemName(inventoryItem);
// Record the creator of this item for user record purposes (which might go away soon)
m_userUuids[inventoryItem.CreatorIdAsUuid] = 1;
InventoryItemBase saveItem = (InventoryItemBase) inventoryItem.Clone();
saveItem.CreatorId = OspResolver.MakeOspa(saveItem.CreatorIdAsUuid, m_accountService);
string serialization = UserInventoryItemSerializer.Serialize(saveItem);
m_archiveWriter.WriteFile(filename, serialization);
AssetType itemAssetType = (AssetType)inventoryItem.AssetType;
// Don't chase down link asset items as they actually point to their target item IDs rather than an asset
if (m_saveAssets && itemAssetType != AssetType.Link && itemAssetType != AssetType.LinkFolder)
m_assetGatherer.GatherAssetUuids(saveItem.AssetID, (AssetType) inventoryItem.AssetType, m_assetUuids);
}
/// <summary>
/// Create the archive name for a particular item.
/// </summary>
/// These names are prepended with an inventory item's UUID so that more than one item can have the
/// same name
/// <param name="item"></param>
/// <returns></returns>
public static string CreateArchiveItemName(InventoryItemBase item)
{
return CreateArchiveItemName(item.Name, item.ID);
}
public bool AddInventoryItem (InventoryItemBase item)
{
if (UUID.Zero == item.Folder) {
InventoryFolderBase f = m_inventoryService.GetFolderForType (
item.Owner,
(InventoryType)item.InvType,
(FolderType)item.AssetType);
if (f != null) {
//MainConsole.Instance.DebugFormat(
// "[Local Inventory Services Connector]: Found folder {0} type {1} for item {2}", f.Name, (AssetType)f.Type, item.Name);
item.Folder = f.ID;
} else {
f = m_inventoryService.GetRootFolder (item.Owner);
if (f != null) {
item.Folder = f.ID;
} else {
MainConsole.Instance.WarnFormat (
"[Agent inventory]: Could not find root folder for {0} when trying to add item {1} with no parent folder specified",
item.Owner, item.Name);
return false;
}
}
}
// check if the folder item exists
if (!m_inventoryService.FolderItemExists (item.Folder, item.ID)) {
if (m_inventoryService.ItemExists (item.ID)) {
// Don't use this item ID as it probably belongs to another local user's folder
item.ID = UUID.Random ();
}
if (!m_inventoryService.AddItem (item)) {
MainConsole.Instance.WarnFormat (
"[Agent inventory]: Agent {0} could not add item {1} {2}",
item.Owner, item.Name, item.ID);
return false;
}
}
return true;
}
/// <summary>
/// Add an inventory item to a prim in this group.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="localID"></param>
/// <param name="item"></param>
/// <param name="copyItemID">The item UUID that should be used by the new item.</param>
/// <returns></returns>
public bool AddInventoryItem(IClientAPI remoteClient, uint localID,
InventoryItemBase item, UUID copyItemID)
{
UUID newItemId = (copyItemID != UUID.Zero) ? copyItemID : item.ID;
SceneObjectPart part = (SceneObjectPart) GetChildPart(localID);
if (part != null)
{
TaskInventoryItem taskItem = new TaskInventoryItem
{
ItemID = newItemId,
AssetID = item.AssetID,
Name = item.Name,
Description = item.Description,
OwnerID = part.OwnerID,
CreatorID = item.CreatorIdAsUuid,
Type = item.AssetType,
InvType = item.InvType
};
// Transfer ownership
if (remoteClient != null &&
remoteClient.AgentId != part.OwnerID &&
m_scene.Permissions.PropagatePermissions())
{
taskItem.BasePermissions = item.BasePermissions &
item.NextPermissions;
taskItem.CurrentPermissions = item.CurrentPermissions &
item.NextPermissions;
taskItem.EveryonePermissions = item.EveryOnePermissions &
item.NextPermissions;
taskItem.GroupPermissions = item.GroupPermissions &
item.NextPermissions;
taskItem.NextPermissions = item.NextPermissions;
// We're adding this to a prim we don't own. Force owner change
taskItem.CurrentPermissions |= 16;
}
else
{
taskItem.BasePermissions = item.BasePermissions;
taskItem.CurrentPermissions = item.CurrentPermissions;
taskItem.EveryonePermissions = item.EveryOnePermissions;
taskItem.GroupPermissions = item.GroupPermissions;
taskItem.NextPermissions = item.NextPermissions;
}
taskItem.Flags = item.Flags;
taskItem.SalePrice = item.SalePrice;
taskItem.SaleType = item.SaleType;
taskItem.CreationDate = (uint) item.CreationDate;
bool addFromAllowedDrop = false;
if (remoteClient != null)
{
addFromAllowedDrop = remoteClient.AgentId != part.OwnerID;
}
part.Inventory.AddInventoryItem(taskItem, addFromAllowedDrop);
return true;
}
MainConsole.Instance.ErrorFormat(
"[PRIM INVENTORY]: " +
"Couldn't find prim local ID {0} in group {1}, {2} to add inventory item ID {3}",
localID, Name, UUID, newItemId);
return false;
}
/// <summary>
/// </summary>
/// <param name="assetName"></param>
/// <param name="assetDescription"></param>
/// <param name="assetID"></param>
/// <param name="inventoryItem"></param>
/// <param name="parentFolder"></param>
/// <param name="data"></param>
/// <param name="inventoryType"></param>
/// <param name="assetType"></param>
/// <param name="everyoneMask"></param>
/// <param name="groupMask"></param>
/// <param name="nextOwnerMask"></param>
public UUID UploadCompleteHandler (string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte [] data, string inventoryType,
string assetType, uint everyoneMask, uint groupMask, uint nextOwnerMask)
{
sbyte assType = 0;
sbyte inType = 0;
switch (inventoryType) {
case "sound":
inType = 1;
assType = 1;
break;
case "animation":
inType = 19;
assType = 20;
break;
case "snapshot":
inType = 15;
assType = 0;
break;
case "wearable":
inType = 18;
switch (assetType) {
case "bodypart":
assType = 13;
break;
case "clothing":
assType = 5;
break;
}
break;
case "object": {
inType = (sbyte)InventoryType.Object;
assType = (sbyte)AssetType.Object;
List<Vector3> positions = new List<Vector3> ();
List<Quaternion> rotations = new List<Quaternion> ();
OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml (data);
OSDArray instance_list = (OSDArray)request ["instance_list"];
OSDArray mesh_list = (OSDArray)request ["mesh_list"];
OSDArray texture_list = (OSDArray)request ["texture_list"];
SceneObjectGroup grp = null;
List<UUID> textures = new List<UUID> ();
foreach (
AssetBase textureAsset in
texture_list.Select (t => new AssetBase (UUID.Random (), assetName, AssetType.Texture,
m_agentID) { Data = t.AsBinary () })) {
textureAsset.ID = m_assetService.Store (textureAsset);
textures.Add (textureAsset.ID);
}
InventoryFolderBase meshFolder = m_inventoryService.GetFolderForType (m_agentID, InventoryType.Mesh, FolderType.Mesh);
for (int i = 0; i < mesh_list.Count; i++) {
PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox ();
Primitive.TextureEntry textureEntry =
new Primitive.TextureEntry (Primitive.TextureEntry.WHITE_TEXTURE);
OSDMap inner_instance_list = (OSDMap)instance_list [i];
OSDArray face_list = (OSDArray)inner_instance_list ["face_list"];
for (uint face = 0; face < face_list.Count; face++) {
OSDMap faceMap = (OSDMap)face_list [(int)face];
Primitive.TextureEntryFace f = pbs.Textures.CreateFace (face);
if (faceMap.ContainsKey ("fullbright"))
f.Fullbright = faceMap ["fullbright"].AsBoolean ();
if (faceMap.ContainsKey ("diffuse_color"))
f.RGBA = faceMap ["diffuse_color"].AsColor4 ();
int textureNum = faceMap ["image"].AsInteger ();
float imagerot = faceMap ["imagerot"].AsInteger ();
float offsets = (float)faceMap ["offsets"].AsReal ();
float offsett = (float)faceMap ["offsett"].AsReal ();
float scales = (float)faceMap ["scales"].AsReal ();
float scalet = (float)faceMap ["scalet"].AsReal ();
if (imagerot != 0)
f.Rotation = imagerot;
if (offsets != 0)
f.OffsetU = offsets;
if (offsett != 0)
f.OffsetV = offsett;
if (scales != 0)
f.RepeatU = scales;
if (scalet != 0)
f.RepeatV = scalet;
f.TextureID = textures.Count > textureNum
? textures [textureNum]
: Primitive.TextureEntry.WHITE_TEXTURE;
textureEntry.FaceTextures [face] = f;
}
pbs.TextureEntry = textureEntry.GetBytes ();
AssetBase meshAsset = new AssetBase (UUID.Random (), assetName, AssetType.Mesh, m_agentID) { Data = mesh_list [i].AsBinary () };
meshAsset.ID = m_assetService.Store (meshAsset);
if (meshFolder == null) {
m_inventoryService.CreateUserInventory (m_agentID, false);
meshFolder = m_inventoryService.GetFolderForType (m_agentID, InventoryType.Mesh, FolderType.Mesh);
}
InventoryItemBase itemBase = new InventoryItemBase (UUID.Random (), m_agentID) {
AssetType = (sbyte)AssetType.Mesh,
AssetID = meshAsset.ID,
CreatorId = m_agentID.ToString (),
Folder = meshFolder.ID,
InvType = (int)InventoryType.Texture,
Name = "(Mesh) - " + assetName,
CurrentPermissions = (uint)PermissionMask.All,
BasePermissions = (uint)PermissionMask.All,
EveryOnePermissions = everyoneMask,
GroupPermissions = groupMask,
NextPermissions = nextOwnerMask
};
//Bad... but whatever
m_inventoryService.AddItem (itemBase);
pbs.SculptEntry = true;
pbs.SculptTexture = meshAsset.ID;
pbs.SculptType = (byte)SculptType.Mesh;
pbs.SculptData = meshAsset.Data;
Vector3 position = inner_instance_list ["position"].AsVector3 ();
Vector3 scale = inner_instance_list ["scale"].AsVector3 ();
Quaternion rotation = inner_instance_list ["rotation"].AsQuaternion ();
int physicsShapeType = inner_instance_list ["physics_shape_type"].AsInteger ();
// not currently used int material = inner_instance_list["material"].AsInteger();
// not currently used int mesh = inner_instance_list["mesh"].AsInteger();
SceneObjectPart prim = new SceneObjectPart (m_agentID, pbs, position, Quaternion.Identity,
Vector3.Zero, assetName) { Scale = scale, AbsolutePosition = position };
rotations.Add (rotation);
positions.Add (position);
prim.UUID = UUID.Random ();
prim.CreatorID = m_agentID;
prim.OwnerID = m_agentID;
prim.GroupID = UUID.Zero;
prim.LastOwnerID = m_agentID;
prim.CreationDate = Util.UnixTimeSinceEpoch ();
prim.Name = assetName;
prim.Description = "";
prim.PhysicsType = (byte)physicsShapeType;
prim.BaseMask = (uint)PermissionMask.All;
prim.EveryoneMask = everyoneMask;
prim.NextOwnerMask = nextOwnerMask;
prim.GroupMask = groupMask;
prim.OwnerMask = (uint)PermissionMask.All;
if (grp == null)
grp = new SceneObjectGroup (prim, null);
else
grp.AddChild (prim, i + 1);
grp.RootPart.IsAttachment = false;
}
if (grp != null) { // unlikely not to have anything but itis possible
if (grp.ChildrenList.Count > 1) //Fix first link #
grp.RootPart.LinkNum++;
Vector3 rootPos = positions [0];
grp.SetAbsolutePosition (false, rootPos);
for (int i = 0; i < positions.Count; i++) {
Vector3 offset = positions [i] - rootPos;
grp.ChildrenList [i].SetOffsetPosition (offset);
}
//grp.Rotation = rotations[0];
for (int i = 0; i < rotations.Count; i++) {
if (i != 0)
grp.ChildrenList [i].SetRotationOffset (false, rotations [i], false);
}
grp.UpdateGroupRotationR (rotations [0]);
data = Encoding.ASCII.GetBytes (grp.ToXml2 ());
}
}
break;
}
AssetBase asset = new AssetBase (assetID, assetName, (AssetType)assType, m_agentID) { Data = data };
asset.ID = m_assetService.Store (asset);
assetID = asset.ID;
InventoryItemBase item = new InventoryItemBase {
Owner = m_agentID,
CreatorId = m_agentID.ToString (),
ID = inventoryItem,
AssetID = asset.ID,
Description = assetDescription,
Name = assetName,
AssetType = assType,
InvType = inType,
Folder = parentFolder,
CurrentPermissions = (uint)PermissionMask.All,
BasePermissions = (uint)PermissionMask.All,
EveryOnePermissions = everyoneMask,
NextPermissions = nextOwnerMask,
GroupPermissions = groupMask,
CreationDate = Util.UnixTimeSinceEpoch ()
};
m_inventoryService.AddItem (item);
return assetID;
}
/// <summary>
/// Update an inventory item with data that has been received through a transaction.
/// This is called when clothing or body parts are updated (for instance, with new textures or
/// colors). It may also be called in other situations.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="transactionID"></param>
/// <param name="item"></param>
public void HandleItemUpdateFromTransaction(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
// MainConsole.Instance.DebugFormat(
// "[TRANSACTIONS MANAGER] Called HandleItemUpdateFromTransaction with item {0}",
// item.Name);
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
IMonitorModule monitorModule = m_scene.RequestModuleInterface<IMonitorModule>();
if (monitorModule != null)
{
INetworkMonitor networkMonitor = monitorModule.GetMonitor<INetworkMonitor>(m_scene);
networkMonitor.AddPendingUploads(1);
}
transactions.RequestUpdateInventoryItem(remoteClient, transactionID, item);
}
/// <summary>
/// Restores an object in world.
/// </summary>
/// <returns>true</returns>
/// <c>false</c>
/// <param name="remoteClient">Remote client.</param>
/// <param name="itemID">Item I.</param>
/// <param name="item">Item.</param>
/// <param name="groupID">Group I.</param>
public virtual bool RezRestoreToWorld(IClientAPI remoteClient, UUID itemID, InventoryItemBase item, UUID groupID)
{
AssetBase rezAsset = m_scene.AssetService.Get(item.AssetID.ToString());
if (rezAsset == null)
{
remoteClient.SendAlertMessage ("Failed to find the item you requested.");
return false;
}
UUID itemId = UUID.Zero;
bool success = false;
XmlDocument doc;
ISceneEntity group = CreateObjectFromInventory(item, remoteClient, itemID, out doc);
bool attachment = (group.IsAttachment || (group.RootChild.Shape.PCode == 9 && group.RootChild.Shape.State != 0));
if (attachment)
{
remoteClient.SendAlertMessage("Inventory item is an attachment, use Wear or Add instead.");
return false;
}
Vector3 pos = group.AbsolutePosition; // maybe .RootPart.GroupPositionNoUpdate;
var rezGroup = RezObject (remoteClient, itemID,
pos, Vector3.Zero, UUID.Zero, 1, true, false, false, UUID.Zero); // NOTE May need taskID from calling llclientview
if (rezGroup != null)
success = true;
if (success && !m_scene.Permissions.BypassPermissions ())
{
//we check the inventory item permissions here instead of the prim permissions
//if the group or item is no copy, it should be removed
if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
{
// Not an attachment and no-copy, so remove inventory copy.
m_scene.AssetService.Delete (itemID);
List<UUID> itemIDs = new List<UUID> { itemId };
m_scene.InventoryService.DeleteItems (remoteClient.AgentId, itemIDs);
}
}
return success;
}
protected virtual ISceneEntity CreateObjectFromInventory(InventoryItemBase item, IClientAPI remoteClient,
UUID itemID, out XmlDocument doc)
{
UUID itemId = UUID.Zero;
// If we have permission to copy then link the rezzed object back to the user inventory
// item that it came from. This allows us to enable 'save object to inventory'
if (!m_scene.Permissions.BypassPermissions())
{
if ((item.CurrentPermissions & (uint) PermissionMask.Copy) == (uint) PermissionMask.Copy)
{
itemId = item.ID;
}
}
else
{
// Brave new fullperm world
//
itemId = item.ID;
}
return CreateObjectFromInventory(remoteClient, itemId, item.AssetID, out doc, item);
}
/// <summary>
/// Checks whether the user has permission to export an inventory item to an IAR.
/// </summary>
/// <param name="UserID">The user</param>
/// <param name="InvItem">The inventory item</param>
/// <returns>Whether the user is allowed to export the object to an IAR</returns>
private bool CanUserArchiveObject(UUID UserID, InventoryItemBase InvItem)
{
if (FilterContent == null || FilterContent == "")
return true;// Default To Allow Export
bool permitted = true;
bool canCopy = (InvItem.CurrentPermissions & (uint)PermissionMask.Copy) != 0;
bool canTransfer = (InvItem.CurrentPermissions & (uint)PermissionMask.Transfer) != 0;
bool canMod = (InvItem.CurrentPermissions & (uint)PermissionMask.Modify) != 0;
if (FilterContent.Contains("C") && !canCopy)
permitted = false;
if (FilterContent.Contains("T") && !canTransfer)
permitted = false;
if (FilterContent.Contains("M") && !canMod)
permitted = false;
return permitted;
}
public void RequestUpdateInventoryItem(IClientAPI remoteClient, InventoryItemBase item)
{
// We must lock to avoid a race with a separate thread uploading the asset.
lock (this)
{
m_asset.Name = item.Name;
m_asset.Description = item.Description;
m_asset.Type = (sbyte) item.AssetType;
// We must always store the item at this point even if the asset hasn't finished uploading, in order
// to avoid a race condition when the appearance module retrieves the item to set the asset id in
// the AvatarAppearance structure.
item.AssetID = m_asset.ID;
if (item.AssetID != UUID.Zero)
m_Scene.InventoryService.UpdateItem(item);
if (m_uploadState == UploadState.Complete)
{
CompleteItemUpdate(item);
}
else
{
// MainConsole.Instance.DebugFormat(
// "[ASSET XFER UPLOADER]: Holding update inventory item request {0} for {1} pending completion of asset xfer for transaction {2}",
// item.Name, remoteClient.Name, transactionID);
m_updateItem = true;
m_updateItemData = item;
}
}
}
public bool BuyObject(IClientAPI remoteClient, UUID categoryID, uint localID, byte saleType)
{
ISceneChildEntity part = m_scene.GetSceneObjectPart(localID);
if (part == null)
return false;
if (part.ParentEntity == null)
return false;
ISceneEntity group = part.ParentEntity;
ILLClientInventory inventoryModule = m_scene.RequestModuleInterface<ILLClientInventory>();
switch (saleType)
{
case 1: // Sell as original (in-place sale)
uint effectivePerms = group.GetEffectivePermissions();
if ((effectivePerms & (uint) PermissionMask.Transfer) == 0)
{
if (m_dialogModule != null)
m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
return false;
}
group.SetOwnerId(remoteClient.AgentId);
group.SetRootPartOwner(part, remoteClient.AgentId, remoteClient.ActiveGroupId);
if (m_scene.Permissions.PropagatePermissions())
{
foreach (ISceneChildEntity child in group.ChildrenEntities())
{
child.Inventory.ChangeInventoryOwner(remoteClient.AgentId);
child.TriggerScriptChangedEvent(Changed.OWNER);
child.ApplyNextOwnerPermissions();
}
}
part.ObjectSaleType = 0;
part.SalePrice = 10;
group.HasGroupChanged = true;
part.GetProperties(remoteClient);
part.TriggerScriptChangedEvent(Changed.OWNER);
group.ResumeScripts();
part.ScheduleUpdate(PrimUpdateFlags.ForcedFullUpdate);
break;
case 2: // Sell a copy
Vector3 inventoryStoredPosition = new Vector3
(((group.AbsolutePosition.X > m_scene.RegionInfo.RegionSizeX)
? m_scene.RegionInfo.RegionSizeX - 1
: group.AbsolutePosition.X)
,
(group.AbsolutePosition.X > m_scene.RegionInfo.RegionSizeY)
? m_scene.RegionInfo.RegionSizeY - 1
: group.AbsolutePosition.X,
group.AbsolutePosition.Z);
Vector3 originalPosition = group.AbsolutePosition;
group.AbsolutePosition = inventoryStoredPosition;
string sceneObjectXml = SceneEntitySerializer.SceneObjectSerializer.ToOriginalXmlFormat(group);
group.AbsolutePosition = originalPosition;
uint perms = group.GetEffectivePermissions();
if ((perms & (uint) PermissionMask.Transfer) == 0)
{
if (m_dialogModule != null)
m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
return false;
}
AssetBase asset = new AssetBase(UUID.Random(), part.Name,
AssetType.Object, group.OwnerID)
{Description = part.Description, Data = Utils.StringToBytes(sceneObjectXml)};
asset.ID = m_scene.AssetService.Store(asset);
InventoryItemBase item = new InventoryItemBase
{
CreatorId = part.CreatorID.ToString(),
CreatorData = part.CreatorData,
ID = UUID.Random(),
Owner = remoteClient.AgentId,
AssetID = asset.ID,
Description = asset.Description,
Name = asset.Name,
AssetType = asset.Type,
InvType = (int) InventoryType.Object,
Folder = categoryID
};
uint nextPerms = (perms & 7) << 13;
if ((nextPerms & (uint) PermissionMask.Copy) == 0)
perms &= ~(uint) PermissionMask.Copy;
if ((nextPerms & (uint) PermissionMask.Transfer) == 0)
perms &= ~(uint) PermissionMask.Transfer;
if ((nextPerms & (uint) PermissionMask.Modify) == 0)
perms &= ~(uint) PermissionMask.Modify;
item.BasePermissions = perms & part.NextOwnerMask;
item.CurrentPermissions = perms & part.NextOwnerMask;
item.NextPermissions = part.NextOwnerMask;
item.EveryOnePermissions = part.EveryoneMask &
part.NextOwnerMask;
item.GroupPermissions = part.GroupMask &
part.NextOwnerMask;
item.CurrentPermissions |= 16; // Slam!
item.CreationDate = Util.UnixTimeSinceEpoch();
m_scene.InventoryService.AddItemAsync(item,
(itm) => remoteClient.SendInventoryItemCreateUpdate(itm, 0));
break;
case 3: // Sell contents
List<UUID> invList = part.Inventory.GetInventoryList();
bool okToSell =
invList.Select(invID => part.Inventory.GetInventoryItem(invID))
.All(item1 => (item1.CurrentPermissions & (uint) PermissionMask.Transfer) != 0);
if (!okToSell)
{
if (m_dialogModule != null)
m_dialogModule.SendAlertToUser(
remoteClient, "This item's inventory doesn't appear to be for sale");
return false;
}
if (invList.Count > 0)
{
if (inventoryModule != null)
inventoryModule.MoveTaskInventoryItemsToUserInventory(remoteClient.AgentId, part.Name, part,
invList);
}
break;
}
return true;
}
/// <summary>
/// Store the asset for the given item when it has been uploaded.
/// </summary>
/// <param name="item"></param>
private void CompleteItemUpdate(InventoryItemBase item)
{
// MainConsole.Instance.DebugFormat(
// "[ASSET XFER UPLOADER]: Storing asset {0} for earlier item update for {1} for {2}",
// m_asset.FullID, item.Name, ourClient.Name);
m_Scene.AssetService.Store(m_asset);
m_transactions.RemoveXferUploader(m_transactionID);
}
/// <summary>
/// Create the calling card inventory item in the user's inventory
/// </summary>
/// <param name="client"></param>
/// <param name="creator"></param>
/// <param name="folder"></param>
/// <param name="name"></param>
public void CreateCallingCard(IClientAPI client, UUID creator, UUID folder, string name)
{
MainConsole.Instance.Debug("[Universe CALLING CARD MODULE]: Creating calling card for " + client.Name);
InventoryItemBase item = new InventoryItemBase
{
AssetID = UUID.Zero,
AssetType = (int) AssetType.CallingCard,
BasePermissions = (uint) (PermissionMask.Copy | PermissionMask.Modify),
CurrentPermissions = (uint) (PermissionMask.Copy | PermissionMask.Modify),
NextPermissions = (uint) PermissionMask.None,
CreationDate = Util.UnixTimeSinceEpoch(),
CreatorId = creator.ToString(),
Description = "",
EveryOnePermissions = (uint) PermissionMask.None,
Flags = 0,
Folder = folder,
GroupID = UUID.Zero,
GroupOwned = false,
ID = UUID.Random(),
InvType = (int) InventoryType.CallingCard,
Name = name,
Owner = client.AgentId,
SalePrice = 10,
SaleType = (byte) SaleType.Not
};
ILLClientInventory inventory = client.Scene.RequestModuleInterface<ILLClientInventory>();
if (inventory != null)
inventory.AddInventoryItemAsync(client, item);
}
public static string Serialize(InventoryItemBase inventoryItem)
{
StringWriter sw = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(sw) {Formatting = Formatting.Indented};
writer.WriteStartDocument();
writer.WriteStartElement("InventoryItem");
writer.WriteStartElement("Name");
writer.WriteString(inventoryItem.Name);
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(inventoryItem.ID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("InvType");
writer.WriteString(inventoryItem.InvType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("CreatorUUID");
writer.WriteString(inventoryItem.CreatorId);
writer.WriteEndElement();
writer.WriteStartElement("CreatorData");
writer.WriteString(inventoryItem.CreatorData);
writer.WriteEndElement();
writer.WriteStartElement("CreationDate");
writer.WriteString(inventoryItem.CreationDate.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Owner");
writer.WriteString(inventoryItem.Owner.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(inventoryItem.Description);
writer.WriteEndElement();
writer.WriteStartElement("AssetType");
writer.WriteString(inventoryItem.AssetType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("AssetID");
writer.WriteString(inventoryItem.AssetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("SaleType");
writer.WriteString(inventoryItem.SaleType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("SalePrice");
writer.WriteString(inventoryItem.SalePrice.ToString());
writer.WriteEndElement();
writer.WriteStartElement("BasePermissions");
writer.WriteString(inventoryItem.BasePermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("CurrentPermissions");
writer.WriteString(inventoryItem.CurrentPermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("EveryOnePermissions");
writer.WriteString(inventoryItem.EveryOnePermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("NextPermissions");
writer.WriteString(inventoryItem.NextPermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Flags");
writer.WriteString(inventoryItem.Flags.ToString());
writer.WriteEndElement();
writer.WriteStartElement("GroupID");
writer.WriteString(inventoryItem.GroupID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("GroupOwned");
writer.WriteString(inventoryItem.GroupOwned.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.Close();
return sw.ToString();
}
List<ISceneEntity> RezMultipleObjectsFromInventory(XmlNodeList nodes, UUID itemId,
IClientAPI remoteClient, Vector3 pos,
bool rezSelected,
InventoryItemBase item, UUID rayTargetID,
byte BypassRayCast, bool rayEndIsIntersection,
Vector3 rayEnd, Vector3 rayStart,
byte bRayEndIsIntersection)
{
Vector3 OldMiddlePos = Vector3.Zero;
List<ISceneEntity> NewGroup = new List<ISceneEntity>();
foreach (XmlNode aPrimNode in nodes)
{
if (aPrimNode.OuterXml.StartsWith("<middle>"))
{
string Position = aPrimNode.OuterXml.Remove(0, 13);
Position = Position.Remove(Position.Length - 16, 16);
string[] XYZ = Position.Split(' ');
OldMiddlePos = new Vector3(float.Parse(XYZ[0]), float.Parse(XYZ[1]), float.Parse(XYZ[2]));
continue;
}
ISceneEntity group
= SceneEntitySerializer.SceneObjectSerializer.FromOriginalXmlFormat(aPrimNode.OuterXml, m_scene);
if (group == null)
return null;
group.IsDeleted = false;
foreach (ISceneChildEntity part in group.ChildrenEntities())
{
part.IsLoading = false;
}
NewGroup.Add(group);
string reason;
if (!m_scene.Permissions.CanRezObject(
group.ChildrenEntities().Count, remoteClient.AgentId, pos, out reason))
{
// The client operates in no fail mode. It will
// have already removed the item from the folder
// if it's no copy.
// Put it back if it's not an attachment
//
if (((item.CurrentPermissions & (uint) PermissionMask.Copy) == 0))
remoteClient.SendBulkUpdateInventory(item);
return null;
}
if (rezSelected)
group.RootChild.AddFlag(PrimFlags.CreateSelected);
// If we're rezzing an attachment then don't ask AddNewSceneObject() to update the client since
// we'll be doing that later on. Scheduling more than one full update during the attachment
// process causes some clients to fail to display the attachment properly.
m_scene.SceneGraph.AddPrimToScene(group);
// MainConsole.Instance.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
// if attachment we set it's asset id so object updates can reflect that
// if not, we set it's position in world.
float offsetHeight = 0;
pos = m_scene.SceneGraph.GetNewRezLocation(
rayStart, rayEnd, rayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true, group.GetAxisAlignedBoundingBox(out offsetHeight), false);
pos.Z += offsetHeight;
//group.AbsolutePosition = pos;
// MainConsole.Instance.InfoFormat("rezx point for inventory rezz is {0} {1} {2} and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
ISceneChildEntity rootPart = group.GetChildPart(group.UUID);
// Since renaming the item in the inventory does not affect the name stored
// in the serialization, transfer the correct name from the inventory to the
// object itself before we rez.
if (NewGroup.Count == 1)
{
//Only do this to the first object, as it is the only one that will need to be renamed
rootPart.Name = item.Name;
rootPart.Description = item.Description;
}
List<ISceneChildEntity> partList = group.ChildrenEntities();
group.SetGroup(remoteClient.ActiveGroupId, remoteClient.AgentId, false);
item.Owner = remoteClient.AgentId;
if (rootPart.OwnerID != item.Owner)
{
//Need to kill the for sale here
rootPart.ObjectSaleType = 0;
rootPart.SalePrice = 10;
if (m_scene.Permissions.PropagatePermissions())
{
if ((item.CurrentPermissions & 8) != 0)
{
foreach (ISceneChildEntity part in partList)
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
group.ApplyNextOwnerPermissions();
}
}
foreach (ISceneChildEntity part in partList)
{
if (part.OwnerID != item.Owner)
{
part.LastOwnerID = part.OwnerID;
part.OwnerID = item.Owner;
part.Inventory.ChangeInventoryOwner(item.Owner);
}
else if ((item.CurrentPermissions & 8) != 0) // Slam!
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
rootPart.TrimPermissions();
if (group.RootChild.Shape.PCode == (byte) PCode.Prim)
group.ClearPartAttachmentData();
// Fire on_rez
group.CreateScriptInstances(0, true, StateSource.NewRez, UUID.Zero, false);
if (!m_scene.Permissions.BypassPermissions())
{
if ((item.CurrentPermissions & (uint) PermissionMask.Copy) == 0)
{
// If this is done on attachments, no
// copy ones will be lost, so avoid it
//
List<UUID> uuids = new List<UUID> {item.ID};
m_scene.InventoryService.DeleteItems(item.Owner, uuids);
}
}
}
foreach (ISceneEntity group in NewGroup)
{
if (OldMiddlePos != Vector3.Zero)
{
Vector3 NewPosOffset = Vector3.Zero;
NewPosOffset.X = group.AbsolutePosition.X - OldMiddlePos.X;
NewPosOffset.Y = group.AbsolutePosition.Y - OldMiddlePos.Y;
NewPosOffset.Z = group.AbsolutePosition.Z - OldMiddlePos.Z;
group.AbsolutePosition = pos + NewPosOffset;
}
group.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
}
return NewGroup;
}
AvatarAppearance CopyWearablesAndAttachments (UUID destination, UUID source,
AvatarAppearance avatarAppearance,
InventoryFolderBase destinationFolder, UUID agentid,
OSDMap itemsMap,
out List<InventoryItemBase> items)
{
items = new List<InventoryItemBase> ();
if (destinationFolder == null) {
MainConsole.Instance.Error ("[Avatar Archiver]: Cannot locate folder(s) for copying wearables!");
return avatarAppearance;
}
List<InventoryItemBase> litems = new List<InventoryItemBase> ();
foreach (KeyValuePair<string, OSD> kvp in itemsMap) {
InventoryItemBase item = new InventoryItemBase ();
item.FromOSD ((OSDMap)kvp.Value);
MainConsole.Instance.Info ("[Avatar Archiver]: Loading item " + item.ID);
litems.Add (item);
}
// Wearables
AvatarWearable [] wearables = avatarAppearance.Wearables;
MainConsole.Instance.InfoFormat ("[Avatar Archiver] Adding {0} wearables", wearables.Length);
for (int i = 0; i < wearables.Length; i++) {
AvatarWearable wearable = wearables [i];
for (int ii = 0; ii < wearable.Count; ii++) {
if (wearable [ii].ItemID != UUID.Zero) {
// Get inventory item and copy it
InventoryItemBase item = inventoryService.GetItem (UUID.Zero, wearable [ii].ItemID);
if (item == null) {
//Attempt to get from the map if it doesn't already exist on the grid
item = litems.First ((itm) => itm.ID == wearable [ii].ItemID);
}
if (item != null) {
InventoryItemBase destinationItem = inventoryService.InnerGiveInventoryItem (destination,
destination,
item,
destinationFolder
.ID,
false, false);
items.Add (destinationItem);
MainConsole.Instance.DebugFormat ("[Avatar Archiver]: Added item {0} to folder {1}",
destinationItem.ID, destinationFolder.ID);
// Wear item
AvatarWearable newWearable = new AvatarWearable ();
newWearable.Wear (destinationItem.ID, destinationItem.AssetID);
avatarAppearance.SetWearable (i, newWearable);
} else {
MainConsole.Instance.WarnFormat ("[Avatar Archiver]: Unable to transfer {0} to folder {1}",
wearable [ii].ItemID, destinationFolder.ID);
}
}
}
}
// Attachments
List<AvatarAttachment> attachments = avatarAppearance.GetAttachments ();
MainConsole.Instance.InfoFormat ("[Avatar Archiver] Adding {0} attachments", attachments.Count);
foreach (AvatarAttachment attachment in attachments) {
int attachpoint = attachment.AttachPoint;
UUID itemID = attachment.ItemID;
if (itemID != UUID.Zero) {
// Get inventory item and copy it
InventoryItemBase item = inventoryService.GetItem (UUID.Zero, itemID);
if (item == null) {
//Attempt to get from the map if it doesn't already exist on the grid
item = litems.First ((itm) => itm.ID == itemID);
}
if (item != null) {
InventoryItemBase destinationItem = inventoryService.InnerGiveInventoryItem (destination,
destination, item,
destinationFolder.ID,
false, false);
items.Add (destinationItem);
MainConsole.Instance.DebugFormat ("[Avatar Archiver]: Added item {0} to folder {1}", destinationItem.ID,
destinationFolder.ID);
// Attach item
avatarAppearance.SetAttachment (attachpoint, destinationItem.ID, destinationItem.AssetID);
MainConsole.Instance.DebugFormat ("[Avatar Archiver]: Attached {0}", destinationItem.ID);
} else {
MainConsole.Instance.WarnFormat ("[Avatar Archiver]: Error transferring {0} to folder {1}", itemID,
destinationFolder.ID);
}
}
}
return avatarAppearance;
}
public virtual ISceneEntity CreateObjectFromInventory(IClientAPI remoteClient, UUID itemID, UUID assetID, InventoryItemBase item)
{
XmlDocument doc;
return CreateObjectFromInventory(remoteClient, itemID, assetID, out doc, item);
}
/// <summary>
/// Update what the avatar is wearing using an item from their inventory.
/// </summary>
/// <param name="client"></param>
/// <param name="e"></param>
public void AvatarIsWearing (IClientAPI client, AvatarWearingArgs e)
{
IScenePresence sp = m_scene.GetScenePresence (client.AgentId);
if (sp == null) {
MainConsole.Instance.WarnFormat ("[AvatarFactory]: AvatarIsWearing unable to find presence for {0}",
client.AgentId);
return;
}
MainConsole.Instance.DebugFormat ("[AvatarFactory]: AvatarIsWearing called for {0}", client.AgentId);
// operate on a copy of the appearance so we don't have to lock anything
IAvatarAppearanceModule appearance = sp.RequestModuleInterface<IAvatarAppearanceModule> ();
AvatarAppearance avatAppearance = new AvatarAppearance (appearance.Appearance, false);
#region Teen Mode Stuff
IOpenRegionSettingsModule module = m_scene.RequestModuleInterface<IOpenRegionSettingsModule> ();
bool NeedsRebake = false;
if (module != null && module.EnableTeenMode) {
foreach (AvatarWearingArgs.Wearable wear in e.NowWearing) {
if (wear.Type == 10 & wear.ItemID == UUID.Zero && module.DefaultUnderpants != UUID.Zero) {
NeedsRebake = true;
wear.ItemID = module.DefaultUnderpants;
InventoryItemBase item = new InventoryItemBase (UUID.Random ()) {
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Underpants",
Folder =
m_scene.InventoryService.GetFolderForType (client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0,
CreatorId = UUID.Zero.ToString (),
AssetID = module.DefaultUnderpants
};
//Locked
client.SendInventoryItemCreateUpdate (item, 0);
} else if (wear.Type == 10 & wear.ItemID == UUID.Zero) {
NeedsRebake = true;
InventoryItemBase item = new InventoryItemBase (UUID.Random ()) {
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Underpants",
Folder =
m_scene.InventoryService.GetFolderForType (client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0
};
//Locked
if (m_underPantsUUID == UUID.Zero) {
m_underPantsUUID = UUID.Random ();
AssetBase asset = new AssetBase (m_underPantsUUID, "Default Underpants", AssetType.Clothing,
UUID.Zero) { Data = Utils.StringToBytes (m_defaultUnderPants) };
asset.ID = m_scene.AssetService.Store (asset);
m_underPantsUUID = asset.ID;
}
item.CreatorId = UUID.Zero.ToString ();
item.AssetID = m_underPantsUUID;
m_scene.InventoryService.AddItemAsync (item, null);
client.SendInventoryItemCreateUpdate (item, 0);
wear.ItemID = item.ID;
}
if (wear.Type == 11 && wear.ItemID == UUID.Zero && module.DefaultUndershirt != UUID.Zero) {
NeedsRebake = true;
wear.ItemID = module.DefaultUndershirt;
InventoryItemBase item = new InventoryItemBase (UUID.Random ()) {
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Undershirt",
Folder =
m_scene.InventoryService.GetFolderForType (client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0,
CreatorId = UUID.Zero.ToString (),
AssetID = module.DefaultUndershirt
};
//Locked
client.SendInventoryItemCreateUpdate (item, 0);
} else if (wear.Type == 11 & wear.ItemID == UUID.Zero) {
NeedsRebake = true;
InventoryItemBase item = new InventoryItemBase (UUID.Random ()) {
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Undershirt",
Folder =
m_scene.InventoryService.GetFolderForType (client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0
};
//Locked
if (m_underShirtUUID == UUID.Zero) {
m_underShirtUUID = UUID.Random ();
AssetBase asset = new AssetBase (m_underShirtUUID, "Default Undershirt", AssetType.Clothing,
UUID.Zero) { Data = Utils.StringToBytes (m_defaultUnderShirt) };
asset.ID = m_scene.AssetService.Store (asset);
m_underShirtUUID = asset.ID;
}
item.CreatorId = UUID.Zero.ToString ();
item.AssetID = m_underShirtUUID;
m_scene.InventoryService.AddItemAsync (item, null);
client.SendInventoryItemCreateUpdate (item, 0);
wear.ItemID = item.ID;
}
}
}
#endregion
foreach (
AvatarWearingArgs.Wearable wear in e.NowWearing.Where (wear => wear.Type < AvatarWearable.MAX_WEARABLES)) {
avatAppearance.Wearables [wear.Type].Add (wear.ItemID, UUID.Zero);
}
avatAppearance.GetAssetsFrom (appearance.Appearance);
// This could take awhile since it needs to pull inventory
SetAppearanceAssets (sp.UUID, e.NowWearing, appearance.Appearance, ref avatAppearance);
// could get fancier with the locks here, but in the spirit of "last write wins"
// this should work correctly, also, we don't need to send the appearance here
// since the "iswearing" will trigger a new set of visual param and baked texture changes
// when those complete, the new appearance will be sent
appearance.Appearance = avatAppearance;
//This only occurs if something has been forced on afterwards (teen mode stuff)
if (NeedsRebake) {
//Tell the client about the new things it is wearing
sp.ControllingClient.SendWearables (appearance.Appearance.Wearables, appearance.Appearance.Serial);
//Then forcefully tell it to rebake
foreach (
Primitive.TextureEntryFace face in
appearance.Appearance.Texture.FaceTextures.Select (t => (t)).Where (face => face != null)) {
sp.ControllingClient.SendRebakeAvatarTextures (face.TextureID);
}
}
QueueAppearanceSave (sp.UUID);
//Send the wearables HERE so that the client knows what it is wearing
//sp.ControllingClient.SendWearables(sp.Appearance.Wearables, sp.Appearance.Serial);
//Do not save or send the appearance! The client loops back and sends a bunch of SetAppearance
// (handled above) and that takes care of it
}
/// <summary>
/// Delete a scene object from a scene and place in the given avatar's inventory.
/// Returns the UUID of the newly created asset.
/// </summary>
/// <param name="action"></param>
/// <param name="folderID"></param>
/// <param name="objectGroups"></param>
/// <param name="agentId"></param>
/// <param name="itemID"></param>
public virtual UUID DeleteToInventory(DeRezAction action, UUID folderID,
List<ISceneEntity> objectGroups, UUID agentId, out UUID itemID)
{
itemID = UUID.Zero;
if (objectGroups.Count == 0)
return UUID.Zero;
// Get the user info of the item destination
//
IScenePresence SP = m_scene.GetScenePresence(agentId);
UUID userID = UUID.Zero;
if (action == DeRezAction.Take || action == DeRezAction.AcquireToUserInventory ||
action == DeRezAction.SaveToExistingUserInventoryItem)
{
// Take or take copy require a taker
// Saving changes requires a local user
//
if (SP == null || SP.ControllingClient == null)
return UUID.Zero;
userID = agentId;
}
else
{
// All returns / deletes go to the object owner
//
userID = objectGroups[0].OwnerID;
}
if (userID == UUID.Zero) // Can't proceed
{
return UUID.Zero;
}
// If we're returning someone's item, it goes back to the
// owner's Lost And Found folder.
// Delete is treated like return in this case
// Deleting your own items makes them go to trash
//
InventoryFolderBase folder = null;
InventoryItemBase item;
if (DeRezAction.SaveToExistingUserInventoryItem == action)
{
item = m_scene.InventoryService.GetItem(userID, objectGroups[0].RootChild.FromUserInventoryItemID);
//item = userInfo.RootFolder.FindItem(
// objectGroup.RootPart.FromUserInventoryItemID);
if (item == null)
{
MainConsole.Instance.DebugFormat(
"[Agent inventory]: Object {0} {1} scheduled for save to inventory has already been deleted.",
objectGroups[0].Name, objectGroups[0].UUID);
return UUID.Zero;
}
}
else
{
// Folder magic
//
if (action == DeRezAction.Delete)
{
// Deleting someone else's item
//
if (SP == null || SP.ControllingClient == null ||
objectGroups[0].OwnerID != agentId)
{
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.LostAndFound);
}
else
{
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.Trash);
}
}
else if (action == DeRezAction.Return)
{
// Dump to lost + found unconditionally
//
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.LostAndFound);
}
if (folderID == UUID.Zero && folder == null)
{
if (action == DeRezAction.Delete)
{
// Deletes go to trash by default
//
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.Trash);
}
else
{
if (SP == null || SP.ControllingClient == null ||
objectGroups[0].OwnerID != agentId)
{
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.LostAndFound);
}
else
{
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Unknown, FolderType.Trash);
}
}
}
// Override and put into where it came from, if it came
// from anywhere in inventory
//
if (action == DeRezAction.Attachment || action == DeRezAction.Take ||
action == DeRezAction.AcquireToUserInventory)
{
if (objectGroups[0].RootChild.FromUserInventoryItemID != UUID.Zero)
{
InventoryFolderBase f =
new InventoryFolderBase(objectGroups[0].RootChild.FromUserInventoryItemID, userID);
folder = m_scene.InventoryService.GetFolder(f);
}
else
{
folder = m_scene.InventoryService.GetFolderForType(userID, InventoryType.Object, FolderType.Object);
}
}
if (folder == null) // None of the above
{
folder = new InventoryFolderBase(folderID);
}
item = new InventoryItemBase
{
CreatorId = objectGroups[0].RootChild.CreatorID.ToString(),
ID = UUID.Random(),
InvType = (int) InventoryType.Object,
Folder = folder.ID,
Owner = userID
};
}
AssetBase asset;
UUID assetID = SaveAsAsset(objectGroups, out asset);
item.AssetID = assetID;
if (DeRezAction.SaveToExistingUserInventoryItem != action)
{
item.Description = asset.Description;
item.Name = asset.Name;
item.AssetType = asset.Type;
}
if (DeRezAction.SaveToExistingUserInventoryItem == action)
{
m_scene.InventoryService.UpdateItem(item);
}
else
{
if (SP != null && SP.ControllingClient != null &&
(SP.ControllingClient.AgentId != objectGroups[0].OwnerID) &&
m_scene.Permissions.PropagatePermissions())
{
foreach (ISceneEntity group in objectGroups)
{
uint perms = group.GetEffectivePermissions();
uint nextPerms = (perms & 7) << 13;
if ((nextPerms & (uint) PermissionMask.Copy) == 0)
perms &= ~(uint) PermissionMask.Copy;
if ((nextPerms & (uint) PermissionMask.Transfer) == 0)
perms &= ~(uint) PermissionMask.Transfer;
if ((nextPerms & (uint) PermissionMask.Modify) == 0)
perms &= ~(uint) PermissionMask.Modify;
// Make sure all bits but the ones we want are clear
// on take.
// This will be applied to the current perms, so
// it will do what we want.
group.RootChild.NextOwnerMask &=
((uint) PermissionMask.Copy |
(uint) PermissionMask.Transfer |
(uint) PermissionMask.Modify);
group.RootChild.NextOwnerMask |=
(uint) PermissionMask.Move;
item.BasePermissions = perms & group.RootChild.NextOwnerMask;
item.CurrentPermissions = item.BasePermissions;
item.NextPermissions = group.RootChild.NextOwnerMask;
item.EveryOnePermissions = group.RootChild.EveryoneMask & group.RootChild.NextOwnerMask;
item.GroupPermissions = group.RootChild.GroupMask & group.RootChild.NextOwnerMask;
// Magic number badness. Maybe this deserves an Enum.
// bit 4 (16) is the "Slam" bit, it means treat as passed
// and apply next owner perms on rez
item.CurrentPermissions |= 16; // Slam!
item.SalePrice = group.RootChild.SalePrice;
item.SaleType = group.RootChild.ObjectSaleType;
}
}
else
{
foreach (ISceneEntity group in objectGroups)
{
item.BasePermissions = group.GetEffectivePermissions();
item.CurrentPermissions = group.GetEffectivePermissions();
item.NextPermissions = group.RootChild.NextOwnerMask;
item.EveryOnePermissions = group.RootChild.EveryoneMask;
item.GroupPermissions = group.RootChild.GroupMask;
item.SalePrice = group.RootChild.SalePrice;
item.SaleType = group.RootChild.ObjectSaleType;
item.CurrentPermissions &=
((uint) PermissionMask.Copy |
(uint) PermissionMask.Transfer |
(uint) PermissionMask.Modify |
(uint) PermissionMask.Move |
7); // Preserve folded permissions
}
}
if (objectGroups.Count != 1)
item.Flags |= (uint) InventoryItemFlags.ObjectHasMultipleItems;
item.CreationDate = Util.UnixTimeSinceEpoch();
m_LLCLientInventoryModule.AddInventoryItem(item);
if (SP != null && SP.ControllingClient != null && item.Owner == SP.ControllingClient.AgentId)
{
SP.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
IScenePresence notifyUser = m_scene.GetScenePresence(item.Owner);
if (notifyUser != null)
{
notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
}
}
itemID = item.ID;
return assetID;
}
List<InventoryItemBase> ParseInventoryItems(IDataReader retVal)
{
List<InventoryItemBase> items = new List<InventoryItemBase>();
while (retVal.Read())
{
InventoryItemBase item = new InventoryItemBase {
AssetID = UUID.Parse (retVal ["assetID"].ToString ()),
AssetType = int.Parse (retVal ["assetType"].ToString ()),
Name = retVal ["inventoryName"].ToString (),
Description = retVal ["inventoryDescription"].ToString (),
NextPermissions = uint.Parse (retVal ["inventoryNextPermissions"].ToString ()),
CurrentPermissions = uint.Parse (retVal ["inventoryCurrentPermissions"].ToString ()),
InvType = int.Parse (retVal ["invType"].ToString ()),
CreatorIdentification = retVal ["creatorID"].ToString (),
BasePermissions = uint.Parse (retVal ["inventoryBasePermissions"].ToString ()),
EveryOnePermissions = uint.Parse (retVal ["inventoryEveryOnePermissions"].ToString ()),
SalePrice = int.Parse (retVal ["salePrice"].ToString ()),
SaleType = byte.Parse (retVal ["saleType"].ToString ()),
CreationDate = int.Parse (retVal ["creationDate"].ToString ()),
GroupID = UUID.Parse (retVal ["groupID"].ToString ()),
GroupOwned = int.Parse (retVal ["groupOwned"].ToString ()) == 1,
Flags = uint.Parse (retVal ["flags"].ToString ()),
ID = UUID.Parse (retVal ["inventoryID"].ToString ()),
Owner = UUID.Parse (retVal ["avatarID"].ToString ()),
Folder = UUID.Parse (retVal ["parentFolderID"].ToString ()),
GroupPermissions = uint.Parse (retVal ["inventoryGroupPermissions"].ToString ())
};
if (item.InvType == -1)
{
//Fix the bad invType
item.InvType = 0;
StoreItem(item);
}
items.Add(item);
}
return items;
}
/// <summary>
/// Rez an object into the scene from the user's inventory
/// </summary>
/// FIXME: It would be really nice if inventory access modules didn't also actually do the work of rezzing
/// things to the scene. The caller should be doing that, I think.
/// <param name="remoteClient"></param>
/// <param name="itemID"></param>
/// <param name="rayEnd"></param>
/// <param name="rayStart"></param>
/// <param name="rayTargetID"></param>
/// <param name="bypassRayCast"></param>
/// <param name="rayEndIsIntersection"></param>
/// <param name="rezSelected"></param>
/// <param name="removeItem"></param>
/// <param name="fromTaskID"></param>
/// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful.</returns>
public virtual ISceneEntity RezObject(IClientAPI remoteClient, UUID itemID, Vector3 rayEnd, Vector3 rayStart,
UUID rayTargetID, byte bypassRayCast, bool rayEndIsIntersection,
bool rezSelected, bool removeItem, UUID fromTaskID)
{
// Work out position details
byte bRayEndIsIntersection;
bRayEndIsIntersection = (byte) (rayEndIsIntersection ? 1 : 0);
XmlDocument doc;
//It might be a library item, send UUID.Zero
InventoryItemBase item = m_scene.InventoryService.GetItem(UUID.Zero, itemID);
if (item == null)
{
remoteClient.SendAlertMessage("Failed to find the item you requested.");
return null;
}
ISceneEntity group = CreateObjectFromInventory(item, remoteClient, itemID, out doc);
Vector3 pos = m_scene.SceneGraph.GetNewRezLocation(
rayStart, rayEnd, rayTargetID, Quaternion.Identity,
bypassRayCast, bRayEndIsIntersection, true, new Vector3(0.5f, 0.5f, 0.5f), false);
if (doc == null)
{
//No asset, check task inventory
IEntity e;
m_scene.SceneGraph.TryGetEntity(fromTaskID, out e);
if (e != null && e is ISceneEntity)
{
ISceneEntity grp = (ISceneEntity) e;
TaskInventoryItem taskItem = grp.RootChild.Inventory.GetInventoryItem(itemID);
item = new InventoryItemBase
{
ID = UUID.Random(),
CreatorId = taskItem.CreatorID.ToString(),
Owner = remoteClient.AgentId,
AssetID = taskItem.AssetID,
Description = taskItem.Description,
Name = taskItem.Name,
AssetType = taskItem.Type,
InvType = taskItem.InvType,
Flags = taskItem.Flags,
SalePrice = taskItem.SalePrice,
SaleType = taskItem.SaleType
};
if (m_scene.Permissions.PropagatePermissions())
{
item.BasePermissions = taskItem.BasePermissions &
(taskItem.NextPermissions | (uint) PermissionMask.Move);
if (taskItem.InvType == (int) InventoryType.Object)
item.CurrentPermissions = item.BasePermissions &
(((taskItem.CurrentPermissions & 7) << 13) |
(taskItem.CurrentPermissions & (uint) PermissionMask.Move));
else
item.CurrentPermissions = item.BasePermissions & taskItem.CurrentPermissions;
item.CurrentPermissions |= 16; // Slam
item.NextPermissions = taskItem.NextPermissions;
item.EveryOnePermissions = taskItem.EveryonePermissions &
(taskItem.NextPermissions | (uint) PermissionMask.Move);
item.GroupPermissions = taskItem.GroupPermissions & taskItem.NextPermissions;
}
else
{
item.BasePermissions = taskItem.BasePermissions;
item.CurrentPermissions = taskItem.CurrentPermissions;
item.NextPermissions = taskItem.NextPermissions;
item.EveryOnePermissions = taskItem.EveryonePermissions;
item.GroupPermissions = taskItem.GroupPermissions;
}
group = CreateObjectFromInventory(item, remoteClient, itemID, out doc);
}
}
if (group == null && doc != null && doc.FirstChild != null &&
(doc.FirstChild.OuterXml.StartsWith("<groups>") ||
(doc.FirstChild.NextSibling != null &&
doc.FirstChild.NextSibling.OuterXml.StartsWith("<groups>"))))
{
XmlNodeList nodes;
if (doc.FirstChild.OuterXml.StartsWith("<groups>")) nodes = doc.FirstChild.ChildNodes;
else if (doc.FirstChild.NextSibling != null) nodes = doc.FirstChild.NextSibling.ChildNodes;
else
{
remoteClient.SendAlertMessage("Failed to find the item you requested.");
return null;
}
List<ISceneEntity> Groups = RezMultipleObjectsFromInventory(nodes, itemID, remoteClient, pos,
rezSelected, item, rayTargetID,
bypassRayCast, rayEndIsIntersection, rayEnd,
rayStart, bRayEndIsIntersection);
if (Groups.Count != 0)
return Groups[0];
remoteClient.SendAlertMessage("Failed to rez the item you requested.");
return null;
}
if (group == null)
{
remoteClient.SendAlertMessage("Failed to find the item you requested.");
return null;
}
string reason;
if (!m_scene.Permissions.CanRezObject(
group.ChildrenEntities().Count, remoteClient.AgentId, pos, out reason))
{
// The client operates in no fail mode. It will
// have already removed the item from the folder
// if it's no copy.
// Put it back if it's not an attachment
//
if ((item.CurrentPermissions & (uint) PermissionMask.Copy) == 0)
remoteClient.SendBulkUpdateInventory(item);
remoteClient.SendAlertMessage("You do not have permission to rez objects here.");
return null;
}
if (rezSelected)
group.RootChild.AddFlag(PrimFlags.CreateSelected);
// If we're rezzing an attachment then don't ask AddNewSceneObject() to update the client since
// we'll be doing that later on. Scheduling more than one full update during the attachment
// process causes some clients to fail to display the attachment properly.
m_scene.SceneGraph.AddPrimToScene(group);
// MainConsole.Instance.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
// Set it's position in world.
const float offsetHeight = 0;
//The OOBsize is only half the size, x2
Vector3 newSize = (group.OOBsize*2)*Quaternion.Inverse(group.GroupRotation);
pos = m_scene.SceneGraph.GetNewRezLocation(
rayStart, rayEnd, rayTargetID, Quaternion.Identity,
bypassRayCast, bRayEndIsIntersection, true, newSize, false);
pos.Z += offsetHeight;
group.AbsolutePosition = pos;
// MainConsole.Instance.InfoFormat("rezx point for inventory rezz is {0} {1} {2} and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
ISceneChildEntity rootPart = group.GetChildPart(group.UUID);
if (rootPart == null)
{
MainConsole.Instance.Error("[Agent inventory]: Error rezzing ItemID: " + itemID +
" object has no rootpart.");
return null;
}
// Since renaming the item in the inventory does not affect the name stored
// in the serialization, transfer the correct name from the inventory to the
// object itself before we rez.
rootPart.Name = item.Name;
rootPart.Description = item.Description;
List<ISceneChildEntity> partList = group.ChildrenEntities();
group.SetGroup(remoteClient.ActiveGroupId, remoteClient.AgentId, false);
item.Owner = remoteClient.AgentId;
if (rootPart.OwnerID != item.Owner)
{
//Need to kill the for sale here
rootPart.ObjectSaleType = 0;
rootPart.SalePrice = 10;
if (m_scene.Permissions.PropagatePermissions())
{
if ((item.CurrentPermissions & 8) != 0)
{
foreach (ISceneChildEntity part in partList)
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
group.ApplyNextOwnerPermissions();
}
}
foreach (ISceneChildEntity part in partList)
{
if (part.OwnerID != item.Owner)
{
part.LastOwnerID = part.OwnerID;
part.OwnerID = item.Owner;
part.Inventory.ChangeInventoryOwner(item.Owner);
}
else if ((item.CurrentPermissions & 8) != 0) // Slam!
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
rootPart.TrimPermissions();
if (group.RootChild.Shape.PCode == (byte) PCode.Prim)
{
group.ClearPartAttachmentData();
}
// Fire on_rez
group.CreateScriptInstances(0, true, StateSource.NewRez, UUID.Zero, false);
group.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
if (!m_scene.Permissions.BypassPermissions())
{
if ((item.CurrentPermissions & (uint) PermissionMask.Copy) == 0)
{
List<UUID> uuids = new List<UUID> {item.ID};
m_scene.InventoryService.DeleteItems(item.Owner, uuids);
}
}
return group;
}
