private static void AddUpdateDeleteInventories(ZipArchiveEntry inventoriesEntry)
{
Console.WriteLine("inventories.csv is {0} bytes", inventoriesEntry.Length);
IEnumerable<Inventory> inventories = null;
using (var entryStream = inventoriesEntry.Open())
{
Console.WriteLine("Starting inventories at {0:hh:mm:ss.fff}", DateTime.Now);
var stopwatch = new Stopwatch();
stopwatch.Start();
var reader = new StreamReader(entryStream);
var csv = new CsvReader(reader);
csv.Configuration.RegisterClassMap(new InventoryMap());
StringBuilder invForImport = new StringBuilder();
inventories = csv.GetRecords<Inventory>().Where(i => !i.IsDead);
var inventoryCollection = new InventoryCollection();
inventoryCollection.SetItems(inventories);
var importer = new NpgsqlBulkImporter(ConfigurationManager.ConnectionStrings["spurious"].ConnectionString, stopwatch);
importer.BulkImport("inventories", inventoryCollection);
stopwatch.Stop();
Console.WriteLine("Finished inventories at {0:hh:mm:ss.fff}, taking {1}", DateTime.Now, stopwatch.Elapsed);
}
}
public InventoryItemControl(byte myslot,ref InventoryCollection inventoryCollection)
{
this.Slot = myslot;
if (!inventoryCollection.ContainsKey(myslot))
{
Item = new InventoryItem();
Item.Count = 0;
Item.Damage = 0;
Item.ID = 0;
Item.Slot = myslot;
} else
Item = inventoryCollection[myslot];
Block b = Blocks.Get(0x00);
try
{
b = Blocks.Get(Item.ID);
}
catch (Exception) { }
Img = b.Image;
_Name = b.Name;
Render();
this.Inventory = inventoryCollection;
this.Inventory.Changed += new InventoryCollection.InventoryChangedDelegate(inventoryCollection_Changed);
this.AllowDrop = true;
this.DragDrop += new System.Windows.Forms.DragEventHandler(this.InventoryItem_DragDrop);
this.DragEnter += new System.Windows.Forms.DragEventHandler(this.InventoryItem_DragEnter);
this.MouseDown += new MouseEventHandler(InventoryItem_MouseDown);
this.KeyDown += new KeyEventHandler(InventoryItem_KeyDown);
this.KeyUp += new KeyEventHandler(InventoryItem_KeyUp);
Changed += Render;
}
internal ProductVariant(Guid productKey, ProductAttributeCollection attributes, InventoryCollection inventory, bool template, string name, string sku, decimal price)
: base(name, sku, price)
{
Mandate.ParameterNotNull(attributes, "attributes");
Mandate.ParameterNotNull(inventory, "inventory");
_productKey = productKey;
_attibutes = attributes;
_template = template;
}
internal ProductBase(string name, string sku, decimal price, InventoryCollection inventory)
{
Mandate.ParameterNotNullOrEmpty(name, "name");
Mandate.ParameterNotNullOrEmpty(sku, "sku");
Mandate.ParameterNotNull(inventory, "inventory");
_name = name;
_sku = sku;
_price = price;
_inventory = inventory;
}
///<summary>
/// Find an item given a PATH_DELIMITOR delimited path starting from this folder.
///
/// This method does not handle paths that contain multiple delimitors
///
/// FIXME: We do not yet handle situations where folders or items have the same name. We could handle this by some
/// XPath like expression
///
/// FIXME: Delimitors which occur in names themselves are not currently escapable.
///</summary>
///<param name = "inventoryService">
/// Inventory service to query
///</param>
///<param name = "startFolder">
/// The folder from which the path starts
///</param>
///<param name = "path">
/// <param name = "path">
/// The path to the required item.
/// </param>
/// <returns>null if the item is not found</returns>
public static InventoryItemBase FindItemByPath(
IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
{
// If the path isn't just / then trim any starting extraneous slashes
path = path.TrimStart(new[] { PATH_DELIMITER });
string[] components = SplitEscapedPath(path);
components[0] = UnescapePath(components[0]);
//string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None);
if (components.Length == 1)
{
// MainConsole.Instance.DebugFormat(
// "FOUND SINGLE COMPONENT [{0}]. Looking for this in [{1}] {2}",
// components[0], startFolder.Name, startFolder.ID);
List <InventoryItemBase> items = inventoryService.GetFolderItems(startFolder.Owner, startFolder.ID);
// MainConsole.Instance.DebugFormat("[INVENTORY ARCHIVE UTILS]: Found {0} items in FindItemByPath()", items.Count);
#if (!ISWIN)
foreach (InventoryItemBase item in items)
{
if (item.Name == components[0])
{
return(item);
}
}
return(null);
#else
return(items.FirstOrDefault(item => item.Name == components[0]));
#endif
}
else
{
// MainConsole.Instance.DebugFormat("FOUND COMPONENTS [{0}] and [{1}]", components[0], components[1]);
InventoryCollection contents = inventoryService.GetFolderContent(startFolder.Owner, startFolder.ID);
return((from folder in contents.Folders
where folder.Name == components[0]
select FindItemByPath(inventoryService, folder, components[1])).FirstOrDefault());
}
}
public virtual InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
{
// This method doesn't receive a valud principal id from the
// connector. So we disregard the principal and look
// by ID.
//
//m_log.DebugFormat("[XINVENTORY SERVICE]: Fetch contents for folder {0}", folderID.ToString());
InventoryCollection inventory = new InventoryCollection();
inventory.OwnerID = principalID;
inventory.Folders = new List <InventoryFolderBase>();
inventory.Items = new List <InventoryItemBase>();
XInventoryFolder[] folders = m_Database.GetFolders(
new string[] { "parentFolderID" },
new string[] { folderID.ToString() });
foreach (XInventoryFolder x in folders)
{
//m_log.DebugFormat("[XINVENTORY]: Adding folder {0} to response", x.folderName);
inventory.Folders.Add(ConvertToOpenSim(x));
}
XInventoryItem[] items = m_Database.GetItems(
new string[] { "parentFolderID" },
new string[] { folderID.ToString() });
foreach (XInventoryItem i in items)
{
//m_log.DebugFormat("[XINVENTORY]: Adding item {0} to response", i.inventoryName);
inventory.Items.Add(ConvertToOpenSim(i));
}
InventoryFolderBase f = new InventoryFolderBase(folderID, principalID);
f = GetFolder(f);
if (f != null)
{
inventory.Version = f.Version;
inventory.OwnerID = f.Owner;
}
inventory.FolderID = folderID;
return(inventory);
}
/// <summary>
/// Save an inventory folder
/// </summary>
/// <param name="inventoryFolder">The inventory folder to save</param>
/// <param name="path">The path to which the folder should be saved</param>
/// <param name="saveThisFolderItself">If true, save this folder itself. If false, only saves contents</param>
/// <param name="options"></param>
/// <param name="userAccountService"></param>
protected void SaveInvFolder(
InventoryFolderBase inventoryFolder, string path, bool saveThisFolderItself,
Dictionary <string, object> options, IUserAccountService userAccountService)
{
if (options.ContainsKey("excludefolders"))
{
if (((List <String>)options["excludefolders"]).Contains(inventoryFolder.Name) ||
((List <String>)options["excludefolders"]).Contains(inventoryFolder.ID.ToString()))
{
if (options.ContainsKey("verbose"))
{
m_log.InfoFormat(
"[INVENTORY ARCHIVER]: Skipping folder {0} at {1}",
inventoryFolder.Name, path);
}
return;
}
}
if (options.ContainsKey("verbose"))
{
m_log.InfoFormat("[INVENTORY ARCHIVER]: Saving folder {0}", inventoryFolder.Name);
}
if (saveThisFolderItself)
{
path += CreateArchiveFolderName(inventoryFolder);
// We need to make sure that we record empty folders
m_archiveWriter.WriteDir(path);
}
InventoryCollection contents
= m_scene.InventoryService.GetFolderContent(inventoryFolder.Owner, inventoryFolder.ID);
foreach (InventoryFolderBase childFolder in contents.Folders)
{
SaveInvFolder(childFolder, path, true, options, userAccountService);
}
foreach (InventoryItemBase item in contents.Items)
{
SaveInvItem(item, path, options, userAccountService);
}
}
public override InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
{
InventoryCollection coll = null;
if (!IsWithinSuitcaseTree(principalID, folderID))
{
return(new InventoryCollection());
}
coll = base.GetFolderContent(principalID, folderID);
if (coll == null)
{
m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Something wrong with user {0}'s suitcase folder", principalID);
coll = new InventoryCollection();
}
return(coll);
}
public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
{
// Uncomment me to simulate a slow responding inventory server
//Thread.Sleep(16000);
InventoryCollection invCollection = new InventoryCollection();
List <InventoryItemBase> items = GetFolderItems(userID, folderID);
List <InventoryFolderBase> folders = RequestSubFolders(folderID);
invCollection.UserID = userID;
invCollection.Folders = folders;
invCollection.Items = items;
m_log.DebugFormat("[INVENTORY SERVICE]: Found {0} items and {1} folders in folder {2}", items.Count, folders.Count, folderID);
return(invCollection);
}
void Start()
{
CardDatabase.LoadAllCards();
GearDatabase.LoadAllGear();
if (GameplayContext.CurrentInventory is null || GameplayContext.RequestReset)
{
playerInventory = new InventoryCollection();
//two legs
playerInventory.AddItem(GearDatabase.GetGearDataByID(0));
playerInventory.AddItem(GearDatabase.GetGearDataByID(0));
//two melee arm
playerInventory.AddItem(GearDatabase.GetGearDataByID(1), 2);
//two rifle arm
playerInventory.AddItem(GearDatabase.GetGearDataByID(3), 2);
GameplayContext.CurrentInventory = playerInventory;
Debug.Log("made new inventory");
}
/// <summary>
/// Find a folder given a PATH_DELIMITER delimited path starting from this folder
/// </summary>
/// This method does not handle paths that contain multiple delimiters
///
/// FIXME: We have no way of distinguishing folders with the same path.
///
/// FIXME: Delimiters which occur in names themselves are not currently escapable.
/// <param name="inventoryService">
/// Inventory service to query
/// </param>
/// <param name="startFolder">
/// The folder from which the path starts
/// </param>
/// <param name="path">
/// The path to the required folder.
/// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
/// </param>
/// <returns>An empty list if the folder is not found, otherwise a list of all folders that match the name</returns>
public static List <InventoryFolderBase> FindFolderByPath(
IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
{
List <InventoryFolderBase> foundFolders = new List <InventoryFolderBase>();
if (path == string.Empty)
{
foundFolders.Add(startFolder);
return(foundFolders);
}
path = path.Trim();
if (path == PATH_DELIMITER.ToString())
{
foundFolders.Add(startFolder);
return(foundFolders);
}
// If the path isn't just / then trim any starting extraneous slashes
path = path.TrimStart(new[] { PATH_DELIMITER });
// MainConsole.Instance.DebugFormat("[INVENTORY ARCHIVE UTILS]: Adjusted path in FindFolderByPath() is [{0}]", path);
string[] components = SplitEscapedPath(path);
components[0] = UnescapePath(components[0]);
//string[] components = path.Split(new string[] { PATH_DELIMITER.ToString() }, 2, StringSplitOptions.None);
InventoryCollection contents = inventoryService.GetFolderContent(startFolder.Owner, startFolder.ID);
foreach (InventoryFolderBase folder in contents.Folders.Where(folder => folder.Name == components[0]))
{
if (components.Length > 1)
{
foundFolders.AddRange(FindFolderByPath(inventoryService, folder, components[1]));
}
else
{
foundFolders.Add(folder);
}
}
return(foundFolders);
}
public BackendResponse TryFetchInventory(Uri owner, out InventoryCollection inventory)
{
inventory = null;
BackendResponse ret;
List <InventoryFolderWithChildren> folders;
ret = TryFetchFolderList(owner, out folders);
if (ret == BackendResponse.Success)
{
// Add the retrieved folders to the inventory collection
inventory = new InventoryCollection();
inventory.Folders = new Dictionary <UUID, InventoryFolderWithChildren>(folders.Count);
foreach (InventoryFolderWithChildren folder in folders)
{
inventory.Folders[folder.ID] = folder;
}
// Fetch inventory items
UUID ownerID;
if (Utils.TryGetOpenSimUUID(owner, out ownerID))
{
inventory.UserID = ownerID;
inventory.Items = new Dictionary <UUID, InventoryItemBase>();
foreach (InventoryFolderWithChildren folder in folders)
{
foreach (InventoryItemBase item in m_inventoryService.RequestFolderItems(folder.ID))
{
inventory.Items.Add(item.ID, item);
}
}
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
}
m_server.MetricsProvider.LogInventoryFetchInventory(EXTENSION_NAME, ret, owner, DateTime.Now);
return(ret);
}
/// <summary>
/// Find a folder given a PATH_DELIMITER delimited path starting from this folder
/// </summary>
///
/// This method does not handle paths that contain multiple delimitors
///
/// FIXME: We have no way of distinguishing folders with the same path.
///
/// FIXME: Delimitors which occur in names themselves are not currently escapable.
///
/// <param name="inventoryService">
/// Inventory service to query
/// </param>
/// <param name="startFolder">
/// The folder from which the path starts
/// </param>
/// <param name="path">
/// The path to the required folder.
/// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
/// </param>
/// <returns>An empty list if the folder is not found, otherwise a list of all folders that match the name</returns>
public static List <InventoryFolderBase> FindFolderByPath(
IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
{
List <InventoryFolderBase> foundFolders = new List <InventoryFolderBase>();
if (path == string.Empty)
{
foundFolders.Add(startFolder);
return(foundFolders);
}
path = path.Trim();
if (path == PATH_DELIMITER.ToString())
{
foundFolders.Add(startFolder);
return(foundFolders);
}
string[] components = SplitEscapedPath(path);
components[0] = UnescapePath(components[0]);
//string[] components = path.Split(new string[] { PATH_DELIMITER.ToString() }, 2, StringSplitOptions.None);
InventoryCollection contents = inventoryService.GetFolderContent(startFolder.Owner, startFolder.ID);
foreach (InventoryFolderBase folder in contents.Folders)
{
if (folder.Name == components[0])
{
if (components.Length > 1)
{
foundFolders.AddRange(FindFolderByPath(inventoryService, folder, components[1]));
}
else
{
foundFolders.Add(folder);
}
}
}
return(foundFolders);
}
byte[] HandleGetFolderContent(Dictionary <string, object> request)
{
Dictionary <string, object> result = new Dictionary <string, object>();
UUID principal = UUID.Zero;
UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
UUID folderID = UUID.Zero;
UUID.TryParse(request["FOLDER"].ToString(), out folderID);
InventoryCollection icoll = m_InventoryService.GetFolderContent(principal, folderID);
if (icoll != null)
{
Dictionary <string, object> folders = new Dictionary <string, object>();
int i = 0;
if (icoll.Folders != null)
{
foreach (InventoryFolderBase f in icoll.Folders)
{
folders["folder_" + i.ToString()] = EncodeFolder(f);
i++;
}
result["FOLDERS"] = folders;
}
if (icoll.Items != null)
{
i = 0;
Dictionary <string, object> items = new Dictionary <string, object>();
foreach (InventoryItemBase it in icoll.Items)
{
items["item_" + i.ToString()] = EncodeItem(it);
i++;
}
result["ITEMS"] = items;
}
}
string xmlString = ServerUtils.BuildXmlResponse(result);
//m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
return(Util.UTF8NoBomEncoding.GetBytes(xmlString));
}
/// <summary>
/// Construct an LLSD reply packet to a CAPS inventory request
/// </summary>
/// <param name="invFetch"></param>
/// <returns></returns>
private LLSDInventoryDescendents FetchInventoryReply(LLSDFetchInventoryDescendents invFetch)
{
LLSDInventoryDescendents reply = new LLSDInventoryDescendents();
LLSDInventoryFolderContents contents = new LLSDInventoryFolderContents();
contents.agent_id = m_agentID;
contents.owner_id = invFetch.owner_id;
contents.folder_id = invFetch.folder_id;
reply.folders.Array.Add(contents);
InventoryCollection inv = new InventoryCollection();
inv.Folders = new List <InventoryFolderBase>();
inv.Items = new List <InventoryItemBase>();
int version = 0;
if (CAPSFetchInventoryDescendents != null)
{
inv = CAPSFetchInventoryDescendents(m_agentID, invFetch.folder_id, invFetch.owner_id, invFetch.fetch_folders, invFetch.fetch_items, invFetch.sort_order, out version);
}
if (inv.Folders != null)
{
foreach (InventoryFolderBase invFolder in inv.Folders)
{
contents.categories.Array.Add(ConvertInventoryFolder(invFolder));
}
}
if (inv.Items != null)
{
foreach (InventoryItemBase invItem in inv.Items)
{
contents.items.Array.Add(ConvertInventoryItem(invItem));
}
}
contents.descendents = contents.items.Array.Count + contents.categories.Array.Count;
contents.version = version;
return(reply);
}
public InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
{
InventoryCollection inventory = new InventoryCollection();
inventory.Folders = new List <InventoryFolderBase>();
inventory.Items = new List <InventoryItemBase>();
inventory.UserID = principalID;
try
{
Dictionary <string, object> ret = MakeRequest("GETFOLDERCONTENT",
new Dictionary <string, object> {
{ "PRINCIPAL", principalID.ToString() },
{ "FOLDER", folderID.ToString() }
});
if (!CheckReturn(ret))
{
return(null);
}
Dictionary <string, object> folders =
(Dictionary <string, object>)ret["FOLDERS"];
Dictionary <string, object> items =
(Dictionary <string, object>)ret["ITEMS"];
foreach (Object o in folders.Values) // getting the values directly, we don't care about the keys folder_i
{
inventory.Folders.Add(BuildFolder((Dictionary <string, object>)o));
}
foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
{
inventory.Items.Add(BuildItem((Dictionary <string, object>)o));
}
}
catch (Exception e)
{
m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Exception in GetFolderContent: {0}", e.Message);
}
return(inventory);
}
public InventoryCollection[] GetMultipleFoldersContent(UUID userID, UUID[] folderIDs)
{
string invURL = GetInventoryServiceURL(userID);
if (invURL == null) // not there, forward to local inventory connector to resolve
{
return(m_LocalGridInventoryService.GetMultipleFoldersContent(userID, folderIDs));
}
else
{
InventoryCollection[] coll = new InventoryCollection[folderIDs.Length];
int i = 0;
foreach (UUID fid in folderIDs)
{
coll[i++] = GetFolderContent(userID, fid);
}
return(coll);
}
}
public override InventoryCollection GetFolderContent(UUID userID, UUID folderID)
{
UUID sessionID = GetSessionID(userID);
try
{
return(m_RemoteConnector.GetFolderContent(userID.ToString(), folderID, sessionID));
}
catch (Exception e)
{
m_log.ErrorFormat("[INVENTORY CONNECTOR]: GetFolderContent operation failed, {0} {1}",
e.Source, e.Message);
}
InventoryCollection nullCollection = new InventoryCollection();
nullCollection.Folders = new List <InventoryFolderBase>();
nullCollection.Items = new List <InventoryItemBase>();
nullCollection.UserID = userID;
return(nullCollection);
}
public override InventoryCollection GetRecursiveFolderContents(UUID userId, UUID folderId)
{
m_log.InfoFormat("[LOCAL INVENTORY SERVICE]: Processing request for folder {0} recursive contents", folderId);
InventoryCollection invCollection = new InventoryCollection();
List <InventoryFolderBase> folders = GetRecursiveFolderList(folderId);
List <InventoryItemBase> items = RequestItemsInMultipleFolders(folders);
invCollection.UserID = UUID.Zero;
invCollection.Folders = folders;
invCollection.Items = items;
m_log.InfoFormat(
"[LOCAL INVENTORY SERVICE]: Sending back recursive folder contents containing {0} folders and {1} items",
invCollection.Folders.Count, invCollection.Items.Count);
return(invCollection);
}
/// <summary>
///
/// </summary>
/// <param name="gear">the gear to equip</param>
/// <param name="inventory">the inventory to return unequipped items into</param>
public void SetEquippedGear(GearData gear, InventoryCollection inventory)
{
if (equippedGear != null && inventory != null)
{
inventory.AddItem(equippedGear);
}
equippedGear = gear;
if (gear != null)
{
icon.enabled = true;
icon.sprite = gear.art;
UpdateDependants(true, inventory);
}
else
{
icon.enabled = false;
UpdateDependants(false, inventory);
}
}
public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
{
InventoryCollection invCol = m_InventoryService.GetFolderContent(userID, folderID);
if (UserManager != null)
{
// Protect ourselves against the caller subsequently modifying the items list
List <InventoryItemBase> items = new List <InventoryItemBase>(invCol.Items);
Util.FireAndForget(delegate
{
foreach (InventoryItemBase item in items)
{
UserManager.AddUser(item.CreatorIdAsUuid, item.CreatorData);
}
});
}
return(invCol);
}
public InventoryCollection FetchDescendants(InventoryFolderBase fb)
{
m_log.Info("[HGStandaloneInvService]: Processing request for folder " + fb.ID);
// Uncomment me to simulate a slow responding inventory server
//Thread.Sleep(16000);
InventoryCollection invCollection = new InventoryCollection();
List <InventoryItemBase> items = m_inventoryService.RequestFolderItems(fb.ID);
List <InventoryFolderBase> folders = m_inventoryService.RequestSubFolders(fb.ID);
invCollection.UserID = fb.Owner;
invCollection.Folders = folders;
invCollection.Items = items;
m_log.DebugFormat("[HGStandaloneInvService]: Found {0} items and {1} folders", items.Count, folders.Count);
return(invCollection);
}
public virtual InventoryItemBase[] GetMultipleItems(UUID principalID, UUID[] itemIDs)
{
InventoryItemBase[] itemArr = new InventoryItemBase[itemIDs.Length];
try
{
Dictionary <string, object> resultSet = MakeRequest("GETMULTIPLEITEMS",
new Dictionary <string, object> {
{ "PRINCIPAL", principalID.ToString() },
{ "ITEMS", String.Join(",", itemIDs) },
{ "COUNT", itemIDs.Length.ToString() }
});
if (!CheckReturn(resultSet))
{
return(null);
}
int i = 0;
foreach (KeyValuePair <string, object> kvp in resultSet)
{
InventoryCollection inventory = new InventoryCollection();
if (kvp.Key.StartsWith("item_"))
{
if (kvp.Value is Dictionary <string, object> )
{
itemArr[i++] = BuildItem((Dictionary <string, object>)kvp.Value);
}
else
{
itemArr[i++] = null;
}
}
}
}
catch (Exception e)
{
m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Exception in GetMultipleItems: {0}", e.Message);
}
return(itemArr);
}
private void LoadPreviouslyLoadedArchives(IRegistryCore registry)
{
IUserAccountService UserAccountService = registry.RequestModuleInterface <IUserAccountService>();
UserAccount uinfo = UserAccountService.GetUserAccount(UUID.Zero, LibraryOwner);
IInventoryService InventoryService = registry.RequestModuleInterface <IInventoryService>();
//Make the user account for the default IAR
if (uinfo == null)
{
uinfo = new UserAccount(LibraryOwner);
uinfo.Name = LibraryOwnerName;
uinfo.Email = "";
uinfo.ServiceURLs = new Dictionary <string, object>();
uinfo.UserLevel = 0;
uinfo.UserFlags = 0;
uinfo.ScopeID = UUID.Zero;
uinfo.UserTitle = "";
UserAccountService.StoreUserAccount(uinfo);
InventoryService.CreateUserInventory(uinfo.PrincipalID);
uinfo = UserAccountService.GetUserAccount(UUID.Zero, LibraryOwner);
if (uinfo == null)
{
//Grid mode, can't create the user... leave
return;
}
}
InventoryCollection col = InventoryService.GetFolderContent(LibraryOwner, UUID.Zero);
foreach (InventoryFolderBase folder in col.Folders)
{
if (folder.Name == "My Inventory")
{
continue; //Pass My Inventory by
}
InventoryFolderImpl f = new InventoryFolderImpl(folder);
TraverseFolders(f, folder.ID, InventoryService);
//This is our loaded folder
AddToDefaultInventory(f);
}
}
//
// These 2 are for local and foreign users coming back, respectively
//
private void ProcessInventoryForComingHome(IClientAPI client)
{
if (!client.IsActive)
{
return;
}
m_log.DebugFormat("[HG INVENTORY ACCESS MODULE]: Restoring root folder for local user {0}", client.Name);
InventoryFolderBase root = m_Scene.InventoryService.GetRootFolder(client.AgentId);
InventoryCollection content = m_Scene.InventoryService.GetFolderContent(client.AgentId, root.ID);
List <InventoryFolderBase> keep = new List <InventoryFolderBase>();
foreach (InventoryFolderBase f in content.Folders)
{
if (f.Name != "My Suitcase" && f.Name != "Current Outfit")
{
keep.Add(f);
}
}
client.SendBulkUpdateInventory(keep.ToArray(), content.Items.ToArray());
}
public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
{
InventoryCollection c;
if (m_Inventories.TryGetValue(userID, out InventoryCollection inv))
{
c = new InventoryCollection();
c.OwnerID = userID;
c.Folders = inv.Folders.FindAll(delegate(InventoryFolderBase f)
{
return(f.ParentID == folderID);
});
c.Items = inv.Items.FindAll(delegate(InventoryItemBase i)
{
return(i.Folder == folderID);
});
return(c);
}
return(null);
}
private int FindAssetPerms(InventoryFolderBase folder, UUID assetID)
{
InventoryCollection contents = GetFolderContent(folder.Owner, folder.ID);
int perms = 0;
foreach (InventoryItemBase item in contents.Items)
{
if (item.AssetID == assetID)
{
perms = (int)item.CurrentPermissions | perms;
}
}
foreach (InventoryFolderBase subfolder in contents.Folders)
{
perms = perms | FindAssetPerms(subfolder, assetID);
}
return(perms);
}
public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
{
InventoryCollection invCol = m_RemoteConnector.GetFolderContent(userID, folderID);
// Commenting this for now, because it's causing more grief than good
//if (invCol != null && UserManager != null)
//{
// // Protect ourselves against the caller subsequently modifying the items list
// List<InventoryItemBase> items = new List<InventoryItemBase>(invCol.Items);
// if (items != null && items.Count > 0)
// //Util.FireAndForget(delegate
// //{
// foreach (InventoryItemBase item in items)
// if (!string.IsNullOrEmpty(item.CreatorData))
// UserManager.AddUser(item.CreatorIdAsUuid, item.CreatorData);
// //});
//}
return(invCol);
}
public virtual InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
{
// This method doesn't receive a valud principal id from the
// connector. So we disregard the principal and look
// by ID.
//
m_log.DebugFormat("[XINVENTORY SERVICE]: Fetch contents for folder {0}", folderID.ToString());
InventoryCollection inventory = new InventoryCollection();
inventory.UserID = principalID;
inventory.Folders = m_Database.GetFolders(
new string[] { "parentFolderID" },
new string[] { folderID.ToString() });
inventory.Items = m_Database.GetItems(
new string[] { "parentFolderID" },
new string[] { folderID.ToString() });
return(inventory);
}
//
// These 2 are for local and foreign users going away respectively
//
private void ProcessInventoryForHypergriding(IClientAPI client)
{
if (client is IClientCore)
{
IClientCore core = (IClientCore)client;
IClientInventory inv;
if (core.TryGet <IClientInventory>(out inv))
{
InventoryFolderBase root = m_Scene.InventoryService.GetRootFolder(client.AgentId);
if (root != null)
{
m_log.DebugFormat("[HG INVENTORY ACCESS MODULE]: Changing root inventory for user {0}", client.Name);
InventoryCollection content = m_Scene.InventoryService.GetFolderContent(client.AgentId, root.ID);
List <InventoryFolderBase> keep = new List <InventoryFolderBase>();
foreach (InventoryFolderBase f in content.Folders)
{
if (f.Name != "My Suitcase")
{
f.Name = f.Name + " (Unavailable)";
keep.Add(f);
}
}
// items directly under the root folder
foreach (InventoryItemBase it in content.Items)
{
it.Name = it.Name + " (Unavailable)";
}
;
// Send the new names
inv.SendBulkUpdateInventory(keep.ToArray(), content.Items.ToArray());
}
}
}
}
public BackendResponse TryFetchFolderContents(Uri owner, UUID folderID, out InventoryCollection contents)
{
contents = null;
BackendResponse ret;
InventoryCollection collection;
InventoryFolderWithChildren folder;
if (inventories.TryGetValue(owner, out collection) && collection.Folders.TryGetValue(folderID, out folder))
{
contents = new InventoryCollection();
contents.UserID = collection.UserID;
contents.Folders = new Dictionary <UUID, InventoryFolderWithChildren>();
contents.Items = new Dictionary <UUID, InventoryItemBase>();
foreach (InventoryNodeBase invBase in folder.Children.Values)
{
if (invBase is InventoryItemBase)
{
InventoryItemBase invItem = invBase as InventoryItemBase;
contents.Items.Add(invItem.ID, invItem);
}
else
{
InventoryFolderWithChildren invFolder = invBase as InventoryFolderWithChildren;
contents.Folders.Add(invFolder.ID, invFolder);
}
}
ret = BackendResponse.Success;
}
else
{
ret = BackendResponse.NotFound;
}
server.MetricsProvider.LogInventoryFetchFolderContents(EXTENSION_NAME, ret, owner, folderID, DateTime.Now);
return(ret);
}
/// <summary>
/// Save an inventory folder
/// </summary>
/// <param name="inventoryFolder">The inventory folder to save</param>
/// <param name="path">The path to which the folder should be saved</param>
/// <param name="saveThisFolderItself">If true, save this folder itself. If false, only saves contents</param>
protected void SaveInvFolder(InventoryFolderBase inventoryFolder, string path, bool saveThisFolderItself)
{
if (saveThisFolderItself)
{
path += CreateArchiveFolderName(inventoryFolder);
// We need to make sure that we record empty folders
m_archiveWriter.WriteDir(path);
}
InventoryCollection contents = FindInventoryCollection(inventoryFolder.Owner, inventoryFolder.ID);
foreach (InventoryFolderBase childFolder in contents.Folders)
{
SaveInvFolder(childFolder, path, true);
}
foreach (InventoryItemBase item in contents.Items)
{
SaveInvItem(item, path);
}
}
private void TraverseFolders(InventoryFolderImpl folderimp, UUID ID, Scene m_MockScene)
{
InventoryCollection col = m_MockScene.InventoryService.GetFolderContent(m_service.LibraryOwner, ID);
foreach (InventoryItemBase item in col.Items)
{
folderimp.Items[item.ID] = item;
}
foreach (InventoryFolderBase folder in col.Folders)
{
InventoryFolderImpl childFolder = new InventoryFolderImpl(folder);
foreach (KeyValuePair <String, AssetType> type in m_assetTypes)
{
if (childFolder.Name.ToLower().StartsWith(type.Key.ToLower()))
{
childFolder.Type = (short)type.Value;
}
}
TraverseFolders(childFolder, folder.ID, m_MockScene);
folderimp.AddChildFolder(childFolder);
}
}
private void UpdateDependants(bool enabled, InventoryCollection inventory)
{
foreach (EquipmentSlot slot in dependants)
{
bool setgear = false;
if (enabled)
{
slot.gameObject.SetActive(true);
if (equippedGear != null)
{
//check if the slot is of a type that the equipped gear doesn't provide
if (Array.IndexOf(equippedGear.DoesntProvide, GearLoadout.GetSlotType(slot.SlotID)) > -1)
{
slot.SetEquippedGear(null, inventory);
setgear = true;
slot.gameObject.SetActive(false);
}
}
else
{
slot.SetEquippedGear(null, inventory);
slot.gameObject.SetActive(false);
setgear = true;
}
}
else
{
slot.SetEquippedGear(null, inventory);
slot.gameObject.SetActive(false);
setgear = true;
}
if (!setgear)
{
slot.UpdateDependants(enabled, inventory);
}
}
}
public virtual InventoryCollection GetFolderContent(UUID UserID, UUID folderID)
{
object remoteValue = DoRemoteByURL("InventoryServerURI", UserID, folderID);
if (remoteValue != null || m_doRemoteOnly)
return (InventoryCollection) remoteValue;
// This method doesn't receive a valud principal id from the
// connector. So we disregard the principal and look
// by ID.
//
MainConsole.Instance.DebugFormat("[XINVENTORY SERVICE]: Fetch contents for folder {0}", folderID.ToString());
InventoryCollection inventory = new InventoryCollection
{
UserID = UserID,
FolderID = folderID,
Folders = m_Database.GetFolders(
new[] {"parentFolderID"},
new[] {folderID.ToString()}),
Items = m_Database.GetItems(UserID,
new[] {"parentFolderID"},
new[] {folderID.ToString()})
};
return inventory;
}
public ProductVariant(Guid productKey, ProductAttributeCollection attributes, InventoryCollection inventory, string name, string sku, decimal price)
: this(productKey, attributes, inventory, false, name, sku, price)
{
}
private InventoryCollection FindInventoryCollection(UUID userID, UUID folderID)
{
InventoryCollection collection = new InventoryCollection();
collection.UserID = userID;
collection.Items = new List<InventoryItemBase> ();
if (m_items.ContainsKey (folderID))
collection.Items = m_items[folderID];
collection.Folders = new List<InventoryFolderBase> ();
if (m_childFolders.ContainsKey (folderID))
collection.Folders = m_childFolders[folderID];
return collection;
}
public virtual InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
{
// This method doesn't receive a valud principal id from the
// connector. So we disregard the principal and look
// by ID.
//
m_log.DebugFormat("[XINVENTORY SERVICE]: Fetch contents for folder {0}", folderID.ToString());
InventoryCollection inventory = new InventoryCollection();
inventory.UserID = principalID;
inventory.Folders = m_Database.GetFolders (
new string[] { "parentFolderID"},
new string[] { folderID.ToString() });
inventory.Items = m_Database.GetItems (
new string[] { "parentFolderID"},
new string[] { folderID.ToString() });
return inventory;
}
/// <summary>
/// Construct an LLSD reply packet to a CAPS inventory request
/// </summary>
/// <param name="invFetch"></param>
/// <returns></returns>
private LLSDInventoryDescendents FetchInventoryReply(LLSDFetchInventoryDescendents invFetch)
{
LLSDInventoryDescendents reply = new LLSDInventoryDescendents();
LLSDInventoryFolderContents contents = new LLSDInventoryFolderContents();
contents.agent_id = m_agentID;
contents.owner_id = invFetch.owner_id;
contents.folder_id = invFetch.folder_id;
reply.folders.Array.Add(contents);
InventoryCollection inv = new InventoryCollection();
inv.Folders = new List<InventoryFolderBase>();
inv.Items = new List<InventoryItemBase>();
int version = 0;
if (CAPSFetchInventoryDescendents != null)
{
inv = CAPSFetchInventoryDescendents(m_agentID, invFetch.folder_id, invFetch.owner_id, invFetch.fetch_folders, invFetch.fetch_items, invFetch.sort_order, out version);
}
if (inv.Folders != null)
{
foreach (InventoryFolderBase invFolder in inv.Folders)
{
contents.categories.Array.Add(ConvertInventoryFolder(invFolder));
}
}
if (inv.Items != null)
{
foreach (InventoryItemBase invItem in inv.Items)
{
contents.items.Array.Add(ConvertInventoryItem(invItem));
}
}
contents.descendents = contents.items.Array.Count + contents.categories.Array.Count;
contents.version = version;
return reply;
}
/// <summary>
/// Construct an LLSD reply packet to a CAPS inventory request
/// </summary>
/// <param name="invFetch"></param>
/// <returns></returns>
private string FetchInventoryReply(OSDArray fetchRequest, UUID AgentID, bool Library)
{
OSDMap contents = new OSDMap();
OSDArray folders = new OSDArray();
foreach (OSD m in fetchRequest)
{
OSDMap invFetch = (OSDMap)m;
OSDMap internalContents = new OSDMap();
UUID agent_id = invFetch["agent_id"].AsUUID();
UUID owner_id = invFetch["owner_id"].AsUUID();
UUID folder_id = invFetch["folder_id"].AsUUID();
bool fetch_folders = invFetch["fetch_folders"].AsBoolean();
bool fetch_items = invFetch["fetch_items"].AsBoolean();
int sort_order = invFetch["sort_order"].AsInteger();
//Set the normal stuff
internalContents["agent_id"] = AgentID;
internalContents["owner_id"] = owner_id;
internalContents["folder_id"] = folder_id;
InventoryCollection inv = new InventoryCollection();
inv.Folders = new List<InventoryFolderBase>();
inv.Items = new List<InventoryItemBase>();
int version = 0;
inv = HandleFetchInventoryDescendentsCAPS(AgentID, folder_id, owner_id, fetch_folders, fetch_items, sort_order, Library, out version);
OSDArray categories = new OSDArray();
if (inv.Folders != null)
{
foreach (InventoryFolderBase invFolder in inv.Folders)
{
categories.Add(ConvertInventoryFolder(invFolder));
}
}
internalContents["categories"] = categories;
OSDArray items = new OSDArray();
if (inv.Items != null)
{
foreach (InventoryItemBase invItem in inv.Items)
{
items.Add(ConvertInventoryItem(invItem, AgentID));
}
}
internalContents["items"] = items;
internalContents["descendents"] = items.Count + categories.Count;
internalContents["version"] = version;
//Now add it to the folder array
folders.Add(internalContents);
}
contents["folders"] = folders;
return OSDParser.SerializeLLSDXmlString(contents);
}
public InventoryCollection HandleFetchInventoryDescendentsCAPS(UUID agentID, UUID folderID, UUID ownerID,
bool fetchFolders, bool fetchItems, int sortOrder, bool Library, out int version)
{
// FIXME MAYBE: We're not handling sortOrder!
InventoryFolderImpl fold;
InventoryCollection contents = new InventoryCollection();
//if (Library)
// {
//version = 0;
if (m_libraryService != null && m_libraryService.LibraryRootFolder != null)
{
if ((fold = m_libraryService.LibraryRootFolder.FindFolder(folderID)) != null)
{
version = 0;
InventoryCollection ret = new InventoryCollection();
ret.Folders = new List<InventoryFolderBase>();
ret.Items = fold.RequestListOfItems();
return ret;
}
}
//return contents;
//}
//if (folderID != UUID.Zero)
//{
if (fetchFolders)
{
contents = m_inventoryService.GetFolderContent(agentID, folderID);
}
if (fetchItems)
{
contents.Items = m_inventoryService.GetFolderItems(agentID, folderID);
}
InventoryFolderBase containingFolder = new InventoryFolderBase();
containingFolder.ID = folderID;
containingFolder.Owner = agentID;
containingFolder = m_inventoryService.GetFolder(containingFolder);
if (containingFolder != null)
version = containingFolder.Version;
else
version = 1;
//}
//else
//{
// // Lost itemsm don't really need a version
// version = 1;
//}
return contents;
}
