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; }