bool IInventoryFolderContentServiceInterface.TryGetValue(UUID principalID, UUID folderID, out InventoryFolderContent inventoryFolderContent)
{
IValue iv;
HttpStatusCode statuscode;
using (Stream s = new HttpClient.Get($"{m_CapabilityUri}category/{folderID}?depth=1")
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest(out statuscode))
{
if (statuscode != HttpStatusCode.OK)
{
inventoryFolderContent = default(InventoryFolderContent);
return(false);
}
iv = LlsdXml.Deserialize(s);
}
var resmap = iv as Map;
if (resmap == null)
{
throw new InvalidDataException();
}
inventoryFolderContent = new InventoryFolderContent();
inventoryFolderContent.FolderID = resmap["category_id"].AsUUID;
inventoryFolderContent.Owner = new UGUI(resmap["agent_id"].AsUUID);
inventoryFolderContent.Folders = ExtractFolders(resmap);
inventoryFolderContent.Items = ExtractItems(resmap);
return(true);
}
private static void WriteInventoryFolderContent(XmlTextWriter writer, InventoryFolderContent folder,
bool fetch_folders,
bool fetch_items, UUID agentID)
{
writer.WriteStartElement("map");
writer.WriteKeyValuePair("agent_id", folder.Owner.ID);
writer.WriteKeyValuePair("descendents", folder.Folders.Count + folder.Items.Count);
writer.WriteKeyValuePair("folder_id", folder.FolderID);
if (fetch_folders)
{
writer.WriteStartElement("key");
writer.WriteValue("categories");
writer.WriteEndElement();
writer.WriteStartElement("array");
foreach (var childfolder in folder.Folders)
{
writer.WriteStartElement("map");
writer.WriteKeyValuePair("folder_id", childfolder.ID);
writer.WriteKeyValuePair("parent_id", childfolder.ParentFolderID);
writer.WriteKeyValuePair("name", childfolder.Name);
if (childfolder.DefaultType != AssetType.RootFolder)
{
writer.WriteKeyValuePair("type", (byte)childfolder.DefaultType);
}
else
{
writer.WriteKeyValuePair("type", -1);
}
writer.WriteKeyValuePair("preferred_type", -1);
writer.WriteKeyValuePair("version", childfolder.Version);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
if (fetch_items)
{
writer.WriteStartElement("key");
writer.WriteValue("items");
writer.WriteEndElement();
writer.WriteStartElement("array");
foreach (var childitem in folder.Items)
{
writer.WriteStartElement("map");
WriteInventoryItem(childitem, writer, agentID);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteKeyValuePair("owner_id", folder.Owner.ID);
writer.WriteKeyValuePair("version", folder.Version);
writer.WriteEndElement();
}
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);
}
public bool TryGetValue(UUID principalID, UUID folderID, out InventoryFolderContent inventoryFolderContent)
{
InventoryFolder folder;
if(!m_Service.TryGetValue(principalID, folderID, out folder))
{
inventoryFolderContent = null;
return false;
}
inventoryFolderContent = new InventoryFolderContent
{
Version = folder.Version,
Owner = folder.Owner,
FolderID = folder.ID
};
try
{
inventoryFolderContent.Folders = m_Service.GetFolders(principalID, folderID);
}
catch
{
inventoryFolderContent.Folders = new List<InventoryFolder>();
}
try
{
inventoryFolderContent.Items = m_Service.GetItems(principalID, folderID);
}
catch
{
inventoryFolderContent.Items = new List<InventoryItem>();
}
return true;
}
bool IInventoryFolderContentServiceInterface.TryGetValue(UUID principalID, UUID folderID, out InventoryFolderContent inventoryFolderContent)
{
throw new NotImplementedException();
}
private Dictionary <UUID, KeyValuePair <InventoryFolder, InventoryFolderContent> > GetFolderContents(UUID[] folderids, bool fetch_children)
{
var folderidsreq = new AnArray();
var reqmap = new Map
{
["folder_ids"] = folderidsreq
};
foreach (UUID folderid in folderids)
{
folderidsreq.Add(new Map {
{ "folder_id", folderid }, { "fetch_folders", fetch_children }, { "fetch_items", fetch_children }
});
}
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(reqmap, ms);
reqdata = ms.ToArray();
}
Map resdata;
using (Stream s = new HttpClient.Post(m_CapabilityUri, "application/llsd+xml", reqdata.Length,
(Stream o) => o.Write(reqdata, 0, reqdata.Length))
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest())
{
resdata = LlsdXml.Deserialize(s) as Map;
}
if (resdata == null)
{
throw new InvalidDataException();
}
AnArray foldersres;
var resultset = new Dictionary <UUID, KeyValuePair <InventoryFolder, InventoryFolderContent> >();
if (!resdata.TryGetValue("folders", out foldersres))
{
return(resultset);
}
foreach (IValue folderiv in foldersres)
{
var folderdata = folderiv as Map;
if (folderdata == null)
{
continue;
}
var folder = new InventoryFolder(folderdata["folder_id"].AsUUID)
{
Owner = new UGUI(folderdata["owner_id"].AsUUID),
Version = folderdata["version"].AsInt,
ParentFolderID = folderdata["parent_id"].AsUUID,
};
var content = new InventoryFolderContent
{
Version = folderdata["version"].AsInt,
FolderID = folderdata["folder_id"].AsUUID,
Owner = new UGUI(folderdata["owner_id"].AsUUID)
};
AnArray categories;
if (folderdata.TryGetValue("categories", out categories))
{
foreach (IValue categoryiv in categories)
{
var category = categoryiv as Map;
if (category == null)
{
continue;
}
content.Folders.Add(new InventoryFolder(category["folder_id"].AsUUID)
{
Name = category["name"].ToString(),
ParentFolderID = category["parent_id"].AsUUID,
DefaultType = (AssetType)category["type"].AsInt,
Version = category["version"].AsInt
});
}
}
AnArray childitems;
if (folderdata.TryGetValue("items", out childitems))
{
foreach (IValue childiv in childitems)
{
var childdata = childiv as Map;
if (childdata == null)
{
continue;
}
if (childdata["parent_id"].AsUUID != folder.ID)
{
continue;
}
var permissions = (Map)childdata["permissions"];
var sale_info = (Map)childdata["sale_info"];
var item = new InventoryItem(childdata["item_id"].AsUUID)
{
AssetID = childdata["asset_id"].AsUUID,
CreationDate = Date.UnixTimeToDateTime(childdata["created_at"].AsULong),
Description = childdata["desc"].ToString(),
Flags = (InventoryFlags)childdata["flags"].AsInt,
InventoryType = (InventoryType)childdata["inv_type"].AsInt,
Name = childdata["name"].ToString(),
ParentFolderID = childdata["parent_id"].AsUUID,
AssetType = (AssetType)childdata["type"].AsInt,
Creator = new UGUI(permissions["creator_id"].AsUUID),
Group = new UGI(permissions["group_id"].AsUUID),
IsGroupOwned = permissions["is_owner_group"].AsBoolean,
LastOwner = new UGUI(permissions["last_owner_id"].AsUUID),
Owner = new UGUI(permissions["owner_id"].AsUUID),
SaleInfo = new InventoryItem.SaleInfoData
{
Price = sale_info["sale_price"].AsInt,
Type = (InventoryItem.SaleInfoData.SaleType)sale_info["sale_type"].AsInt
}
};
item.Permissions.Base = (InventoryPermissionsMask)permissions["base_mask"].AsInt;
item.Permissions.EveryOne = (InventoryPermissionsMask)permissions["everyone_mask"].AsInt;
item.Permissions.Group = (InventoryPermissionsMask)permissions["group_mask"].AsInt;
item.Permissions.NextOwner = (InventoryPermissionsMask)permissions["next_owner_mask"].AsInt;
item.Permissions.Current = (InventoryPermissionsMask)permissions["owner_mask"].AsInt;
content.Items.Add(item);
}
}
resultset.Add(folder.ID, new KeyValuePair <InventoryFolder, InventoryFolderContent>(folder, content));
}
return(resultset);
}
bool IInventoryFolderContentServiceInterface.TryGetValue(UUID principalID, UUID folderID, out InventoryFolderContent inventoryFolderContent)
{
InventoryFolder folder;
return(TryGetValue(folderID, out folder, out inventoryFolderContent));
}
public void LoadFromCurrentOutfit(UGUI principal, InventoryServiceInterface inventoryService, AssetServiceInterface assetService, Action <string> logOutput = null)
{
lock (m_Lock)
{
if (CurrentOutfitFolderID == UUID.Zero)
{
InventoryFolder folder;
if (!inventoryService.Folder.TryGetValue(principal.ID, AssetType.CurrentOutfitFolder, out folder))
{
throw new BakeErrorException("Outfit folder missing");
}
CurrentOutfitFolderID = folder.ID;
}
InventoryFolderContent folderContent = inventoryService.Folder.Content[principal.ID, CurrentOutfitFolderID];
AppearanceSerial = folderContent.Version;
var items = new List <InventoryItem>();
var itemlinks = new List <UUID>();
foreach (var item in folderContent.Items)
{
if (item.AssetType == AssetType.Link &&
item.InventoryType == InventoryType.Wearable)
{
items.Add(item);
itemlinks.Add(item.AssetID);
}
}
var actualItems = itemlinks.Count != 0 ? inventoryService.Item[principal.ID, itemlinks] : new List <InventoryItem>();
var actualItemsInDict = new Dictionary <UUID, InventoryItem>();
foreach (var item in actualItems)
{
actualItemsInDict.Add(item.ID, item);
}
var outfitItems = new Dictionary <UUID, OutfitItem>();
logOutput?.Invoke(string.Format("Processing assets for baking agent {0}", principal.ToString()));
AvatarWearables.Clear();
foreach (var linkItem in items)
{
InventoryItem actualItem;
if (actualItemsInDict.TryGetValue(linkItem.AssetID, out actualItem))
{
AssetData outfitData;
Wearable wearableData;
if (assetService.TryGetValue(actualItem.AssetID, out outfitData))
{
#if DEBUG
logOutput?.Invoke(string.Format("Using item {0} {1} ({2}): asset {3}", actualItem.AssetType.ToString(), actualItem.Name, actualItem.ID, actualItem.AssetID));
#endif
try
{
wearableData = new Wearable(outfitData);
}
catch (Exception e)
{
string info = string.Format("Asset {0} for agent {1} ({2}) failed to decode as wearable", actualItem.AssetID, principal.ToString(), principal.ID);
m_Log.ErrorFormat(info, e);
throw new BakeErrorException(info, e);
}
var oitem = new OutfitItem(LinkDescriptionToInt(linkItem.Description), wearableData);
outfitItems.Add(linkItem.AssetID, oitem);
List <AgentWearables.WearableInfo> wearables;
if (!AvatarWearables.TryGetValue(wearableData.Type, out wearables))
{
wearables = new List <AgentWearables.WearableInfo>();
AvatarWearables.Add(wearableData.Type, wearables);
}
wearables.Add(new AgentWearables.WearableInfo(linkItem.AssetID, actualItem.AssetID));
}
else
{
logOutput?.Invoke(string.Format("Missing asset {0} for inventory item {1} ({2})", actualItem.AssetID, actualItem.Name, actualItem.ID));
}
}
else
{
logOutput?.Invoke(string.Format("Missing inventory item {0} for link {1} ({2}", linkItem.AssetID, linkItem.Name, linkItem.ID));
}
}
logOutput?.Invoke(string.Format("Setting current outfit for baking agent {0}", principal.ToString()));
SetCurrentOutfit(outfitItems);
}
}
public FolderGetStack(InventoryFolderContent content, Map embedded, int depth)
{
Content = content;
Depth = depth;
Embedded = embedded;
}
