public virtual bool CreateUserRootFolder(UUID principalID)
{
bool result = false;
InventoryFolderBase rootFolder = GetRootFolder(principalID);
if (rootFolder == null)
{
List<InventoryFolderBase> rootFolders = GetInventorySkeleton(principalID);
if (rootFolders.Count == 0)
rootFolder = CreateFolder(principalID, UUID.Zero, (int) AssetType.RootFolder, "My Inventory");
else
{
rootFolder = new InventoryFolderBase
{
Name = "My Inventory",
Type = (short) AssetType.RootFolder,
Version = 1,
ID = rootFolders[0].ParentID,
Owner = principalID,
ParentID = UUID.Zero
};
m_Database.StoreFolder(rootFolder);
}
result = true;
}
return result;
}
// Constructors
public InventoryFolderImpl(InventoryFolderBase folderbase)
{
Owner = folderbase.Owner;
ID = folderbase.ID;
Name = folderbase.Name;
ParentID = folderbase.ParentID;
Type = folderbase.Type;
Version = folderbase.Version;
}
public override bool AddFolder(InventoryFolderBase folder)
{
string invserverURL = "";
if (GetHandlers.GetIsForeign (folder.Owner, "InventoryServerURI", m_registry, out invserverURL))
{
XInventoryServicesConnector xinv = new XInventoryServicesConnector (invserverURL + "xinventory");
return xinv.AddFolder (folder);
}
return base.AddFolder (folder);
}
public override bool AddFolder(InventoryFolderBase folder)
{
object remoteValue = DoRemote(folder);
if (remoteValue != null || m_doRemoteOnly)
return remoteValue != null && (bool)remoteValue;
string invserverURL = "";
if (GetHandlers.GetIsForeign (folder.Owner, "InventoryServerURI", m_registry, out invserverURL))
{
XInventoryServicesConnector xinv = new XInventoryServicesConnector (invserverURL + "xinventory");
return xinv.AddFolder (folder);
}
return base.AddFolder (folder);
}
public override void FromOSD(OSDMap map)
{
OSDArray items = (OSDArray)map["Items"];
Items = items.ConvertAll<InventoryItemBase>((osd) =>
{
InventoryItemBase item = new InventoryItemBase();
item.FromOSD((OSDMap)osd);
return item;
}
);
OSDArray folders = (OSDArray)map["Folders"];
Folders = folders.ConvertAll<InventoryFolderBase>((osd) =>
{
InventoryFolderBase folder = new InventoryFolderBase();
folder.FromOSD((OSDMap)osd);
return folder;
}
);
UserID = map["UserID"];
}
public virtual bool AddFolder(InventoryFolderBase folder)
{
if (folder == null)
return false;
Dictionary<string, object> ret = MakeRequest("ADDFOLDER",
new Dictionary<string, object>
{
{"ParentID", folder.ParentID.ToString()},
{"Type", folder.Type.ToString()},
{"Version", folder.Version.ToString()},
{"Name", folder.Name},
{"Owner", folder.Owner.ToString()},
{"ID", folder.ID.ToString()}
});
if (ret == null)
return false;
return bool.Parse(ret["RESULT"].ToString());
}
/// <summary>
/// Move the inventory folder to another place in the user's inventory
/// </summary>
/// <param name="remoteClient">The client that requested the change</param>
/// <param name="folderID">The folder UUID to move</param>
/// <param name="parentID">The folder to move the folder (folderID) into</param>
protected void HandleMoveInventoryFolder(IClientAPI remoteClient, UUID folderID, UUID parentID)
{
InventoryFolderBase folder = new InventoryFolderBase(folderID, remoteClient.AgentId);
folder = m_scene.InventoryService.GetFolder(folder);
if (folder != null)
{
folder.ParentID = parentID;
if (!m_scene.InventoryService.MoveFolder(folder))
MainConsole.Instance.WarnFormat("[AGENT INVENTORY]: could not move folder {0}", folderID);
else
MainConsole.Instance.DebugFormat("[AGENT INVENTORY]: folder {0} moved to parent {1}", folderID, parentID);
}
else
{
MainConsole.Instance.WarnFormat("[AGENT INVENTORY]: request to move folder {0} but folder not found", folderID);
}
}
/// <summary>
/// Handle an inventory folder creation request from the client.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="folderID"></param>
/// <param name="folderType"></param>
/// <param name="folderName"></param>
/// <param name="parentID"></param>
protected void HandleCreateInventoryFolder(IClientAPI remoteClient, UUID folderID, ushort folderType,
string folderName, UUID parentID)
{
InventoryFolderBase folder = new InventoryFolderBase(folderID, folderName, remoteClient.AgentId, (short)folderType, parentID, 1);
if (!m_scene.InventoryService.AddFolder(folder))
{
MainConsole.Instance.WarnFormat(
"[AGENT INVENTORY]: Failed to create folder for user {0} {1}",
remoteClient.Name, remoteClient.AgentId);
}
}
/// <summary>
/// Send an update to the client about the given folder
/// </summary>
/// <param name="client">The client to send the update to</param>
/// <param name="folder">The folder that we need to send</param>
/// <param name="fetchFolders">Should we fetch folders inside of this folder</param>
/// <param name="fetchItems">Should we fetch items inside of this folder</param>
protected void SendInventoryUpdate(IClientAPI client, InventoryFolderBase folder, bool fetchFolders, bool fetchItems)
{
if (folder == null)
return;
// Fetch the folder contents
InventoryCollection contents = m_scene.InventoryService.GetFolderContent(client.AgentId, folder.ID);
// Fetch the folder itself to get its current version
InventoryFolderBase containingFolder = new InventoryFolderBase(folder.ID, client.AgentId);
containingFolder = m_scene.InventoryService.GetFolder(containingFolder);
//MainConsole.Instance.DebugFormat("[AGENT INVENTORY]: Sending inventory folder contents ({0} nodes) for \"{1}\" to {2} {3}",
// contents.Folders.Count + contents.Items.Count, containingFolder.Name, client.FirstName, client.LastName);
if (containingFolder != null)
client.SendInventoryFolderDetails(client.AgentId, folder.ID, contents.Items, contents.Folders, containingFolder.Version, fetchFolders, fetchItems);
}
private void NewFolder(UUID userID, string newFolderName, string folder)
{
UUID folderID = UUID.Zero;
if (UUID.TryParse(folder, out folderID))
{
InventoryFolderBase fbase = new InventoryFolderBase(UUID.Random(), newFolderName, userID, folderID);
fbase.Type = (short)AssetType.Folder;
m_InventoryService.AddFolder(fbase);
}
}
private void Delete(UUID userID, List<string> nodes, List<string> types)
{
List<UUID> items = new List<UUID>();
List<UUID> folders = new List<UUID>();
SplitNodes(userID, nodes, types, items, folders);
var trash = m_InventoryService.GetFolderForType(userID, InventoryType.Folder, AssetType.TrashFolder);
if (trash != null)
{
List<InventoryItemBase> its = new List<InventoryItemBase>();
foreach (UUID uuid in items)
{
InventoryItemBase itbase = new InventoryItemBase();
itbase.ID = uuid;
itbase.Folder = UUID.Zero;
its.Add(itbase);
}
m_InventoryService.MoveItems(userID, its);
bool purgeTrash = false;
foreach (UUID uuid in folders)
{
InventoryFolderBase fbase = new InventoryFolderBase(uuid, userID);
//if (uuid == trash)
// purgeTrash = true;
//else
{
fbase.ParentID = UUID.Zero;
m_InventoryService.MoveFolder(fbase);
}
}
if (purgeTrash)
{
InventoryFolderBase fbase = new InventoryFolderBase(UUID.Zero, userID);
m_InventoryService.PurgeFolder(fbase);
}
}
}
///<summary>
/// Create the archive name for a particular folder.
///</summary>
///These names are prepended with an inventory folder's UUID so that more than one folder can have the
///same name
///<param name = "folder"></param>
///<returns></returns>
public static string CreateArchiveFolderName(InventoryFolderBase folder)
{
return CreateArchiveFolderName(folder.Name, folder.ID);
}
/// <summary>
/// Purge an inventory folder of all its items and subfolders.
/// </summary>
/// <param name = "folder"></param>
/// <returns>true if the folder was successfully purged</returns>
public bool PurgeFolder(InventoryFolderBase folder)
{
NameValueCollection requestArgs = new NameValueCollection
{
{"RequestMethod", "PurgeInventoryFolder"},
{"OwnerID", folder.Owner.ToString()},
{"FolderID", folder.ID.ToString()}
};
OSDMap response = WebUtils.PostToService(m_serverUrl, requestArgs);
bool success = response["Success"].AsBoolean();
if (!success)
{
MainConsole.Instance.Warn("[SIMIAN INVENTORY CONNECTOR]: Error purging folder " + folder.ID + " for " + folder.Owner +
": " +
response["Message"].AsString());
}
return success;
}
/// <summary>
/// Get a folder, given by its UUID
/// </summary>
/// <param name = "folder"></param>
/// <returns></returns>
public InventoryFolderBase GetFolder(InventoryFolderBase folder)
{
NameValueCollection requestArgs = new NameValueCollection
{
{"RequestMethod", "GetInventoryNode"},
{"ItemID", folder.ID.ToString()},
{"OwnerID", folder.Owner.ToString()},
{"IncludeFolders", "1"},
{"IncludeItems", "0"},
{"ChildrenOnly", "1"}
};
OSDMap response = WebUtils.PostToService(m_serverUrl, requestArgs);
if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
{
OSDArray items = (OSDArray) response["Items"];
List<InventoryFolderBase> folders = GetFoldersFromResponse(items, folder.ID, true);
if (folders.Count > 0)
return folders[0];
}
return null;
}
/// <summary>
/// Add a new folder to the user's inventory
/// </summary>
/// <param name = "folder"></param>
/// <returns>true if the folder was successfully added</returns>
public bool AddFolder(InventoryFolderBase folder)
{
NameValueCollection requestArgs = new NameValueCollection
{
{"RequestMethod", "AddInventoryFolder"},
{"FolderID", folder.ID.ToString()},
{"ParentID", folder.ParentID.ToString()},
{"OwnerID", folder.Owner.ToString()},
{"Name", folder.Name},
{"ContentType", SLUtil.SLAssetTypeToContentType(folder.Type)}
};
OSDMap response = WebUtils.PostToService(m_serverUrl, requestArgs);
bool success = response["Success"].AsBoolean();
if (!success)
{
MainConsole.Instance.Warn("[SIMIAN INVENTORY CONNECTOR]: Error creating folder " + folder.Name + " for " + folder.Owner +
": " +
response["Message"].AsString());
}
return success;
}
/// <summary>
/// Constructor
/// </summary>
public InventoryArchiveWriteRequest(
Guid id, InventoryArchiverModule module, IRegistryCore registry,
UserAccount userInfo, string invPath, Stream saveStream, bool UseAssets, InventoryFolderBase folderBase,
List<AssetBase> assetsToAdd)
{
m_id = id;
m_module = module;
m_registry = registry;
m_userInfo = userInfo;
m_invPath = invPath;
m_saveStream = saveStream;
m_assetGatherer = new UuidGatherer(m_registry.RequestModuleInterface<IAssetService>());
m_saveAssets = UseAssets;
m_defaultFolderToSave = folderBase;
m_assetsToAdd = assetsToAdd;
}
/// <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
= m_registry.RequestModuleInterface<IInventoryService>().GetFolderContent(inventoryFolder.Owner,
inventoryFolder.ID);
foreach (InventoryFolderBase childFolder in contents.Folders)
{
SaveInvFolder(childFolder, path, true);
}
foreach (InventoryItemBase item in contents.Items)
{
SaveInvItem(item, path);
}
}
/// <summary>
/// Update a folder in the user's inventory
/// </summary>
/// <param name = "folder"></param>
/// <returns>true if the folder was successfully updated</returns>
public bool UpdateFolder(InventoryFolderBase folder)
{
return AddFolder(folder);
}
public override bool PurgeFolder(InventoryFolderBase folder)
{
// NOGO
return false;
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name = "item"></param>
/// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item)
{
if (item.AssetID != UUID.Zero)
{
return AddItem(item);
}
else
{
// This is actually a folder update
InventoryFolderBase folder = new InventoryFolderBase(item.ID, item.Name, item.Owner,
(short) item.AssetType, item.Folder, 0);
return UpdateFolder(folder);
}
}
private void Move(UUID userID, List<string> nodes, List<string> types, string folder)
{
UUID folderID = UUID.Zero;
if (UUID.TryParse(folder, out folderID))
{
List<UUID> items = new List<UUID>();
List<UUID> folders = new List<UUID>();
SplitNodes(userID, nodes, types, items, folders);
List<InventoryItemBase> its = new List<InventoryItemBase>();
foreach (UUID uuid in items)
{
InventoryItemBase itbase = new InventoryItemBase();
itbase.ID = uuid;
itbase.Folder = folderID;
its.Add(itbase);
}
m_InventoryService.MoveItems(userID, its);
foreach (UUID uuid in folders)
{
InventoryFolderBase fbase = new InventoryFolderBase();
fbase.ID = uuid;
fbase.ParentID = folderID;
m_InventoryService.MoveFolder(fbase);
}
}
}
public virtual bool MoveFolder(InventoryFolderBase folder)
{
if (folder == null)
return false;
Dictionary<string, object> ret = MakeRequest("MOVEFOLDER",
new Dictionary<string, object>
{
{"ParentID", folder.ParentID.ToString()},
{"ID", folder.ID.ToString()},
{"PRINCIPAL", folder.Owner.ToString()}
});
if (ret == null)
return false;
return bool.Parse(ret["RESULT"].ToString());
}
public byte[] CreateInventoryCategory(string path, Stream request, OSHttpRequest httpRequest,
OSHttpResponse httpResponse)
{
OSDMap map = (OSDMap)OSDParser.DeserializeLLSDXml(request);
UUID folder_id = map["folder_id"].AsUUID();
UUID parent_id = map["parent_id"].AsUUID();
int type = map["type"].AsInteger();
string name = map["name"].AsString();
UUID newFolderId = UUID.Random();
InventoryFolderBase newFolder
= new InventoryFolderBase(
newFolderId, name, m_service.AgentID, (short)type, parent_id, 1);
m_inventoryService.AddFolder(newFolder);
OSDMap resp = new OSDMap();
resp["folder_id"] = folder_id;
resp["parent_id"] = parent_id;
resp["type"] = type;
resp["name"] = name;
return OSDParser.SerializeLLSDXmlBytes(map);
}
public bool ForcePurgeFolder(InventoryFolderBase folder)
{
return false;
}
/// <summary>
/// Move the given items from the object task inventory to the agent's inventory
/// </summary>
/// <param name="destID"></param>
/// <param name="name"></param>
/// <param name="host"></param>
/// <param name="items"></param>
/// <returns></returns>
public UUID MoveTaskInventoryItemsToUserInventory (UUID destID, string name, ISceneChildEntity host, List<UUID> items)
{
//InventoryFolderBase rootFolder = m_scene.InventoryService.GetRootFolder(destID);
UUID newFolderID = UUID.Random();
// InventoryFolderBase newFolder = new InventoryFolderBase(newFolderID, name, destID, -1, rootFolder.ID, rootFolder.Version);
// m_scene.InventoryService.AddFolder(newFolder);
//int countLeft = items.Count;
//foreach (UUID itemID in items)
Util.FireAndForget((o) =>
{
//InventoryItemBase agentItem = CreateAgentInventoryItemFromTask(destID, host, itemID);
InventoryFolderBase rootFolder = m_scene.InventoryService.GetRootFolder(destID);
InventoryFolderBase newFolder = new InventoryFolderBase(newFolderID, name, destID, -1, rootFolder.ID, rootFolder.Version);
m_scene.InventoryService.AddFolder(newFolder);
//if (agentItem != null)
foreach (UUID itemID in items)
{
//agentItem.Folder = newFolderID;
InventoryItemBase agentItem = CreateAgentInventoryItemFromTask(destID, host, itemID);
// m_scene.InventoryService.AddItemAsync(agentItem, (itm) =>
/*if (agentItem != null)
{
if (--countLeft == 0)
{
IScenePresence avatar;
if (m_scene.TryGetScenePresence(destID, out avatar))
{
SendInventoryUpdate(avatar.ControllingClient, rootFolder, true, false);
SendInventoryUpdate(avatar.ControllingClient, newFolder, false, true);
}
}
});
*/
agentItem.Folder = newFolderID;
m_scene.InventoryService.AddItem(agentItem);
}
// }
IScenePresence avatar;
if (m_scene.TryGetScenePresence(destID, out avatar))
{
SendInventoryUpdate(avatar.ControllingClient, rootFolder, true, false);
SendInventoryUpdate(avatar.ControllingClient, newFolder, false, true);
}
});
return newFolderID;
}
public virtual bool PurgeFolder(InventoryFolderBase folder)
{
if (folder == null)
return false;
Dictionary<string, object> ret = MakeRequest("PURGEFOLDER",
new Dictionary<string, object>
{
{"ID", folder.ID.ToString()}
});
if (ret == null)
return false;
return bool.Parse(ret["RESULT"].ToString());
}
/// <summary>
/// Handle a client request to update the inventory folder
/// </summary>
///
/// FIXME: We call add new inventory folder because in the data layer, we happen to use an SQL REPLACE
/// so this will work to rename an existing folder. Needless to say, to rely on this is very confusing,
/// and needs to be changed.
///
/// <param name="remoteClient"></param>
/// <param name="folderID"></param>
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="parentID"></param>
protected void HandleUpdateInventoryFolder(IClientAPI remoteClient, UUID folderID, ushort type, string name,
UUID parentID)
{
// MainConsole.Instance.DebugFormat(
// "[AGENT INVENTORY]: Updating inventory folder {0} {1} for {2} {3}", folderID, name, remoteClient.Name, remoteClient.AgentId);
InventoryFolderBase folder = new InventoryFolderBase(folderID, remoteClient.AgentId);
folder = m_scene.InventoryService.GetFolder(folder);
if (folder != null)
{
folder.Name = name;
folder.Type = (short)type;
folder.ParentID = parentID;
if (!m_scene.InventoryService.UpdateFolder(folder))
{
MainConsole.Instance.ErrorFormat(
"[AGENT INVENTORY]: Failed to update folder for user {0} {1}",
remoteClient.Name, remoteClient.AgentId);
}
}
}
public virtual InventoryFolderBase GetFolder(InventoryFolderBase folder)
{
if (folder == null)
return null;
try
{
Dictionary<string, object> ret = MakeRequest("GETFOLDER",
new Dictionary<string, object>
{
{"ID", folder.ID.ToString()}
});
if (ret == null)
return null;
if (ret.Count == 0)
return null;
return BuildFolder((Dictionary<string, object>)ret["folder"]);
}
catch (Exception e)
{
MainConsole.Instance.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception in GetFolder: {0}", e.Message);
}
return null;
}
/// <summary>
/// This should delete all the items and folders in the given directory.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="folderID"></param>
protected void HandlePurgeInventoryDescendents(IClientAPI remoteClient, UUID folderID)
{
InventoryFolderBase folder = new InventoryFolderBase(folderID, remoteClient.AgentId);
Util.FireAndForget(PurgeFolderAsync, folder);
}
private InventoryFolderBase BuildFolder(Dictionary<string, object> data)
{
InventoryFolderBase folder = new InventoryFolderBase();
try
{
folder.ParentID = new UUID(data["ParentID"].ToString());
folder.Type = short.Parse(data["Type"].ToString());
folder.Version = ushort.Parse(data["Version"].ToString());
folder.Name = data["Name"].ToString();
folder.Owner = new UUID(data["Owner"].ToString());
folder.ID = new UUID(data["ID"].ToString());
}
catch (Exception e)
{
MainConsole.Instance.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception building folder: {0}", e.Message);
}
return folder;
}