public void RequestFolderContents(UUID folder, UUID owner, bool folders, bool items,
InventorySortOrder order)
{
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = frame.AgentID;
fetch.AgentData.SessionID = frame.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = owner;
fetch.InventoryData.SortOrder = (int)order;
proxy.InjectPacket(fetch, Direction.Outgoing);
}
/// <summary>
/// Request a folder's content.
/// </summary>
/// <param name="folder"></param>
/// <param name="folders"></param>
/// <param name="items"></param>
/// <param name="order"></param>
public void RequestFolderContents(UUID folder, bool folders, bool items, InventorySortOrder order)
{
//empty the dictionnary containing current folder items by name
currentFolderItems = new Dictionary <string, InventoryItem>();
//reset the number of descendants received
nbdescendantsreceived = 0;
//build a packet to request the content
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = frame.AgentID;
fetch.AgentData.SessionID = frame.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = frame.AgentID; //is it correct?
fetch.InventoryData.SortOrder = (int)order;
//send packet to SL
proxy.InjectPacket(fetch, Direction.Outgoing);
}
public void RequestFolderContents(LLUUID folder, LLUUID owner, bool folders, bool items,
InventorySortOrder order)
{
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = _Client.Self.AgentID;
fetch.AgentData.SessionID = _Client.Self.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = owner;
fetch.InventoryData.SortOrder = (int)order;
_Client.Network.SendPacket(fetch);
}
public List<InventoryBase> FolderContents(LLUUID folder, LLUUID owner, bool folders, bool items,
InventorySortOrder order, int timeoutMS)
{
List<InventoryBase> objects = null;
AutoResetEvent fetchEvent = new AutoResetEvent(false);
FolderUpdatedCallback callback =
delegate(LLUUID folderID)
{
if (folderID == folder)
fetchEvent.Set();
};
OnFolderUpdated += callback;
RequestFolderContents(folder, owner, folders, items, order);
if (fetchEvent.WaitOne(timeoutMS, false))
objects = _Store.GetContents(folder);
OnFolderUpdated -= callback;
return objects;
}
/// <summary>
/// Get contents of a folder
/// </summary>
/// <param name="folder">The <seealso cref="UUID"/> of the folder to search</param>
/// <param name="owner">The <seealso cref="UUID"/> of the folders owner</param>
/// <param name="folders">true to retrieve folders</param>
/// <param name="items">true to retrieve items</param>
/// <param name="order">sort order to return results in</param>
/// <param name="timeoutMS">a integer representing the number of milliseconds to wait for results</param>
/// <returns>A list of inventory items matching search criteria within folder</returns>
/// <seealso cref="InventoryManager.RequestFolderContents"/>
/// <remarks>InventoryFolder.DescendentCount will only be accurate if both folders and items are
/// requested</remarks>
public List<InventoryBase> FolderContents(UUID folder, UUID owner, bool folders, bool items,
InventorySortOrder order, int timeoutMS)
{
List<InventoryBase> objects = null;
AutoResetEvent fetchEvent = new AutoResetEvent(false);
EventHandler<FolderUpdatedEventArgs> callback =
delegate(object sender, FolderUpdatedEventArgs e)
{
if (e.FolderID == folder
&& _Store[folder] is InventoryFolder)
{
// InventoryDescendentsHandler only stores DescendendCount if both folders and items are fetched.
if (_Store.GetContents(folder).Count >= ((InventoryFolder)_Store[folder]).DescendentCount)
{
fetchEvent.Set();
}
}
else
{
fetchEvent.Set();
}
};
FolderUpdated += callback;
RequestFolderContents(folder, owner, folders, items, order);
if (fetchEvent.WaitOne(timeoutMS, false))
objects = _Store.GetContents(folder);
FolderUpdated -= callback;
return objects;
}
//request a folder content
public void RequestFolderContents(UUID folder, bool folders, bool items,
InventorySortOrder order)
{
//empty the dictionnary containing current folder items by name
currentFolderItems = new Dictionary<string, ItemData>();
//reset the number of descendants received
nbdescendantsreceived = 0;
//build a packet to request the content
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = frame.AgentID;
fetch.AgentData.SessionID = frame.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = frame.AgentID; //is it correct?
fetch.InventoryData.SortOrder = (int)order;
//send packet to SL
proxy.InjectPacket(fetch, Direction.Outgoing);
}
/// <summary>
/// Request the contents of an inventory folder, <paramref name="callback"/> is fired when all of the contents are retrieved.
/// <paramref name="partialCallback"/> is fired as the contents trickle in from the server.
/// </summary>
/// <param name="folder">The folder to search</param>
/// <param name="owner">The folder owners <seealso cref="UUID"/></param>
/// <param name="folders">true to return <seealso cref="InventoryManager.InventoryFolder"/>s contained in folder</param>
/// <param name="items">true to return <seealso cref="InventoryManager.InventoryItem"/>s containd in folder</param>
/// <param name="order">the sort order to return items in</param>
/// <param name="callback">The callback to fire when all the contents are received.</param>
/// <param name="partialCallback">The callback to fire as the contents are received.</param>
/// <seealso cref="InventoryManager.FolderContents"/>
public void RequestFolderContents(UUID folder, UUID owner, bool folders, bool items, InventorySortOrder order, FolderContentsCallback callback, PartialContentsCallback partialCallback)
{
DescendentsRequest request = new DescendentsRequest(folder, callback);
request.PartialCallback = partialCallback;
lock (_DescendentsRequests)
_DescendentsRequests.Add(request);
// Send the packet:
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = _Agents.AgentID;
fetch.AgentData.SessionID = _Agents.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = owner;
fetch.InventoryData.SortOrder = (int)order;
_Network.SendPacket(fetch);
}
/// <summary>
///
/// </summary>
/// <param name="folder"></param>
/// <param name="owner"></param>
/// <param name="folders"></param>
/// <param name="items"></param>
/// <param name="order"></param>
/// <param name="callback"></param>
public void RequestFolderContents(UUID folder, UUID owner, bool folders, bool items, InventorySortOrder order, FolderContentsCallback callback)
{
RequestFolderContents(folder, owner, folders, items, order, callback, null);
}
/// <summary>
/// Get contents of a folder
/// </summary>
/// <param name="folder">The <seealso cref="UUID"/> of the folder to search</param>
/// <param name="owner">The <seealso cref="UUID"/> of the folders owner</param>
/// <param name="folders">true to retrieve folders</param>
/// <param name="items">true to retrieve items</param>
/// <param name="order">sort order to return results in</param>
/// <param name="timeout">a TimeSpan representing the amount of time to wait for results</param>
/// <param name="folderContents">A list of FolderData representing the folders contained in the parent folder.</param>
/// <param name="itemContents">A list of ItemData representing the items contained in the parent folder.</param>
/// <returns><code>true</code> if successful, <code>false</code> if timed out</returns>
/// <seealso cref="InventoryManager.RequestFolderContents"/>
public bool FolderContents(UUID folder, UUID owner, bool folders, bool items,
InventorySortOrder order, TimeSpan timeout, out List<ItemData> itemContents, out List<FolderData> folderContents)
{
AutoResetEvent lockEvent = new AutoResetEvent(false);
List<FolderData> _folders = null;
List<ItemData> _items = null;
FolderContentsCallback callback = new FolderContentsCallback(
delegate(UUID folderID, List<ItemData> __items, List<FolderData> __folders)
{
if (folderID == folder)
{
_folders = __folders;
_items = __items;
lockEvent.Set();
}
});
RequestFolderContents(folder, owner, folders, items, order, callback);
bool success = lockEvent.WaitOne(timeout, false);
itemContents = _items;
folderContents = _folders;
return success;
}
public void RequestFolderContentsCap(List<InventoryFolder> batch, Uri url, bool fetchFolders, bool fetchItems, InventorySortOrder order)
{
try
{
CapsClient request = new CapsClient(url);
request.OnComplete += (client, result, error) =>
{
try
{
if (error != null)
{
throw error;
}
OSDMap resultMap = ((OSDMap)result);
if (resultMap.ContainsKey("folders"))
{
OSDArray fetchedFolders = (OSDArray)resultMap["folders"];
for (int fetchedFolderNr = 0; fetchedFolderNr < fetchedFolders.Count; fetchedFolderNr++)
{
OSDMap res = (OSDMap)fetchedFolders[fetchedFolderNr];
InventoryFolder fetchedFolder = null;
if (_Store.Contains(res["folder_id"])
&& _Store[res["folder_id"]] is InventoryFolder)
{
fetchedFolder = (InventoryFolder)_Store[res["folder_id"]];
}
else
{
fetchedFolder = new InventoryFolder(res["folder_id"]);
_Store[res["folder_id"]] = fetchedFolder;
}
fetchedFolder.DescendentCount = res["descendents"];
fetchedFolder.Version = res["version"];
fetchedFolder.OwnerID = res["owner_id"];
_Store.GetNodeFor(fetchedFolder.UUID).NeedsUpdate = false;
// Do we have any descendants
if (fetchedFolder.DescendentCount > 0)
{
// Fetch descendent folders
if (res["categories"] is OSDArray)
{
OSDArray folders = (OSDArray)res["categories"];
for (int i = 0; i < folders.Count; i++)
{
OSDMap descFolder = (OSDMap)folders[i];
InventoryFolder folder;
UUID folderID = descFolder.ContainsKey("category_id") ? descFolder["category_id"] : descFolder["folder_id"];
if (!_Store.Contains(folderID))
{
folder = new InventoryFolder(folderID);
folder.ParentUUID = descFolder["parent_id"];
_Store[folderID] = folder;
}
else
{
folder = (InventoryFolder)_Store[folderID];
}
folder.OwnerID = descFolder["agent_id"];
folder.ParentUUID = descFolder["parent_id"];
folder.Name = descFolder["name"];
folder.Version = descFolder["version"];
folder.PreferredType = (FolderType)(int)descFolder["type_default"];
}
// Fetch descendent items
OSDArray items = (OSDArray)res["items"];
for (int i = 0; i < items.Count; i++)
{
InventoryItem item = InventoryItem.FromOSD(items[i]);
_Store[item.UUID] = item;
}
}
}
OnFolderUpdated(new FolderUpdatedEventArgs(res["folder_id"], true));
}
}
}
catch (Exception exc)
{
Logger.Log(string.Format("Failed to fetch inventory descendants: {0}\n{1}", exc.Message, exc.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
foreach (var f in batch)
{
OnFolderUpdated(new FolderUpdatedEventArgs(f.UUID, false));
}
return;
}
};
// Construct request
OSDArray requestedFolders = new OSDArray(1);
foreach (var f in batch)
{
OSDMap requestedFolder = new OSDMap(1);
requestedFolder["folder_id"] = f.UUID;
requestedFolder["owner_id"] = f.OwnerID;
requestedFolder["fetch_folders"] = fetchFolders;
requestedFolder["fetch_items"] = fetchItems;
requestedFolder["sort_order"] = (int)order;
requestedFolders.Add(requestedFolder);
}
OSDMap req = new OSDMap(1);
req["folders"] = requestedFolders;
request.BeginGetResponse(req, OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);
}
catch (Exception ex)
{
Logger.Log(string.Format("Failed to fetch inventory descendants: {0}\n{1}", ex.Message, ex.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
foreach (var f in batch)
{
OnFolderUpdated(new FolderUpdatedEventArgs(f.UUID, false));
}
return;
}
}
/// <summary>
/// Request the contents of an inventory folder using HTTP capabilities
/// </summary>
/// <param name="folderID">The folder to search</param>
/// <param name="ownerID">The folder owners <seealso cref="UUID"/></param>
/// <param name="fetchFolders">true to return <seealso cref="InventoryManager.InventoryFolder"/>s contained in folder</param>
/// <param name="fetchItems">true to return <seealso cref="InventoryManager.InventoryItem"/>s containd in folder</param>
/// <param name="order">the sort order to return items in</param>
/// <seealso cref="InventoryManager.FolderContents"/>
public void RequestFolderContentsCap(UUID folderID, UUID ownerID, bool fetchFolders, bool fetchItems,
InventorySortOrder order)
{
Uri url = null;
string cap = ownerID == Client.Self.AgentID ? "FetchInventoryDescendents2" : "FetchLibDescendents2";
if (Client.Network.CurrentSim.Caps == null ||
null == (url = Client.Network.CurrentSim.Caps.CapabilityURI(cap)))
{
Logger.Log(cap + " capability not available in the current sim", Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
InventoryFolder folder = new InventoryFolder(folderID);
folder.OwnerID = ownerID;
folder.UUID = folderID;
RequestFolderContentsCap(new List<InventoryFolder>() { folder }, url, fetchFolders, fetchItems, order);
}
/// <summary>
/// Request the contents of an inventory folder
/// </summary>
/// <param name="folder">The folder to search</param>
/// <param name="owner">The folder owners <seealso cref="UUID"/></param>
/// <param name="folders">true to return <seealso cref="InventoryManager.InventoryFolder"/>s contained in folder</param>
/// <param name="items">true to return <seealso cref="InventoryManager.InventoryItem"/>s containd in folder</param>
/// <param name="order">the sort order to return items in</param>
/// <seealso cref="InventoryManager.FolderContents"/>
public void RequestFolderContents(UUID folder, UUID owner, bool folders, bool items,
InventorySortOrder order)
{
string cap = owner == Client.Self.AgentID ? "FetchInventoryDescendents2" : "FetchLibDescendents2";
if (Client.Settings.HTTP_INVENTORY &&
Client.Network.CurrentSim.Caps != null &&
Client.Network.CurrentSim.Caps.CapabilityURI(cap) != null)
{
RequestFolderContentsCap(folder, owner, folders, items, order);
return;
}
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = Client.Self.AgentID;
fetch.AgentData.SessionID = Client.Self.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = owner;
fetch.InventoryData.SortOrder = (int)order;
Client.Network.SendPacket(fetch);
}
/// <summary>
/// Request the contents of an inventory folder using HTTP capabilities
/// </summary>
/// <param name="folderID">The folder to search</param>
/// <param name="ownerID">The folder owners <seealso cref="UUID"/></param>
/// <param name="fetchFolders">true to return <seealso cref="InventoryManager.InventoryFolder"/>s contained in folder</param>
/// <param name="fetchItems">true to return <seealso cref="InventoryManager.InventoryItem"/>s containd in folder</param>
/// <param name="order">the sort order to return items in</param>
/// <seealso cref="InventoryManager.FolderContents"/>
public void RequestFolderContentsCap(UUID folderID, UUID ownerID, bool fetchFolders, bool fetchItems,
InventorySortOrder order)
{
Uri url = null;
if (Client.Network.CurrentSim.Caps == null ||
null == (url = Client.Network.CurrentSim.Caps.CapabilityURI("FetchInventoryDescendents2")))
{
Logger.Log("FetchInventoryDescendents2 capability not available in the current sim", Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
try
{
CapsClient request = new CapsClient(url);
request.OnComplete += (client, result, error) =>
{
try
{
if (error != null)
{
throw error;
}
OSDArray fetchedFolders = (OSDArray)((OSDMap)result)["folders"];
for (int fetchedFolderNr = 0; fetchedFolderNr < fetchedFolders.Count; fetchedFolderNr++)
{
OSDMap res = (OSDMap)fetchedFolders[fetchedFolderNr];
InventoryFolder fetchedFolder = null;
if (_Store.Contains(res["folder_id"])
&& _Store[res["folder_id"]] is InventoryFolder)
{
fetchedFolder = (InventoryFolder)_Store[res["folder_id"]];
}
else
{
fetchedFolder = new InventoryFolder(res["folder_id"]);
_Store[res["folder_id"]] = fetchedFolder;
}
fetchedFolder.DescendentCount = res["descendents"];
fetchedFolder.Version = res["version"];
fetchedFolder.OwnerID = res["owner_id"];
_Store.GetNodeFor(fetchedFolder.UUID).NeedsUpdate = false;
// Do we have any descendants
if (fetchedFolder.DescendentCount > 0)
{
// Fetch descendent folders
if (res["categories"] is OSDArray)
{
OSDArray folders = (OSDArray)res["categories"];
for (int i = 0; i < folders.Count; i++)
{
OSDMap descFolder = (OSDMap)folders[i];
InventoryFolder folder;
if (!_Store.Contains(descFolder["category_id"]))
{
folder = new InventoryFolder(descFolder["category_id"]);
folder.ParentUUID = descFolder["parent_id"];
_Store[descFolder["category_id"]] = folder;
}
else
{
folder = (InventoryFolder)_Store[descFolder["category_id"]];
}
folder.OwnerID = descFolder["agent_id"];
folder.ParentUUID = descFolder["parent_id"];
folder.Name = descFolder["name"];
folder.Version = descFolder["version"];
folder.PreferredType = (AssetType)(int)descFolder["type_default"];
}
// Fetch descendent items
OSDArray items = (OSDArray)res["items"];
for (int i = 0; i < items.Count; i++)
{
InventoryItem item = InventoryItem.FromOSD(items[i]);
_Store[item.UUID] = item;
}
}
}
OnFolderUpdated(new FolderUpdatedEventArgs(res["folder_id"], true));
}
}
catch (Exception exc)
{
Logger.Log(string.Format("Failed to fetch inventory descendants for folder id {0}: {1}\n{2}", folderID, exc.Message, exc.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
};
// Construct request
OSDMap requestedFolder = new OSDMap(1);
requestedFolder["folder_id"] = folderID;
requestedFolder["owner_id"] = ownerID;
requestedFolder["fetch_folders"] = fetchFolders;
requestedFolder["fetch_items"] = fetchItems;
requestedFolder["sort_order"] = (int)order;
OSDArray requestedFolders = new OSDArray(1);
requestedFolders.Add(requestedFolder);
OSDMap req = new OSDMap(1);
req["folders"] = requestedFolders;
request.BeginGetResponse(req, OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);
}
catch (Exception ex)
{
Logger.Log(string.Format("Failed to fetch inventory descendants for folder id {0}: {1}\n{2}", folderID, ex.Message, ex.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
}
/// <summary>
/// Request the contents of an inventory folder using HTTP capabilities
/// </summary>
/// <param name="folderID">The folder to search</param>
/// <param name="ownerID">The folder owners <seealso cref="UUID"/></param>
/// <param name="fetchFolders">true to return <seealso cref="InventoryManager.InventoryFolder"/>s contained in folder</param>
/// <param name="fetchItems">true to return <seealso cref="InventoryManager.InventoryItem"/>s containd in folder</param>
/// <param name="order">the sort order to return items in</param>
/// <seealso cref="InventoryManager.FolderContents"/>
public void RequestFolderContentsCap(UUID folderID, UUID ownerID, bool fetchFolders, bool fetchItems,
InventorySortOrder order)
{
Uri url = null;
if (Client.Network.CurrentSim.Caps == null ||
null == (url = Client.Network.CurrentSim.Caps.CapabilityURI("FetchInventoryDescendents2")))
{
Logger.Log("FetchInventoryDescendents2 capability not available in the current sim", Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
try
{
CapsClient request = new CapsClient(url);
request.OnComplete += (client, result, error) =>
{
try
{
if (error != null) throw error;
OSDArray fetchedFolders = (OSDArray)((OSDMap)result)["folders"];
for (int fetchedFolderNr = 0; fetchedFolderNr < fetchedFolders.Count; fetchedFolderNr++)
{
OSDMap res = (OSDMap)fetchedFolders[fetchedFolderNr];
InventoryFolder fetchedFolder = null;
if (_Store.Contains(res["folder_id"])
&& _Store[res["folder_id"]] is InventoryFolder)
{
fetchedFolder = (InventoryFolder)_Store[res["folder_id"]];
}
else
{
fetchedFolder = new InventoryFolder(res["folder_id"]);
_Store[res["folder_id"]] = fetchedFolder;
}
fetchedFolder.DescendentCount = res["descendents"];
fetchedFolder.Version = res["version"];
fetchedFolder.OwnerID = res["owner_id"];
_Store.GetNodeFor(fetchedFolder.UUID).NeedsUpdate = false;
// Do we have any descendants
if (fetchedFolder.DescendentCount > 0)
{
// Fetch descendent folders
if (res["categories"] is OSDArray)
{
OSDArray folders = (OSDArray)res["categories"];
for (int i = 0; i < folders.Count; i++)
{
OSDMap descFolder = (OSDMap)folders[i];
InventoryFolder folder;
if (!_Store.Contains(descFolder["category_id"]))
{
folder = new InventoryFolder(descFolder["category_id"]);
folder.ParentUUID = descFolder["parent_id"];
_Store[descFolder["category_id"]] = folder;
}
else
{
folder = (InventoryFolder)_Store[descFolder["category_id"]];
}
folder.OwnerID = descFolder["agent_id"];
folder.ParentUUID = descFolder["parent_id"];
folder.Name = descFolder["name"];
folder.Version = descFolder["version"];
folder.PreferredType = (AssetType)(int)descFolder["type_default"];
}
// Fetch descendent items
OSDArray items = (OSDArray)res["items"];
for (int i = 0; i < items.Count; i++)
{
OSDMap descItem = (OSDMap)items[i];
InventoryType type = (InventoryType)descItem["inv_type"].AsInteger();
if (type == InventoryType.Texture && (AssetType)descItem["type"].AsInteger() == AssetType.Object)
{
type = InventoryType.Attachment;
}
InventoryItem item = CreateInventoryItem(type, descItem["item_id"]);
item.ParentUUID = descItem["parent_id"];
item.Name = descItem["name"];
item.Description = descItem["desc"];
item.OwnerID = descItem["agent_id"];
item.AssetUUID = descItem["asset_id"];
item.AssetType = (AssetType)descItem["type"].AsInteger();
item.CreationDate = Utils.UnixTimeToDateTime(descItem["created_at"]);
item.Flags = descItem["flags"];
OSDMap perms = (OSDMap)descItem["permissions"];
item.CreatorID = perms["creator_id"];
item.LastOwnerID = perms["last_owner_id"];
item.Permissions = new Permissions(perms["base_mask"], perms["everyone_mask"], perms["group_mask"], perms["next_owner_mask"], perms["owner_mask"]);
item.GroupOwned = perms["is_owner_group"];
item.GroupID = perms["group_id"];
OSDMap sale = (OSDMap)descItem["sale_info"];
item.SalePrice = sale["sale_price"];
item.SaleType = (SaleType)sale["sale_type"].AsInteger();
_Store[item.UUID] = item;
}
}
}
OnFolderUpdated(new FolderUpdatedEventArgs(res["folder_id"], true));
}
}
catch (Exception exc)
{
Logger.Log(string.Format("Failed to fetch inventory descendants for folder id {0}: {1}\n{2}", folderID, exc.Message, exc.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
};
// Construct request
OSDMap requestedFolder = new OSDMap(1);
requestedFolder["folder_id"] = folderID;
requestedFolder["owner_id"] = ownerID;
requestedFolder["fetch_folders"] = fetchFolders;
requestedFolder["fetch_items"] = fetchItems;
requestedFolder["sort_order"] = (int)order;
OSDArray requestedFolders = new OSDArray(1);
requestedFolders.Add(requestedFolder);
OSDMap req = new OSDMap(1);
req["folders"] = requestedFolders;
request.BeginGetResponse(req, OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);
}
catch (Exception ex)
{
Logger.Log(string.Format("Failed to fetch inventory descendants for folder id {0}: {1}\n{2}", folderID, ex.Message, ex.StackTrace.ToString()), Helpers.LogLevel.Warning, Client);
OnFolderUpdated(new FolderUpdatedEventArgs(folderID, false));
return;
}
}
public void RequestFolderContents(UUID folder, UUID owner, bool folders, bool items,
InventorySortOrder order)
{
FetchInventoryDescendentsPacket fetch = new FetchInventoryDescendentsPacket();
fetch.AgentData.AgentID = frame.AgentID;
fetch.AgentData.SessionID = frame.SessionID;
fetch.InventoryData.FetchFolders = folders;
fetch.InventoryData.FetchItems = items;
fetch.InventoryData.FolderID = folder;
fetch.InventoryData.OwnerID = owner;
fetch.InventoryData.SortOrder = (int)order;
proxy.InjectPacket(fetch, Direction.Outgoing);
}