private void DeleteItem(TreeNode node)
{
if (node == null)
{
return;
}
InventoryBase io = (InventoryBase)node.Tag;
if (io is InventoryFolder)
{
InventoryFolder folder = (InventoryFolder)io;
//treeLookup.Remove(folder.UUID);
client.Inventory.RemoveFolder(folder.UUID);
folder = null;
}
else if (io is InventoryItem)
{
InventoryItem item = (InventoryItem)io;
//treeLookup.Remove(item.UUID);
client.Inventory.RemoveItem(item.UUID);
item = null;
}
io = null;
node.Remove();
node = null;
}
public static InventoryFolder[] ParseInventoryFolders(string key, UUID owner, LLSDMap reply)
{
List <InventoryFolder> folders = new List <InventoryFolder>();
LLSD skeleton;
if (reply.TryGetValue(key, out skeleton) && skeleton.Type == LLSDType.Array)
{
LLSDArray array = (LLSDArray)skeleton;
for (int i = 0; i < array.Count; i++)
{
if (array[i].Type == LLSDType.Map)
{
LLSDMap map = (LLSDMap)array[i];
InventoryFolder folder = new InventoryFolder(map["folder_id"].AsUUID());
folder.PreferredType = (AssetType)map["type_default"].AsInteger();
folder.Version = map["version"].AsInteger();
folder.OwnerID = owner;
folder.ParentUUID = map["parent_id"].AsUUID();
folder.Name = map["name"].AsString();
folders.Add(folder);
}
}
}
return(folders.ToArray());
}
public void TestFindFolderForType()
{
var owner = Guid.NewGuid();
InventoryFolder folder1 = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.TopLevel,
Name = "Test1",
OwnerId = owner,
ParentId = Guid.Empty,
Type = 2
};
InventoryFolder folder2 = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.TopLevel,
Name = "Test2",
OwnerId = owner,
ParentId = Guid.Empty,
Type = 3
};
_storage.CreateFolder(folder1);
_storage.CreateFolder(folder2);
Assert.AreEqual(folder1.FolderId, _storage.FindFolderForType(owner, 2).FolderId);
}
void Inventory_FolderUpdated(object sender, FolderUpdatedEventArgs e)
{
if (COF == null)
{
return;
}
if (e.FolderID == COF.UUID && e.Success)
{
COF = (InventoryFolder)Client.Inventory.Store[COF.UUID];
lock (FolderSync)
{
lock (Content) Content.Clear();
List <UUID> items = new List <UUID>();
List <UUID> owners = new List <UUID>();
foreach (var link in ContentLinks())
{
//if (Client.Inventory.Store.Contains(link.AssetUUID))
//{
// continue;
//}
items.Add(link.AssetUUID);
owners.Add(Client.Self.AgentID);
}
if (items.Count > 0)
{
Client.Inventory.RequestFetchInventory(items, owners);
}
}
}
}
public UUID CopyFolder(InventoryFolder folder, UUID destination)
{
UUID newFolderID = CreateFolder(destination, folder.Name, folder.PreferredType);
//var newFolder = (InventoryFolder)Store[newFolderID];
var items = FetchFolder(folder);
foreach (var item in items)
{
if (item is InventoryItem)
{
AutoResetEvent itemCopied = new AutoResetEvent(false);
Client.Inventory.RequestCopyItem(item.UUID, newFolderID, item.Name, item.OwnerID, (newItem) =>
{
itemCopied.Set();
});
if (itemCopied.WaitOne(20 * 1000, false))
{
Logger.Log("Copied item " + item.Name, Helpers.LogLevel.Info);
}
else
{
Logger.Log("Failed to copy item " + item.Name, Helpers.LogLevel.Warning);
}
}
else if (item is InventoryFolder)
{
CopyFolder((InventoryFolder)item, newFolderID);
}
}
return(newFolderID);
}
public void TestCreateAndReadFolder()
{
InventoryFolder folder = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = Guid.NewGuid(),
ParentId = Guid.Empty,
Type = 2
};
_storage.CreateFolder(folder);
var copy = _storage.GetFolderAttributes(folder.FolderId);
Assert.AreEqual(folder.FolderId, copy.FolderId);
//note that level is a property of the skel and GetFolderAttributes doesnt load it
Assert.AreEqual(folder.Name, copy.Name);
Assert.AreEqual(folder.OwnerId, copy.OwnerId);
Assert.AreEqual(folder.ParentId, copy.ParentId);
Assert.AreEqual(folder.Type, copy.Type);
//get the skel for this user to check the level and version
var skel = _storage.GetInventorySkeleton(folder.OwnerId);
Assert.AreEqual(1, skel.Count);
Assert.AreEqual(1, skel[0].Version);
Assert.AreEqual(folder.Level, skel[0].Level);
Assert.AreEqual(folder.Name, skel[0].Name);
Assert.AreEqual(folder.ParentId, skel[0].ParentId);
Assert.AreEqual(folder.Type, skel[0].Type);
}
/// <summary>
/// Updates the state of the InventoryNode and inventory data structure that
/// is responsible for the InventoryObject. If the item was previously not added to inventory,
/// it adds the item, and updates structure accordingly. If it was, it updates the
/// InventoryNode, changing the parent node if <code>item.parentUUID</code> does
/// not match <code>node.Parent.Data.UUID</code>.
///
/// You can not set the inventory root folder using this method
/// </summary>
/// <param name="item">The InventoryObject to store</param>
public void UpdateNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode itemParent = null;
if (item.ParentUUID != UUID.Zero && !Items.TryGetValue(item.ParentUUID, out itemParent))
{
// OK, we have no data on the parent, let's create a fake one.
InventoryFolder fakeParent = new InventoryFolder(item.ParentUUID);
fakeParent.DescendentCount = 1; // Dear god, please forgive me.
itemParent = new InventoryNode(fakeParent);
Items[item.ParentUUID] = itemParent;
// Unfortunately, this breaks the nice unified tree
// while we're waiting for the parent's data to come in.
// As soon as we get the parent, the tree repairs itself.
Console.WriteLine("Attempting to update inventory child of " +
item.ParentUUID.ToString() + " when we have no local reference to that folder");
if (true)
{
// Fetch the parent
List <UUID> fetchreq = new List <UUID>(1);
fetchreq.Add(item.ParentUUID);
//Manager.FetchInventory(fetchreq); // we cant fetch folder data! :-O
}
}
InventoryNode itemNode;
if (Items.TryGetValue(item.UUID, out itemNode)) // We're updating.
{
InventoryNode oldParent = itemNode.Parent;
// Handle parent change
if (oldParent == null || itemParent == null || itemParent.Data.UUID != oldParent.Data.UUID)
{
if (oldParent != null)
{
lock (oldParent.Nodes.SyncRoot)
oldParent.Nodes.Remove(item.UUID);
}
if (itemParent != null)
{
lock (itemParent.Nodes.SyncRoot)
itemParent.Nodes[item.UUID] = itemNode;
}
}
itemNode.Parent = itemParent;
itemNode.Data = item;
}
else // We're adding.
{
itemNode = new InventoryNode(item, itemParent);
Items.Add(item.UUID, itemNode);
}
}
}
private void btnDecline_Click(object sender, EventArgs e)
{
try
{
//UUID invfolder = client.Inventory.FindFolderForType(invtype);
UUID invfolder = UUID.Zero;
if (invtype == AssetType.Folder)
{
instance.State.FolderRcvd = true;
invfolder = client.Inventory.Store.RootFolder.UUID;
}
else
{
instance.State.FolderRcvd = false;
invfolder = client.Inventory.FindFolderForType(invtype);
}
if (diag == InstantMessageDialog.InventoryOffered)
{
client.Self.InstantMessage(client.Self.Name, msg.FromAgentID, string.Empty, msg.IMSessionID, InstantMessageDialog.InventoryDeclined, InstantMessageOnline.Offline, instance.SIMsittingPos(), client.Network.CurrentSim.RegionID, invfolder.GetBytes()); // Decline Inventory Offer
try
{
//client.Inventory.RemoveItem(objectID);
//client.Inventory.RequestFetchInventory(objectID, client.Self.AgentID);
InventoryBase item = client.Inventory.Store.Items[objectID].Data;
UUID content = client.Inventory.FindFolderForType(AssetType.TrashFolder);
InventoryFolder folder = (InventoryFolder)client.Inventory.Store.Items[content].Data;
if (invtype != AssetType.Folder)
{
client.Inventory.Move(item, folder, item.Name);
}
else
{
client.Inventory.MoveFolder(objectID, content, item.Name);
}
}
catch {; }
}
else if (diag == InstantMessageDialog.TaskInventoryOffered)
{
client.Self.InstantMessage(client.Self.Name, msg.FromAgentID, string.Empty, msg.IMSessionID, InstantMessageDialog.TaskInventoryDeclined, InstantMessageOnline.Offline, instance.SIMsittingPos(), client.Network.CurrentSim.RegionID, invfolder.GetBytes()); // Decline Inventory Offer
}
timer1.Stop();
timer1.Enabled = false;
}
catch
{
;
}
this.Close();
}
public override CmdResult ExecuteRequest(CmdRequest args)
{
if (args.Length > 1)
{
return(ShowUsage()); // " ls [-l]";
}
bool longDisplay = false;
if (args.Length > 0 && args[0] == "-l")
{
longDisplay = true;
}
Manager = Client.Inventory;
Inventory = Manager.Store;
// WARNING: Uses local copy of inventory contents, need to download them first.
List <InventoryBase> contents = Inventory.GetContents(TheBotClient.CurrentDirectory);
string displayString = "";
string nl = "\n"; // New line character
// Pretty simple, just print out the contents.
foreach (InventoryBase b in contents)
{
if (longDisplay)
{
// Generate a nicely formatted description of the item.
// It kinda looks like the WriteLine of the unix ls.
// starts with 'd' if the inventory is a folder, '-' if not.
// 9 character permissions string
// UUID of object
// Name of object
if (b is InventoryFolder)
{
InventoryFolder folder = b as InventoryFolder;
displayString += "d--------- ";
displayString += folder.UUID;
displayString += " " + folder.Name;
}
else if (b is InventoryItem)
{
InventoryItem item = b as InventoryItem;
displayString += "-";
displayString += PermMaskString(item.Permissions.OwnerMask);
displayString += PermMaskString(item.Permissions.GroupMask);
displayString += PermMaskString(item.Permissions.EveryoneMask);
displayString += " " + item.UUID;
displayString += " " + item.Name;
displayString += nl;
displayString += " AssetID: " + item.AssetUUID;
}
}
else
{
displayString += b.Name;
}
displayString += nl;
}
return(Success(displayString));
}
private Dictionary <UUID, InventoryBase> CreateInventory(UUID ownerID, out InventoryFolder rootFolder)
{
Dictionary <UUID, InventoryBase> inventory = new Dictionary <UUID, InventoryBase>();
// Create a default inventory
UUID rootFolderID = CreateFolder(inventory, UUID.Zero, "My Inventory", "application/vnd.ll.folder", ownerID);
rootFolder = (InventoryFolder)inventory[rootFolderID];
CreateFolder(inventory, rootFolderID, "Animations", "application/vnd.ll.animation", ownerID);
CreateFolder(inventory, rootFolderID, "Body Parts", "application/vnd.ll.bodypart", ownerID);
CreateFolder(inventory, rootFolderID, "Calling Cards", "application/vnd.ll.callingcard", ownerID);
CreateFolder(inventory, rootFolderID, "Gestures", "application/vnd.ll.gesture", ownerID);
CreateFolder(inventory, rootFolderID, "Landmarks", "application/vnd.ll.landmark", ownerID);
CreateFolder(inventory, rootFolderID, "Lost and Found", "application/vnd.ll.lostandfoundfolder", ownerID);
CreateFolder(inventory, rootFolderID, "Notecards", "application/vnd.ll.notecard", ownerID);
CreateFolder(inventory, rootFolderID, "Objects", "application/vnd.ll.primitive", ownerID);
CreateFolder(inventory, rootFolderID, "Photo Album", "application/vnd.ll.snapshotfolder", ownerID);
CreateFolder(inventory, rootFolderID, "Scripts", "application/vnd.ll.lsltext", ownerID);
CreateFolder(inventory, rootFolderID, "Sounds", "audio/ogg", ownerID);
CreateFolder(inventory, rootFolderID, "Textures", "image/x-j2c", ownerID);
CreateFolder(inventory, rootFolderID, "Trash", "application/vnd.ll.trashfolder", ownerID);
UUID clothingFolder = CreateFolder(inventory, rootFolderID, "Clothing", "application/vnd.ll.clothing", ownerID);
UUID outfitFolder = CreateFolder(inventory, clothingFolder, "Default Outfit", "application/octet-stream", ownerID);
UUID hairItem = CreateItem(inventory, outfitFolder, "Default Hair", "Default Hair", WearableType.Hair, HAIR_ASSET, "application/vnd.ll.bodypart", ownerID);
UUID pantsItem = CreateItem(inventory, outfitFolder, "Default Pants", "Default Pants", WearableType.Pants, PANTS_ASSET, "application/vnd.ll.clothing", ownerID);
UUID shapeItem = CreateItem(inventory, outfitFolder, "Default Shape", "Default Shape", WearableType.Shape, SHAPE_ASSET, "application/vnd.ll.bodypart", ownerID);
UUID shirtItem = CreateItem(inventory, outfitFolder, "Default Shirt", "Default Shirt", WearableType.Shirt, SHIRT_ASSET, "application/vnd.ll.clothing", ownerID);
UUID skinItem = CreateItem(inventory, outfitFolder, "Default Skin", "Default Skin", WearableType.Skin, SKIN_ASSET, "application/vnd.ll.bodypart", ownerID);
UUID eyesItem = CreateItem(inventory, outfitFolder, "Default Eyes", "Default Eyes", WearableType.Eyes, EYES_ASSET, "application/vnd.ll.bodypart", ownerID);
if (m_userClient != null)
{
OSDMap appearanceMap = new OSDMap
{
{ "Height", OSD.FromReal(1.771488d) },
{ "ShapeItem", OSD.FromUUID(shapeItem) },
{ "ShapeAsset", OSD.FromUUID(SHAPE_ASSET) },
{ "EyesItem", OSD.FromUUID(eyesItem) },
{ "EyesAsset", OSD.FromUUID(EYES_ASSET) },
{ "HairItem", OSD.FromUUID(hairItem) },
{ "HairAsset", OSD.FromUUID(HAIR_ASSET) },
{ "PantsItem", OSD.FromUUID(pantsItem) },
{ "PantsAsset", OSD.FromUUID(PANTS_ASSET) },
{ "ShirtItem", OSD.FromUUID(shirtItem) },
{ "ShirtAsset", OSD.FromUUID(SHIRT_ASSET) },
{ "SkinItem", OSD.FromUUID(skinItem) },
{ "SkinAsset", OSD.FromUUID(SKIN_ASSET) }
};
m_userClient.UpdateUserFields(ownerID, new OSDMap {
{ "LLAppearance", appearanceMap }
});
}
return(inventory);
}
public object Outfit(string name, string token)
{
if (tokens.Allow(token, "inventory", "Outfit", handleGetClientIP()) == false)
{
return(Failure("Token not accepted", "Outfit", new [] { name }));
}
if (helpers.notempty(name) == false)
{
return(Failure("Named folder value is empty", "Outfit", new [] { name }));
}
// uses the Clothing folder
// must be a full outfit (shapes/eyes ect)
InventoryFolder AA = bot.GetClient.Inventory.Store.RootFolder;
List <InventoryBase> T = bot.GetClient.Inventory.Store.GetContents(AA);
AA = null;
foreach (InventoryBase R in T)
{
if (R.Name == "Clothing")
{
AA = (InventoryFolder)R;
break;
}
}
if (AA == null)
{
return(Failure("Cant find Clothing folder", "Outfit", new [] { name }));
}
T = bot.GetClient.Inventory.Store.GetContents(AA);
AA = null;
foreach (InventoryBase R in T)
{
if (R.Name == name)
{
AA = (InventoryFolder)R;
break;
}
}
if (AA == null)
{
return(Failure("Cant find target folder", "Outfit", new [] { name }));
}
List <InventoryBase> contents = bot.GetClient.Inventory.FolderContents(AA.UUID, bot.GetClient.Self.AgentID, true, true, InventorySortOrder.ByName, 5 * 1000);
List <InventoryItem> wareables = new List <InventoryItem>();
if (contents == null)
{
return(Failure("target folder is empty or so full I cant get it in 5 secs...", "Outfit", new [] { name }));
}
foreach (InventoryBase item in contents)
{
if ((item is InventoryWearable) || (item is InventoryObject))
{
wareables.Add((InventoryItem)item);
}
}
bot.GetClient.Appearance.ReplaceOutfit(wareables, false);
return(BasicReply("ok", "Outfit", new [] { name }));
}
public void regFolderHook(InventoryFolder folder)
{
if (!hooked.ContainsKey(folder.UUID))
{
hooked.Add(folder.UUID, folder.Name);
WriteLine(" regFolderHook " + folder.Name);
}
}
/// <summary>
/// Initialize everything that needs to be initialized once we're logged in.
/// </summary>
/// <param name="login">The status of the login</param>
/// <param name="message">Error message on failure, MOTD on success.</param>
public void LoginHandler(LoginStatus login, string message)
{
if (login == LoginStatus.Success)
{
// Start in the inventory root folder.
CurrentDirectory = Inventory.Store.RootFolder;
}
}
/// <summary>
/// Initialize everything that needs to be initialized once we're logged in.
/// </summary>
/// <param name="login">The status of the login</param>
/// <param name="message">Error message on failure, MOTD on success.</param>
public void LoginHandler(object sender, LoginProgressEventArgs e)
{
if (e.Status == LoginStatus.Success)
{
// Start in the inventory root folder.
CurrentDirectory = Inventory.Store.RootFolder;
}
}
public static bool TryGetSpecificOrDefaultFolderOrFallback(
this IInventoryFolderServiceInterface folderServiceInterface,
UUID principalID,
UUID specificFolder,
AssetType type,
out InventoryFolder folder) =>
folderServiceInterface.TryGetValue(principalID, specificFolder, out folder) ||
folderServiceInterface.TryGetDefaultFolderOrFallback(principalID, type, out folder);
Process(RestBot b, Dictionary <string, string> Parameters)
{
UUID folderID;
DebugUtilities.WriteDebug("Entering folder key parser");
try
{
bool check = false;
if (Parameters.ContainsKey("key"))
{
DebugUtilities.WriteDebug("Attempting to parse from POST");
check =
UUID
.TryParse(Parameters["key"].ToString().Replace("_", " "),
out folderID);
DebugUtilities.WriteDebug("Succesfully parsed POST");
}
else
{
folderID = UUID.Zero; // start with root folder
check = true;
}
if (
check // means that we have a correctly parsed key OR no key
)
// which is fine too (attempts root folder)
{
DebugUtilities.WriteDebug("Entering loop");
Manager = b.Client.Inventory;
Inventory = Manager.Store;
StringBuilder response = new StringBuilder();
InventoryFolder startFolder = new InventoryFolder(folderID);
if (folderID == UUID.Zero)
{
startFolder = Inventory.RootFolder;
}
PrintFolder(b, startFolder, response);
DebugUtilities.WriteDebug("Complete");
return($"<inventory>{response}</inventory>");
}
else
{
return($"<error>{MethodName}: parsekey</error>");
}
}
catch (Exception e)
{
DebugUtilities.WriteError(e.Message);
return($"<error>{MethodName}: {e.Message}</error>");
}
}
private static UUID GetPath(
UGUI principalID,
InventoryServiceInterface inventoryService,
Dictionary <UUID, UUID> folders,
string path,
LoadOptions options)
{
path = path.Substring(10); /* Get Rid of inventory/ */
int slashPos = path.LastIndexOf('/');
if (slashPos >= 0)
{
path = path.Substring(0, slashPos);
}
string[] pathcomps = path.Split('/');
var finalpath = new StringBuilder();
UUID folderID = folders[string.Empty];
int pathidx = 0;
if ((options & LoadOptions.Merge) != 0 &&
pathcomps[0].StartsWith("MyInventory") &&
pathcomps[0].Length == 13 + 36)
{
pathidx = 1;
}
for (; pathidx < pathcomps.Length; ++pathidx)
{
if (finalpath.Length != 0)
{
finalpath.Append("/");
}
string uuidstr = pathcomps[pathidx].Substring(pathcomps[pathidx].Length - 36);
UUID nextfolderid = UUID.Parse(uuidstr);
string pname = pathcomps[pathidx].Substring(0, pathcomps[pathidx].Length - 38);
finalpath.Append(pname);
if (folders.ContainsKey(nextfolderid))
{
folderID = folders[nextfolderid];
}
else
{
var folder = new InventoryFolder
{
Owner = principalID,
ParentFolderID = folderID,
Name = EscapingMethods.UnescapeName(pname)
};
inventoryService.Folder.Add(folder);
folderID = folder.ID;
folders[nextfolderid] = folderID;
}
}
return(folderID);
}
public static Dictionary <string, object> ToDictionary(this InventoryFolder folder) => new Dictionary <string, object>
{
["ID"] = folder.ID,
["ParentFolderID"] = folder.ParentFolderID,
["Name"] = folder.Name,
["DefaultType"] = folder.DefaultType,
["OwnerID"] = folder.Owner.ID,
["Version"] = folder.Version
};
public bool CreateNewFolder(LLUUID folderID, ushort type)
{
InventoryFolder Folder = new InventoryFolder();
Folder.FolderID = folderID;
Folder.OwnerID = this.AgentID;
Folder.DefaultType = type;
this.InventoryFolders.Add(Folder.FolderID, Folder);
return (true);
}
public void appendFolderHook(InventoryFolder folder)
{
if (!hooked.ContainsKey(folder.UUID))
{
hooked.Add(folder.UUID, folder.Name);
// botclient.Inventory.OnContentsRetrieved += new InventoryFolder.ContentsRetrieved(myfolder_OnContentsRetrieved);
WriteLine(" appendFolderHook " + folder.Name);
}
}
public void AddInventoryFolder(InventoryFolder folder)
{
FolderData.Add(new FolderDataEntry
{
FolderID = folder.ID,
ParentID = folder.ParentFolderID,
DefaultType = folder.DefaultType,
Name = folder.Name
});
}
public void FetchInventoryDescendents(SimClient userInfo, FetchInventoryDescendentsPacket FetchDescend)
{
if (this._agentsInventory.ContainsKey(userInfo.AgentID))
{
AgentInventory agentInventory = this._agentsInventory[userInfo.AgentID];
if (FetchDescend.InventoryData.FetchItems)
{
if (agentInventory.InventoryFolders.ContainsKey(FetchDescend.InventoryData.FolderID))
{
InventoryFolder Folder = agentInventory.InventoryFolders[FetchDescend.InventoryData.FolderID];
InventoryDescendentsPacket Descend = new InventoryDescendentsPacket();
Descend.AgentData.AgentID = userInfo.AgentID;
Descend.AgentData.OwnerID = Folder.OwnerID;
Descend.AgentData.FolderID = FetchDescend.InventoryData.FolderID;
Descend.AgentData.Descendents = Folder.Items.Count;
Descend.AgentData.Version = Folder.Items.Count;
Descend.ItemData = new InventoryDescendentsPacket.ItemDataBlock[Folder.Items.Count];
for (int i = 0; i < Folder.Items.Count; i++)
{
InventoryItem Item = Folder.Items[i];
Descend.ItemData[i] = new InventoryDescendentsPacket.ItemDataBlock();
Descend.ItemData[i].ItemID = Item.ItemID;
Descend.ItemData[i].AssetID = Item.AssetID;
Descend.ItemData[i].CreatorID = Item.CreatorID;
Descend.ItemData[i].BaseMask = FULL_MASK_PERMISSIONS;
Descend.ItemData[i].CreationDate = 1000;
Descend.ItemData[i].Description = _enc.GetBytes(Item.Description + "\0");
Descend.ItemData[i].EveryoneMask = FULL_MASK_PERMISSIONS;
Descend.ItemData[i].Flags = 1;
Descend.ItemData[i].FolderID = Item.FolderID;
Descend.ItemData[i].GroupID = new LLUUID("00000000-0000-0000-0000-000000000000");
Descend.ItemData[i].GroupMask = FULL_MASK_PERMISSIONS;
Descend.ItemData[i].InvType = Item.InvType;
Descend.ItemData[i].Name = _enc.GetBytes(Item.Name + "\0");
Descend.ItemData[i].NextOwnerMask = FULL_MASK_PERMISSIONS;
Descend.ItemData[i].OwnerID = Item.OwnerID;
Descend.ItemData[i].OwnerMask = FULL_MASK_PERMISSIONS;
Descend.ItemData[i].SalePrice = 100;
Descend.ItemData[i].SaleType = 0;
Descend.ItemData[i].Type = Item.Type;
Descend.ItemData[i].CRC = libsecondlife.Helpers.InventoryCRC(1000, 0, Descend.ItemData[i].InvType, Descend.ItemData[i].Type, Descend.ItemData[i].AssetID, Descend.ItemData[i].GroupID, 100, Descend.ItemData[i].OwnerID, Descend.ItemData[i].CreatorID, Descend.ItemData[i].ItemID, Descend.ItemData[i].FolderID, FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS);
}
userInfo.OutPacket(Descend);
}
}
else
{
Console.WriteLine("fetch subfolders");
}
}
}
void IInventoryFolderServiceInterface.Move(UUID principalID, UUID folderID, UUID toFolderID)
{
InventoryFolder thisfolder = Folder[principalID, folderID];
if (folderID == toFolderID)
{
throw new ArgumentException("folderID != toFolderID");
}
using (var connection = new MySqlConnection(m_ConnectionString))
{
connection.Open();
connection.InsideTransaction((transaction) =>
{
if (!IsParentFolderIdValid(connection, principalID, toFolderID, folderID, transaction))
{
throw new InvalidParentFolderIdException(string.Format("Invalid parent folder {0} for folder {1}", toFolderID, folderID));
}
using (var cmd = new MySqlCommand("SELECT NULL FROM " + m_InventoryFolderTable + " WHERE ID = @folderid AND OwnerID = @ownerid LIMIT 1", connection)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@folderid", toFolderID);
cmd.Parameters.AddParameter("@ownerid", principalID);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
if (!reader.Read())
{
throw new InventoryFolderNotStoredException(folderID);
}
}
}
using (var cmd = new MySqlCommand("UPDATE " + m_InventoryFolderTable + " SET ParentFolderID = @folderid WHERE ID = @id AND OwnerID = @ownerid", connection)
{
Transaction = transaction
})
{
cmd.Parameters.AddParameter("@folderid", toFolderID);
cmd.Parameters.AddParameter("@ownerid", principalID);
cmd.Parameters.AddParameter("@id", folderID);
if (cmd.ExecuteNonQuery() < 1)
{
throw new InventoryFolderNotStoredException(folderID);
}
}
});
}
IncrementVersionNoExcept(principalID, toFolderID);
IncrementVersionNoExcept(principalID, thisfolder.ParentFolderID);
}
void PrintFolder(InventoryFolder f, StringBuilder result, int indent)
{
foreach (InventoryBase i in Manager.FolderContents(f.UUID, Client.Self.AgentID, true, true, InventorySortOrder.ByName, 3000))
{
result.AppendFormat("{0}{1} ({2})\n", new String(' ', indent * 2), i.Name, i.UUID);
if (i is InventoryFolder)
{
InventoryFolder folder = (InventoryFolder)i;
PrintFolder(folder, result, indent + 1);
}
}
}
void IInventoryFolderServiceInterface.Add(InventoryFolder folder)
{
var m = new Map();
var categories = new AnArray();
m.Add("categories", categories);
var category = new Map();
categories.Add(category);
category.Add("name", folder.Name);
category.Add("type_default", (int)folder.DefaultType);
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(m, ms);
reqdata = ms.ToArray();
}
IValue res;
HttpStatusCode statuscode;
using (Stream sres = new HttpClient.Post(
$"{m_CapabilityUri}category/{folder.ParentFolderID}",
"application/llsd+xml",
reqdata.Length,
(Stream s) => s.Write(reqdata, 0, reqdata.Length))
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest(out statuscode))
{
if (statuscode != HttpStatusCode.Created)
{
throw new InventoryFolderNotFoundException(folder.ParentFolderID);
}
res = LlsdXml.Deserialize(sres);
}
var resmap = res as Map;
if (resmap == null)
{
throw new InvalidDataException();
}
var created_items = resmap["_created_categories"] as AnArray;
if (created_items == null)
{
throw new InvalidDataException();
}
folder.ID = created_items[0].AsUUID;
}
private static bool TryGetFolder(Request request, UUID folderId, out InventoryFolder folder, Dictionary <UUID, InventoryFolder> folderCache)
{
if (folderCache.TryGetValue(folderId, out folder))
{
return(true);
}
if (request.InventoryService.Folder.TryGetValue(request.Agent.ID, folderId, out folder))
{
folderCache.Add(folder.ID, folder);
return(true);
}
return(false);
}
bool IInventoryFolderServiceInterface.TryGetValue(UUID key, out InventoryFolder folder)
{
foreach (RwLockedDictionary <UUID, InventoryFolder> dict in m_Folders.Values)
{
if (dict.TryGetValue(key, out folder))
{
folder = new InventoryFolder(folder);
return(true);
}
}
folder = default(InventoryFolder);
return(false);
}
public static void DoMapFolderHumanReadable(CommandsBot bot, int level, InventoryFolder folder, StringBuilder reply)
{
List <InventoryBase> T = bot.GetClient.Inventory.Store.GetContents(folder);
foreach (InventoryBase R in T)
{
if (R.GetType() == typeof(InventoryFolder))
{
reply.Append("" + Spaces(level) + "|- " + R.Name + " [" + R.UUID.ToString() + "]\n\r");
DoMapFolderHumanReadable(bot, level + 1, (InventoryFolder)R, reply);
}
}
}
public override string Execute(string[] args, UUID fromAgentID)
{
Manager = Client.Inventory;
Inventory = Manager.Store;
StringBuilder result = new StringBuilder();
InventoryFolder rootFolder = Inventory.RootFolder;
PrintFolder(rootFolder, result, 0);
return(result.ToString());
}
public void Inventory_OnFolderUpdated(LLUUID folderID)
{
List <InventoryBase> contents = Client.Inventory.Store.GetContents(folderID);
Hashtable roothash = new Hashtable();
roothash.Add("MessageType", "FolderUpdated");
roothash.Add("FolderID", folderID);
List <Hashtable> response = new List <Hashtable>();
lock (LoadedInventory)
{
foreach (InventoryBase o in contents)
{
if (LoadedInventory.Contains(o.UUID))
{
continue;
}
LoadedInventory.Add(o.UUID);
Hashtable hash = new Hashtable();
if (o is InventoryFolder)
{
InventoryFolder folder = (InventoryFolder)o;
hash.Add("Type", "InventoryFolder");
hash.Add("Name", folder.Name);
hash.Add("PreferredType", folder.PreferredType);
hash.Add("OwnerID", folder.OwnerID);
hash.Add("UUID", folder.UUID);
response.Add(hash);
}
else if (o is InventoryItem)
{
InventoryItem item = (InventoryItem)o;
hash.Add("Type", "InventoryItem");
hash.Add("Name", item.Name);
hash.Add("UUID", item.UUID);
hash.Add("AssetType", item.AssetType);
hash.Add("AssetUUID", item.AssetUUID);
hash.Add("CreatorID", item.CreatorID);
hash.Add("OwnerID", item.OwnerID);
hash.Add("CreationDate", item.CreationDate);
hash.Add("Description", item.Description);
hash.Add("Flags", item.Flags);
hash.Add("InventoryType", item.InventoryType);
hash.Add("Permissions", item.Permissions);
response.Add(hash);
}
}
}
roothash.Add("Contents", response);
enqueue(roothash);
}
public void TestWriteItemToFolder()
{
InventoryFolder folder = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = Guid.NewGuid(),
ParentId = Guid.Empty,
Type = 2
};
_storage.CreateFolder(folder);
InventoryItem item = new InventoryItem
{
AssetId = Guid.NewGuid(),
AssetType = 11,
BasePermissions = 3,
CreationDate = 4,
CreatorId = Guid.NewGuid(),
CurrentPermissions = 5,
Description = "Description",
EveryonePermissions = 6,
Flags = 7,
FolderId = folder.FolderId,
GroupId = Guid.NewGuid(),
GroupOwned = true,
GroupPermissions = 8,
InventoryType = 9,
ItemId = Guid.NewGuid(),
Name = "Name",
NextPermissions = int.MaxValue,
OwnerId = folder.OwnerId,
SaleType = 10
};
_storage.CreateItem(item);
folder = _storage.GetFolder(folder.FolderId);
var skelEntry = _storage.GetInventorySkeletonEntry(folder.OwnerId, folder.FolderId);
Assert.AreEqual(2, skelEntry.Version);
Assert.AreEqual(1, folder.Items.Count);
AssertItemEqual(item, folder.Items[0]);
var foundItem = _storage.GetItem(item.ItemId, Guid.Empty);
AssertItemEqual(item, foundItem);
}
public void TraverseNodesUnsorted(InventoryNode start, TimeSpan maxTime)
{
var Inventory = client.Inventory.Store;
bool has_items = false;
foreach (InventoryNode node in start.Nodes.Values)
{
if (node.Data is InventoryItem)
{
has_items = true;
break;
}
}
if (!has_items || start.NeedsUpdate)
{
InventoryFolder f = (InventoryFolder)start.Data;
AutoResetEvent gotFolderEvent = new AutoResetEvent(false);
bool success = false;
EventHandler <FolderUpdatedEventArgs> callback = delegate(object sender, FolderUpdatedEventArgs ea)
{
if (f.UUID == ea.FolderID)
{
if (((InventoryFolder)Inventory.Items[ea.FolderID].Data).DescendentCount <= Inventory.Items[ea.FolderID].Nodes.Count)
{
success = true;
gotFolderEvent.Set();
}
}
};
client.Inventory.FolderUpdated += callback;
fetchFolder(f.UUID, f.OwnerID, true);
gotFolderEvent.WaitOne(maxTime, false);
client.Inventory.FolderUpdated -= callback;
if (!success)
{
Logger.Log(string.Format("Failed fetching folder {0}, got {1} items out of {2}", f.Name, Inventory.Items[f.UUID].Nodes.Count, ((InventoryFolder)Inventory.Items[f.UUID].Data).DescendentCount), Helpers.LogLevel.Error, client);
}
}
foreach (InventoryBase item in Inventory.GetContents((InventoryFolder)start.Data))
{
if (item is InventoryFolder)
{
TraverseNodes(Inventory.GetNodeFor(item.UUID), maxTime);
}
}
}
private bool TryGetValue(UUID folderID, out InventoryFolder folder, out InventoryFolderContent inventoryFolderContent)
{
KeyValuePair <InventoryFolder, InventoryFolderContent> result;
inventoryFolderContent = default(InventoryFolderContent);
folder = default(InventoryFolder);
if (!GetFolderContents(new UUID[] { folderID }, true).TryGetValue(folderID, out result))
{
return(false);
}
folder = result.Key;
inventoryFolderContent = result.Value;
return(true);
}
private void InventoryFolder_OnContentsRetrieved(InventoryFolder folder)
{
UpdateFolder(folder);
}
public void PurgeFolder(InventoryFolder folder)
{
this.PurgeFolderContents(folder);
this.DeleteFolder(folder.OwnerId, folder.FolderId);
}
/// <summary>
/// Equivalent to the SL "Replace Outfit" command. All clothing is removed, and replaced with wearables in given folder. Body wearables will be replaced if provided.
/// </summary>
/// <param name="outfitFolder">Contains the wearable items to put on.</param>
public void WearOutfit(InventoryFolder outfitFolder)
{
WearOutfit(outfitFolder, 10000, true);
}
/// <summary>
/// Thread-safe method for updating the contents of the specified folder UUID
/// </summary>
/// <param name="folderID"></param>
public void UpdateFolder(InventoryFolder folder)
{
if (this.InvokeRequired) this.BeginInvoke((MethodInvoker)delegate { UpdateFolder(folder); });
else
{
TreeNode node = null;
TreeNodeCollection children;
if (folder != Client.InventoryStore.RootFolder)
{
TreeNode[] found = Nodes.Find(folder.UUID.ToString(), true);
if (found.Length > 0)
{
node = found[0];
children = node.Nodes;
}
else
{
Logger.Log("Received update for unknown TreeView node " + folder.UUID, Helpers.LogLevel.Warning);
return;
}
}
else children = this.Nodes;
children.Clear();
List<InventoryBase> contents = folder.Contents;
if (contents.Count == 0)
{
TreeNode add = children.Add(null, "(empty)");
add.ForeColor = Color.FromKnownColor(KnownColor.GrayText);
}
else
{
foreach (InventoryBase inv in contents)
{
string key = inv.UUID.ToString();
children.Add(key, inv.Name);
children[key].Tag = inv;
if (inv is InventoryFolder)
{
children[key].Nodes.Add(null, "(loading...)").ForeColor = Color.FromKnownColor(KnownColor.GrayText);
((InventoryFolder)inv).OnContentsRetrieved += new InventoryFolder.ContentsRetrieved(InventoryFolder_OnContentsRetrieved);
}
}
}
}
}
public InventoryFolder GetFolder(Guid folderId)
{
var statement = FOLDER_SELECT_STMT.Bind(folderId);
var rowset = _session.Execute(statement);
var itemList = new List<InventoryItem>();
InventoryFolder retFolder = null;
foreach (var row in rowset)
{
if (row.GetValue<Guid>("item_id") == FOLDER_MAGIC_ENTRY)
{
retFolder = new InventoryFolder { FolderId = folderId };
//this is the data row that holds the information for the folder itself
MapRowToFolder(retFolder, row);
}
else
{
itemList.Add(MapRowToItem(row));
}
}
if (retFolder != null)
{
retFolder.Items = itemList;
}
return retFolder;
}
public List<InventoryBase> GetContents(InventoryFolder folder)
{
return GetContents(folder.UUID);
}
internal void FolderRename(InventoryFolder ifolder)
{
Packet packet = InvPacketHelper.UpdateInventoryFolder(ifolder.Name, ifolder.ParentID, ifolder.Type, ifolder.FolderID);
slClient.Network.SendPacket(packet);
}
public InventoryFolder(InventoryFolder folder)
: base(folder)
{
PreferredContentType = folder.PreferredContentType;
Version = folder.Version;
Children = new Dictionary<UUID, InventoryBase>(folder.Children);
}
internal void FolderMove(InventoryFolder iFolder, LLUUID newParentID)
{
Packet packet = InvPacketHelper.MoveInventoryFolder(newParentID, iFolder.FolderID);
slClient.Network.SendPacket(packet);
}
internal void FolderRemove(InventoryFolder ifolder)
{
FolderRemove(ifolder.FolderID);
}
private static void MapRowToFolder(InventoryFolder retFolder, Row row)
{
retFolder.CreationDate = row.GetValue<int>("creation_date");
retFolder.Name = row.GetValue<string>("name");
retFolder.OwnerId = row.GetValue<Guid>("owner_id");
retFolder.Type = row.GetValue<int>("inv_type");
}
public void TestPurgeEmptyFolder()
{
InventoryFolder folder = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = Guid.NewGuid(),
ParentId = Guid.Empty,
Type = 2
};
_storage.CreateFolder(folder);
_storage.PurgeFolder(folder);
var newfolder = _storage.GetFolder(folder.FolderId);
var skelEntry = _storage.GetInventorySkeletonEntry(folder.OwnerId, folder.FolderId);
Assert.Null(newfolder);
Assert.Null(skelEntry);
}
public void TestPurgeNonemptyFolderContents()
{
var ownerId = Guid.NewGuid();
InventoryFolder parent = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = ownerId,
ParentId = Guid.Empty,
Type = 2
};
InventoryFolder child = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.TopLevel,
Name = "Test",
OwnerId = ownerId,
ParentId = parent.FolderId,
Type = 2
};
_storage.CreateFolder(parent);
_storage.CreateFolder(child);
InventoryItem item = new InventoryItem
{
AssetId = Guid.NewGuid(),
AssetType = 11,
BasePermissions = 3,
CreationDate = 4,
CreatorId = Guid.NewGuid(),
CurrentPermissions = 5,
Description = "Description",
EveryonePermissions = 6,
Flags = 7,
FolderId = child.FolderId,
GroupId = Guid.NewGuid(),
GroupOwned = true,
GroupPermissions = 8,
InventoryType = 9,
ItemId = Guid.NewGuid(),
Name = "Name",
NextPermissions = int.MaxValue,
OwnerId = ownerId,
SaleType = 10
};
InventoryItem item2 = new InventoryItem
{
AssetId = Guid.NewGuid(),
AssetType = 11,
BasePermissions = 3,
CreationDate = 4,
CreatorId = Guid.NewGuid(),
CurrentPermissions = 5,
Description = "Description",
EveryonePermissions = 6,
Flags = 7,
FolderId = parent.FolderId,
GroupId = Guid.NewGuid(),
GroupOwned = true,
GroupPermissions = 8,
InventoryType = 9,
ItemId = Guid.NewGuid(),
Name = "Name",
NextPermissions = int.MaxValue,
OwnerId = ownerId,
SaleType = 10
};
_storage.CreateItem(item);
_storage.CreateItem(item2);
_storage.PurgeFolderContents(parent);
Assert.Null(_storage.GetFolder(child.FolderId));
Assert.Null(_storage.GetInventorySkeletonEntry(parent.OwnerId, child.FolderId));
Assert.Null(_storage.GetItem(item.ItemId, Guid.Empty));
Assert.Null(_storage.GetItem(item2.ItemId, Guid.Empty));
}
/// <summary>
/// Move this item to the target folder
/// </summary>
/// <param name="targetFolder"></param>
public void MoveTo(InventoryFolder targetFolder)
{
this.FolderID = targetFolder.FolderID;
}
private InventoryFolder getFolder(Queue<string> qFolderPath, InventoryFolder ifRoot)
{
string sCurFolder = qFolderPath.Dequeue();
foreach (InventoryBase ibFolder in ifRoot.alContents)
{
if (ibFolder is libsecondlife.InventorySystem.InventoryFolder)
{
if (((InventoryFolder)ibFolder).Name.Equals(sCurFolder))
{
if (qFolderPath.Count == 0)
{
return (InventoryFolder)ibFolder;
}
else
{
return getFolder(qFolderPath, (InventoryFolder)ibFolder);
}
}
}
}
return null;
}
public void MoveItem(InventoryItem item, InventoryFolder parentFolder)
{
var insert = FOLDER_ITEM_INSERT_STMT.Bind(parentFolder.FolderId, item.ItemId, item.Name, item.AssetId, item.AssetType,
item.BasePermissions, item.CreationDate, item.CreatorId, item.CurrentPermissions, item.Description, item.EveryonePermissions,
item.Flags, item.GroupId, item.GroupOwned, item.GroupPermissions, item.InventoryType, item.NextPermissions,
item.OwnerId, item.SaleType);
var removeOld = FOLDER_ITEM_REMOVE_STMT.Bind(item.FolderId, item.ItemId);
var ownershipUpdate = ITEM_OWNERSHIP_UPDATE.Bind(parentFolder.FolderId, item.ItemId);
var batch = new BatchStatement()
.Add(insert)
.Add(ownershipUpdate)
.Add(removeOld);
_session.Execute(batch);
VersionInc(item.OwnerId, item.FolderId);
VersionInc(item.OwnerId, parentFolder.FolderId);
}
private void resetFoldersByUUID()
{
// Init folder structure with root
htFoldersByUUID = new Dictionary<LLUUID,InventoryFolder>();
InventoryFolder ifRootFolder = new InventoryFolder(this, "My Inventory", uuidRootFolder, null);
htFoldersByUUID[uuidRootFolder] = ifRootFolder;
}
public InventoryFolder GetFolderAttributes(Guid folderId)
{
var statement = FOLDER_SELECT_STMT.Bind(folderId);
var rowset = _session.Execute(statement);
InventoryFolder retFolder = null;
foreach (var row in rowset)
{
retFolder = new InventoryFolder { FolderId = folderId };
//should only be a single row
MapRowToFolder(retFolder, row);
break;
}
return retFolder;
}
public void TestMoveFolder()
{
var ownerId = Guid.NewGuid();
InventoryFolder firstParent = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test1",
OwnerId = ownerId,
ParentId = Guid.Empty,
Type = 2
};
InventoryFolder secondParent = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test2",
OwnerId = ownerId,
ParentId = Guid.Empty,
Type = 2
};
InventoryFolder folder = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = ownerId,
ParentId = firstParent.FolderId,
Type = 2
};
_storage.CreateFolder(firstParent);
_storage.CreateFolder(secondParent);
_storage.CreateFolder(folder);
//find the folder in the skel
var folderSkelEntry = _storage.GetInventorySkeletonEntry(ownerId, folder.FolderId);
_storage.MoveFolder(folderSkelEntry, secondParent.FolderId);
//get the skel for this user to check the level, version, and parent
var skel = _storage.GetInventorySkeleton(folder.OwnerId);
Dictionary<Guid, InventorySkeletonEntry> entries = new Dictionary<Guid, InventorySkeletonEntry>();
foreach (var skelentry in skel)
{
entries.Add(skelentry.FolderId, skelentry);
}
Assert.AreEqual(3, skel.Count);
Assert.AreEqual(folder.Level, entries[folder.FolderId].Level);
Assert.AreEqual(secondParent.FolderId, entries[folder.FolderId].ParentId);
Assert.AreEqual(2, entries[folder.FolderId].Version);
Assert.AreEqual(folder.Name, entries[folder.FolderId].Name);
Assert.AreEqual(folder.Type, entries[folder.FolderId].Type);
}
/// <summary>
/// Updates the state of the InventoryNode and inventory data structure that
/// is responsible for the InventoryObject. If the item was previously not added to inventory,
/// it adds the item, and updates structure accordingly. If it was, it updates the
/// InventoryNode, changing the parent node if <code>item.parentUUID</code> does
/// not match <code>node.Parent.Data.UUID</code>.
///
/// You can not set the inventory root folder using this method
/// </summary>
/// <param name="item">The InventoryObject to store</param>
public void UpdateNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode itemParent = null;
if (item.ParentUUID != UUID.Zero && !Items.TryGetValue(item.ParentUUID, out itemParent))
{
// OK, we have no data on the parent, let's create a fake one.
InventoryFolder fakeParent = new InventoryFolder(item.ParentUUID);
fakeParent.DescendentCount = 1; // Dear god, please forgive me.
itemParent = new InventoryNode(fakeParent);
Items[item.ParentUUID] = itemParent;
// Unfortunately, this breaks the nice unified tree
// while we're waiting for the parent's data to come in.
// As soon as we get the parent, the tree repairs itself.
Console.WriteLine("Attempting to update inventory child of " +
item.ParentUUID.ToString() + " when we have no local reference to that folder");
if (true)
{
// Fetch the parent
List<UUID> fetchreq = new List<UUID>(1);
fetchreq.Add(item.ParentUUID);
//Manager.FetchInventory(fetchreq); // we cant fetch folder data! :-O
}
}
InventoryNode itemNode;
if (Items.TryGetValue(item.UUID, out itemNode)) // We're updating.
{
InventoryNode oldParent = itemNode.Parent;
// Handle parent change
if (oldParent == null || itemParent == null || itemParent.Data.UUID != oldParent.Data.UUID)
{
if (oldParent != null)
{
lock (oldParent.Nodes.SyncRoot)
oldParent.Nodes.Remove(item.UUID);
}
if (itemParent != null)
{
lock (itemParent.Nodes.SyncRoot)
itemParent.Nodes[item.UUID] = itemNode;
}
}
itemNode.Parent = itemParent;
itemNode.Data = item;
}
else // We're adding.
{
itemNode = new InventoryNode(item, itemParent);
Items.Add(item.UUID, itemNode);
}
}
}
public void PurgeFolderContents(InventoryFolder folder)
{
//build a graph from the inventory skeleton
var skel = this.GetInventorySkeleton(folder.OwnerId);
var graph = new SkeletonGraphNode(skel);
var thisNode = graph.AllChildren[folder.FolderId];
//to purge the contents of a folder, we need to collect all
//the items and subfolders currently inside of it and delete everything
//recursively
Tuple<List<InventoryItem>, List<Guid>> itemsAndFolders = new Tuple<List<InventoryItem>, List<Guid>>(new List<InventoryItem>(), new List<Guid>());
RecursiveCollectFolderContents(thisNode, itemsAndFolders);
//remove all the items
foreach (var item in itemsAndFolders.Item1)
{
this.PurgeItem(item);
}
//remove the folders
foreach (var folderid in itemsAndFolders.Item2)
{
if (folderid != folder.FolderId)
{
this.DeleteFolder(folder.OwnerId, folderid);
}
}
VersionInc(folder.OwnerId, folder.FolderId);
}
public void InventoryDescendentsHandler(Packet packet, Simulator simulator)
{
InventoryDescendentsPacket reply = (InventoryDescendentsPacket)packet;
LastPacketRecieved = Helpers.GetUnixTime();
InventoryItem invItem;
InventoryFolder invFolder;
LLUUID uuidFolderID = new LLUUID();
int iDescendentsExpected = int.MaxValue;
int iDescendentsReceivedThisBlock = 0;
foreach (InventoryDescendentsPacket.ItemDataBlock itemBlock in reply.ItemData)
{
// There is always an item block, even if there isn't any items
// the "filler" block will not have a name
if (itemBlock.Name.Length != 0)
{
iDescendentsReceivedThisBlock++;
invItem = new InventoryItem(this, itemBlock);
InventoryFolder ifolder = (InventoryFolder)htFoldersByUUID[invItem.FolderID];
if (ifolder.alContents.Contains(invItem) == false)
{
if ((invItem.InvType == 7) && (invItem.Type == Asset.ASSET_TYPE_NOTECARD))
{
InventoryItem temp = new InventoryNotecard(this, invItem);
invItem = temp;
}
if ((invItem.InvType == 0) && (invItem.Type == Asset.ASSET_TYPE_IMAGE))
{
InventoryItem temp = new InventoryImage(this, invItem);
invItem = temp;
}
ifolder.alContents.Add(invItem);
}
}
}
foreach (InventoryDescendentsPacket.FolderDataBlock folderBlock in reply.FolderData)
{
String name = System.Text.Encoding.UTF8.GetString(folderBlock.Name).Trim().Replace("\0", "");
LLUUID folderid = folderBlock.FolderID;
LLUUID parentid = folderBlock.ParentID;
sbyte type = folderBlock.Type;
// There is always an folder block, even if there isn't any folders
// the "filler" block will not have a name
if (folderBlock.Name.Length != 0)
{
invFolder = new InventoryFolder(this, name, folderid, parentid);
iDescendentsReceivedThisBlock++;
// Add folder to Parent
InventoryFolder ifolder = (InventoryFolder)htFoldersByUUID[invFolder.ParentID];
if (ifolder.alContents.Contains(invFolder) == false)
{
ifolder.alContents.Add(invFolder);
}
// Add folder to UUID Lookup
htFoldersByUUID[invFolder.FolderID] = invFolder;
// It's not the root, should be safe to "recurse"
if (!invFolder.FolderID.Equals(uuidRootFolder))
{
bool alreadyQueued = false;
foreach (DescendentRequest dr in alFolderRequestQueue)
{
if (dr.FolderID == invFolder.FolderID)
{
alreadyQueued = true;
break;
}
}
if (!alreadyQueued)
{
alFolderRequestQueue.Add(new DescendentRequest(invFolder.FolderID));
}
}
}
}
// Check how many descendents we're actually supposed to receive
iDescendentsExpected = reply.AgentData.Descendents;
uuidFolderID = reply.AgentData.FolderID;
// Update download status for this folder
if (iDescendentsReceivedThisBlock >= iDescendentsExpected)
{
// We received all the descendents we're expecting for this folder
// in this packet, so go ahead and remove folder from status list.
htFolderDownloadStatus.Remove(uuidFolderID);
}
else
{
// This one packet didn't have all the descendents we're expecting
// so update the total we're expecting, and update the total downloaded
DescendentRequest dr = (DescendentRequest)htFolderDownloadStatus[uuidFolderID];
dr.Expected = iDescendentsExpected;
dr.Received += iDescendentsReceivedThisBlock;
dr.LastReceived = Helpers.GetUnixTime();
if (dr.Received >= dr.Expected)
{
// Looks like after updating, we have all the descendents,
// remove from folder status.
htFolderDownloadStatus.Remove(uuidFolderID);
}
else
{
htFolderDownloadStatus[uuidFolderID] = dr;
// Console.WriteLine( uuidFolderID + " is expecting " + (iDescendentsExpected - iStatus[1]) + " more packets." );
}
}
}
public void MoveTo(InventoryFolder newParent)
{
MoveTo(newParent.FolderID);
}
internal InventoryFolder FolderCreate(String name, LLUUID parentid)
{
InventoryFolder ifolder = new InventoryFolder(this, name, LLUUID.GenerateUUID(), parentid);
ifolder._Type = -1;
if (htFoldersByUUID.ContainsKey(ifolder.ParentID))
{
if (((InventoryFolder)htFoldersByUUID[ifolder.ParentID]).alContents.Contains(ifolder) == false)
{
// Add new folder to the contents of the parent folder.
((InventoryFolder)htFoldersByUUID[ifolder.ParentID]).alContents.Add(ifolder);
}
}
else
{
throw new Exception("Parent Folder " + ifolder.ParentID + " does not exist in this Inventory Manager.");
}
if (htFoldersByUUID.ContainsKey(ifolder.FolderID) == false)
{
htFoldersByUUID[ifolder.FolderID] = ifolder;
}
Packet packet = InvPacketHelper.CreateInventoryFolder(ifolder.Name, ifolder.ParentID, ifolder.Type, ifolder.FolderID);
slClient.Network.SendPacket(packet);
return ifolder;
}
public void SaveFolder(InventoryFolder folder)
{
var skelUpdate = SKEL_UPDATE_STMT.Bind(folder.Name, folder.Type, folder.OwnerId, folder.FolderId);
var contentUpdate = FOLDER_UPDATE_STMT.Bind(folder.Name, folder.Type, folder.FolderId);
var batch = new BatchStatement()
.Add(skelUpdate)
.Add(contentUpdate);
_session.Execute(batch);
VersionInc(folder.OwnerId, folder.FolderId);
}
/// <summary>
/// Equivalent to the SL "Replace Outfit" command. All clothing is removed, and replaced with wearables in given folder. Body wearables will be replaced if provided.
/// </summary>
/// <param name="outfitFolder">Contains the wearable items to put on.</param>
/// <param name="TimeOut">How long to wait for outfit directory information to download</param>
public void WearOutfit(InventoryFolder outfitFolder, int TimeOut, bool removeExistingAttachments)
{
// Refresh download of outfit folder
if (!outfitFolder.RequestDownloadContents(false, false, true).RequestComplete.WaitOne(TimeOut, false))
{
Client.Log("Outfit not changed. An error occured while downloads the folder contents of : " + outfitFolder.Name, Helpers.LogLevel.Error);
return;
}
// Make sure we have some Wearable Data to start with.
if (AgentWearablesSignal.WaitOne(1000, false) == false)
{
Client.Log("You must have set appearance at least once, before calling WearOutfit(). AgentWearablesSignal not set.", Helpers.LogLevel.Error);
return;
}
// Flush the cached clothing wearables so we can redefine them
for (byte i = 4; i <= 12; i++)
{
AgentWearablesData[i].ItemID = LLUUID.Zero;
AgentWearablesData[i].AssetID = LLUUID.Zero;
}
List<InventoryItem> attachments = new List<InventoryItem>();
// Replace with wearables from Outfit folder
foreach (InventoryBase ib in outfitFolder.GetContents())
{
if (ib is InventoryWearable)
{
try
{
InventoryWearable iw = (InventoryWearable)ib;
Client.Log("Retrieving asset for " + iw.Name + "("+iw.AssetID+")", Helpers.LogLevel.Info);
AssetWearable.AppearanceLayerType AppearanceLayer = ((AssetWearable)iw.Asset).AppearanceLayer;
Client.Log("Adding skin/clothing layer for " + AppearanceLayer, Helpers.LogLevel.Info);
AgentWearablesData[(byte)AppearanceLayer].ItemID = iw.ItemID;
AgentWearablesData[(byte)AppearanceLayer].AssetID = iw.AssetID;
}
catch (Exception e)
{
Client.Log("Asset for " + ib._Name + " unavailable: " + e.Message, Helpers.LogLevel.Error);
}
}
else if (ib is InventoryItem)
{
InventoryItem ii = (InventoryItem)ib;
attachments.Add(ii);
}
}
// Change attachments
AddAttachments(attachments, removeExistingAttachments);
// Create AgentIsNowWearing Packet, and send it
SendAgentIsNowWearing();
// Send updated AgentSetAppearance to the grid
SendAgentSetAppearance();
}
public void TestWriteItemToFolder()
{
InventoryFolder folder = new InventoryFolder
{
FolderId = Guid.NewGuid(),
Level = FolderLevel.Root,
Name = "Test",
OwnerId = Guid.NewGuid(),
ParentId = Guid.Empty,
Type = 2
};
_storage.CreateFolder(folder);
InventoryItem item = new InventoryItem
{
AssetId = Guid.NewGuid(),
AssetType = 11,
BasePermissions = 3,
CreationDate = 4,
CreatorId = Guid.NewGuid(),
CurrentPermissions = 5,
Description = "Description",
EveryonePermissions = 6,
Flags = 7,
FolderId = folder.FolderId,
GroupId = Guid.NewGuid(),
GroupOwned = true,
GroupPermissions = 8,
InventoryType = 9,
ItemId = Guid.NewGuid(),
Name = "Name",
NextPermissions = int.MaxValue,
OwnerId = folder.OwnerId,
SaleType = 10
};
_storage.CreateItem(item);
folder = _storage.GetFolder(folder.FolderId);
var skelEntry = _storage.GetInventorySkeletonEntry(folder.OwnerId, folder.FolderId);
Assert.AreEqual(2, skelEntry.Version);
Assert.AreEqual(1, folder.Items.Count);
AssertItemEqual(item, folder.Items[0]);
var foundItem = _storage.GetItem(item.ItemId, Guid.Empty);
AssertItemEqual(item, foundItem);
}
