public virtual bool AddFolder(InventoryFolderBase folder)
{
object remoteValue = DoRemoteByURL("InventoryServerURI", folder);
if (remoteValue != null || m_doRemoteOnly)
return remoteValue == null ? false : (bool) remoteValue;
InventoryFolderBase check = GetFolder(folder);
if (check != null)
return false;
return m_Database.StoreFolder(folder);
}
private InventoryFolderBase[] ParseInventoryFolders (Dictionary<string, List<string>> retVal)
{
List<InventoryFolderBase> folders = new List<InventoryFolderBase> ();
if (retVal.Count == 0)
return folders.ToArray();
for (int i = 0; i < retVal.ElementAt(0).Value.Count; i++)
{
InventoryFolderBase folder = new InventoryFolderBase ();
folder.Name = retVal["folderName"][i];
folder.Type = short.Parse (retVal["type"][i]);
folder.Version = (ushort)int.Parse (retVal["version"][i]);
folder.ID = UUID.Parse (retVal["folderID"][i]);
folder.Owner = UUID.Parse (retVal["agentID"][i]);
folder.ParentID = UUID.Parse (retVal["parentFolderID"][i]);
folders.Add (folder);
}
return folders.ToArray ();
}
public virtual InventoryFolderBase GetFolder(InventoryFolderBase folder)
{
List<InventoryFolderBase> folders = m_Database.GetFolders(
new string[] { "folderID"},
new string[] { folder.ID.ToString() });
if (folders.Count == 0)
return null;
return folders[0];
}
private void GridInventoryOffer(GridInstantMessage im)
{
if (im.binaryBucket.Length < 1) // Invalid
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Invalid IM (binary bucket length {0}).", im.binaryBucket.Length);
return;
}
Scene scene = FindScene(new UUID(im.toAgentID));
ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
if (user == null) // Shouldn't happen
{
m_log.Warn("[INVENTORY TRANSFER]: Can't find recipient");
return;
}
CachedUserInfo userInfo =
scene.CommsManager.UserService.
GetUserDetails(user.ControllingClient.AgentId);
if (userInfo == null)
{
m_log.Warn("[INVENTORY TRANSFER]: Can't find user info of recipient");
return;
}
AssetType assetType = (AssetType)im.binaryBucket[0];
UUID inventoryEntityID = UUID.Zero;
if (im.binaryBucket.Length >= 17) // includes UUID
{
inventoryEntityID = new UUID(im.binaryBucket, 1);
}
if (AssetType.Folder == assetType)
{
if (inventoryEntityID != UUID.Zero)
{
// Get folder info
InventoryFolderBase folder = userInfo.GetFolder(inventoryEntityID);
if (folder == null)
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Can't retrieve folder {0} to give.", inventoryEntityID);
return;
}
// Update folder to viewer (makes it appear to user)
user.ControllingClient.SendBulkUpdateInventory(folder);
userInfo.SendInventoryDecendents(user.ControllingClient, folder.ID, false, true);
}
// Deliver message
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (inventoryEntityID != UUID.Zero)
{
// Get item info
InventoryItemBase item = userInfo.FindItem(inventoryEntityID);
if (item == null)
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Can't retrieve item {0} to give.", inventoryEntityID);
return;
}
// Update item to viewer (makes it appear in proper folder)
user.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
// Deliver message
user.ControllingClient.SendInstantMessage(im);
}
}
public virtual bool ForcePurgeFolder (InventoryFolderBase folder)
{
List<InventoryFolderBase> subFolders = m_Database.GetFolders(
new string[] { "parentFolderID" },
new string[] { folder.ID.ToString () });
foreach (InventoryFolderBase x in subFolders)
{
ForcePurgeFolder (x);
m_Database.DeleteFolders ("folderID", x.ID.ToString (), false);
}
m_Database.DeleteItems ("parentFolderID", folder.ID.ToString ());
m_Database.DeleteFolders("folderID", folder.ID.ToString(), false);
return true;
}
public void LoadAvatarArchive(string FileName, string Name)
{
UserAccount account = UserAccountService.GetUserAccount(UUID.Zero, Name);
m_log.Info("[AvatarArchive] Loading archive from " + FileName);
if (account == null)
{
m_log.Error("[AvatarArchive] User not found!");
return;
}
string file = "";
if (FileName.EndsWith(".database"))
{
m_log.Info("[AvatarArchive] Loading archive from the database " + FileName);
FileName = FileName.Substring(0, FileName.Length - 9);
Aurora.Framework.IAvatarArchiverConnector avarchiver = DataManager.RequestPlugin<IAvatarArchiverConnector>();
AvatarArchive archive = avarchiver.GetAvatarArchive(FileName);
file = archive.ArchiveXML;
}
else
{
m_log.Info("[AvatarArchive] Loading archive from " + FileName);
StreamReader reader = new StreamReader(FileName);
file = reader.ReadToEnd();
reader.Close();
reader.Dispose();
}
string FolderNameToLoadInto = "";
OSD m = OSDParser.DeserializeLLSDXml(file);
if (m.Type != OSDType.Map)
{
m_log.Warn("[AvatarArchiver]: Failed to load AA from " + FileName + ", text: " + file);
return;
}
OSDMap map = ((OSDMap)m);
OSDMap assetsMap = ((OSDMap)map["Assets"]);
OSDMap itemsMap = ((OSDMap)map["Items"]);
OSDMap bodyMap = ((OSDMap)map["Body"]);
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(bodyMap, out FolderNameToLoadInto);
appearance.Owner = account.PrincipalID;
List<InventoryItemBase> items = new List<InventoryItemBase>();
InventoryFolderBase AppearanceFolder = InventoryService.GetFolderForType (account.PrincipalID, InventoryType.Unknown, AssetType.Clothing);
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), FolderNameToLoadInto, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
InventoryService.AddFolder(folderForAppearance);
folderForAppearance = InventoryService.GetFolder(folderForAppearance);
try
{
LoadAssets(assetsMap, appearance);
LoadItems(itemsMap, account.PrincipalID, folderForAppearance, appearance, out items);
}
catch (Exception ex)
{
m_log.Warn("[AvatarArchiver]: Error loading assets and items, " + ex.ToString());
}
AvatarData adata = new AvatarData(appearance);
AvatarService.SetAvatar(account.PrincipalID, adata);
m_log.Info("[AvatarArchive] Loaded archive from " + FileName);
}
public void FinishedStartup()
{
string IARName = "DefaultInventory.iar";
IniConfigSource iniSource = null;
try
{
iniSource = new IniConfigSource("DefaultInventory/Inventory.ini", Nini.Ini.IniFileType.AuroraStyle);
}
catch
{
}
IConfig libConfig = m_config.Configs["DefaultAssetsIARCreator"];
if (libConfig == null)
libConfig = iniSource.Configs["DefaultAssetsIARCreator"];
if (libConfig != null)
{
if (!libConfig.GetBoolean("Enabled", false))
return;
IARName = libConfig.GetString("NameOfIAR", IARName);
}
else
return;
m_service = m_registry.RequestModuleInterface<ILibraryService>();
RegionInfo regInfo = new RegionInfo();
IScene m_MockScene = null;
//Make the scene for the IAR loader
if (m_registry is IScene)
m_MockScene = (IScene)m_registry;
else
{
m_MockScene = new Scene();
m_MockScene.Initialize(regInfo);
m_MockScene.AddModuleInterfaces(m_registry.GetInterfaces());
}
UserAccount uinfo = m_MockScene.UserAccountService.GetUserAccount(null, m_service.LibraryOwner);
//Make the user account for the default IAR
if (uinfo == null)
{
uinfo = new UserAccount(m_service.LibraryOwner);
uinfo.Name = m_service.LibraryOwnerName;
//m_MockScene.InventoryService.CreateUserInventory(m_service.LibraryOwner, false);
MainConsole.Instance.InfoFormat("[DefaultInventoryToIARConverter]: 1,1");
InventoryFolderBase newFolder = new InventoryFolderBase
{
Name = "My Inventory",
Type = 9,
Version = 1,
ID = new UUID("00000112-000f-0000-0000-000100bba000"),
Owner = m_service.LibraryOwner,
ParentID = UUID.Zero
};
MainConsole.Instance.InfoFormat("[DefaultInventoryToIARConverter]: 1,3");
}
MainConsole.Instance.InfoFormat("[DefaultInventoryToIARConverter]: 1,4");
List<AssetBase> assets = new List<AssetBase> ();
if (m_MockScene.InventoryService != null)
{
//Add the folders to the user's inventory
InventoryCollection i = m_MockScene.InventoryService.GetFolderContent (m_service.LibraryOwner, UUID.Zero);
if (i != null)
{
foreach (InventoryItemBase item in i.Items)
{
AssetBase asset = m_MockScene.RequestModuleInterface<IAssetService> ().Get (item.AssetID.ToString ());
if (asset != null)
assets.Add (asset);
}
}
}
InventoryFolderBase rootFolder = null;
List<InventoryFolderBase> rootFolders = m_MockScene.InventoryService.GetRootFolders (m_service.LibraryOwner);
foreach (InventoryFolderBase folder in rootFolders)
{
if (folder.Name == "My Inventory")
continue;
rootFolder = folder;
break;
}
if (rootFolder != null)
{
//Save the IAR of the default assets
InventoryArchiveWriteRequest write = new InventoryArchiveWriteRequest (Guid.NewGuid (), null, m_MockScene,
uinfo, "/", new GZipStream (new FileStream (IARName, FileMode.Create), CompressionMode.Compress), true, rootFolder, assets);
write.Execute ();
}
}
/// <summary>
/// Handle a client request to update the inventory folder
/// </summary>
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// 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="folderID"></param>
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="parentID"></param>
public bool UpdateFolder(InventoryFolderBase baseFolder)
{
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
inventorySelect.GetProvider(m_userProfile.ID).SaveFolder(baseFolder);
return true;
}
public AvatarArchive LoadAvatarArchive(string fileName, UUID principalID)
{
AvatarArchive archive = new AvatarArchive();
UserAccount account = UserAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return null;
}
if (!File.Exists(fileName))
{
MainConsole.Instance.Error("[AvatarArchive]: Unable to load from file: file does not exist!");
return null;
}
MainConsole.Instance.Info("[AvatarArchive]: Loading archive from " + fileName);
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(fileName)));
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(archive.BodyMap);
appearance.Owner = principalID;
InventoryFolderBase AppearanceFolder = InventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
AssetType.Clothing);
List<InventoryItemBase> items = new List<InventoryItemBase>();
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), archive.FolderName, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
InventoryService.AddFolder(folderForAppearance);
folderForAppearance = InventoryService.GetFolder(folderForAppearance);
try
{
LoadAssets(archive.AssetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance,
account.PrincipalID, archive.ItemsMap, out items);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
MainConsole.Instance.Info("[AvatarArchive]: Loaded archive from " + fileName);
archive.Appearance = appearance;
return archive;
}
/// <summary>
/// Updates an inventory folder
/// </summary>
/// <param name="folder">Folder to update</param>
public void updateInventoryFolder(InventoryFolderBase folder)
{
addInventoryFolder(folder);
}
/// <summary>
/// See IInventoryDataPlugin
/// </summary>
/// <param name="parentID"></param>
/// <returns></returns>
public List <InventoryFolderBase> getFolderHierarchy(UUID parentID)
{
/* Note: There are subtle changes between this implementation of getFolderHierarchy and the previous one
* - We will only need to hit the database twice instead of n times.
* - We assume the database is well-formed - no stranded/dangling folders, all folders in heirarchy owned
* by the same person, each user only has 1 inventory heirarchy
* - The returned list is not ordered, instead of breadth-first ordered
* There are basically 2 usage cases for getFolderHeirarchy:
* 1) Getting the user's entire inventory heirarchy when they log in
* 2) Finding a subfolder heirarchy to delete when emptying the trash.
* This implementation will pull all inventory folders from the database, and then prune away any folder that
* is not part of the requested sub-heirarchy. The theory is that it is cheaper to make 1 request from the
* database than to make n requests. This pays off only if requested heirarchy is large.
* By making this choice, we are making the worst case better at the cost of making the best case worse.
* This way is generally better because we don't have to rebuild the connection/sql query per subfolder,
* even if we end up getting more data from the SQL server than we need.
* - Francis
*/
try
{
List <InventoryFolderBase> folders = new List <InventoryFolderBase>();
Dictionary <UUID, List <InventoryFolderBase> > hashtable = new Dictionary <UUID, List <InventoryFolderBase> >();;
List <InventoryFolderBase> parentFolder = new List <InventoryFolderBase>();
bool buildResultsFromHashTable = false;
lock (m_dbLock)
{
using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
{
dbcon.Open();
/* Fetch the parent folder from the database to determine the agent ID, and if
* we're querying the root of the inventory folder tree */
using (MySqlCommand result = new MySqlCommand("SELECT * FROM inventoryfolders WHERE folderID = ?uuid", dbcon))
{
result.Parameters.AddWithValue("?uuid", parentID.ToString());
using (MySqlDataReader reader = result.ExecuteReader())
{
// Should be at most 1 result
while (reader.Read())
{
parentFolder.Add(readInventoryFolder(reader));
}
}
}
if (parentFolder.Count >= 1) // No result means parent folder does not exist
{
if (parentFolder[0].ParentID == UUID.Zero) // We are querying the root folder
{
/* Get all of the agent's folders from the database, put them in a list and return it */
using (MySqlCommand result = new MySqlCommand("SELECT * FROM inventoryfolders WHERE agentID = ?uuid", dbcon))
{
result.Parameters.AddWithValue("?uuid", parentFolder[0].Owner.ToString());
using (MySqlDataReader reader = result.ExecuteReader())
{
while (reader.Read())
{
InventoryFolderBase curFolder = readInventoryFolder(reader);
if (curFolder.ID != parentID) // Do not need to add the root node of the tree to the list
{
folders.Add(curFolder);
}
}
}
}
} // if we are querying the root folder
else // else we are querying a subtree of the inventory folder tree
{
/* Get all of the agent's folders from the database, put them all in a hash table
* indexed by their parent ID */
using (MySqlCommand result = new MySqlCommand("SELECT * FROM inventoryfolders WHERE agentID = ?uuid", dbcon))
{
result.Parameters.AddWithValue("?uuid", parentFolder[0].Owner.ToString());
using (MySqlDataReader reader = result.ExecuteReader())
{
while (reader.Read())
{
InventoryFolderBase curFolder = readInventoryFolder(reader);
if (hashtable.ContainsKey(curFolder.ParentID)) // Current folder already has a sibling
{
hashtable[curFolder.ParentID].Add(curFolder); // append to sibling list
}
else // else current folder has no known (yet) siblings
{
List <InventoryFolderBase> siblingList = new List <InventoryFolderBase>();
siblingList.Add(curFolder);
// Current folder has no known (yet) siblings
hashtable.Add(curFolder.ParentID, siblingList);
}
} // while more items to read from the database
}
}
// Set flag so we know we need to build the results from the hash table after
// we unlock the database
buildResultsFromHashTable = true;
} // else we are querying a subtree of the inventory folder tree
} // if folder parentID exists
if (buildResultsFromHashTable)
{
/* We have all of the user's folders stored in a hash table indexed by their parent ID
* and we need to return the requested subtree. We will build the requested subtree
* by performing a breadth-first-search on the hash table */
if (hashtable.ContainsKey(parentID))
{
folders.AddRange(hashtable[parentID]);
}
for (int i = 0; i < folders.Count; i++) // **Note: folders.Count is *not* static
{
if (hashtable.ContainsKey(folders[i].ID))
{
folders.AddRange(hashtable[folders[i].ID]);
}
}
}
}
} // lock (database)
return(folders);
}
catch (Exception e)
{
m_log.Error(e.Message, e);
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="im"></param>
private void OnGridInstantMessage(GridInstantMessage im)
{
// Check if this is ours to handle
//
Scene scene = FindClientScene(new UUID(im.toAgentID));
if (scene == null)
{
return;
}
// Find agent to deliver to
//
ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
if (user == null)
{
return;
}
// This requires a little bit of processing because we have to make the
// new item visible in the recipient's inventory here
//
if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
{
if (im.binaryBucket.Length < 17) // Invalid
{
return;
}
UUID recipientID = new UUID(im.toAgentID);
// First byte is the asset type
AssetType assetType = (AssetType)im.binaryBucket[0];
if (AssetType.Folder == assetType)
{
UUID folderID = new UUID(im.binaryBucket, 1);
InventoryFolderBase folder =
scene.InventoryService.GetFolder(recipientID, folderID);
if (folder != null)
{
user.ControllingClient.SendBulkUpdateInventory(folder);
}
}
else
{
UUID itemID = new UUID(im.binaryBucket, 1);
InventoryItemBase item =
scene.InventoryService.GetItem(recipientID, itemID);
if (item != null)
{
user.ControllingClient.SendBulkUpdateInventory(item);
}
}
user.ControllingClient.SendInstantMessage(im);
}
if (im.dialog == (byte)InstantMessageDialog.TaskInventoryOffered)
{
if (im.binaryBucket.Length < 1) // Invalid
{
return;
}
UUID recipientID = new UUID(im.toAgentID);
// Bucket is the asset type
AssetType assetType = (AssetType)im.binaryBucket[0];
if (AssetType.Folder == assetType)
{
UUID folderID = new UUID(im.imSessionID);
InventoryFolderBase folder =
scene.InventoryService.GetFolder(recipientID, folderID);
if (folder != null)
{
user.ControllingClient.SendBulkUpdateInventory(folder);
}
}
else
{
UUID itemID = new UUID(im.imSessionID);
InventoryItemBase item =
scene.InventoryService.GetItem(recipientID, itemID);
if (item != null)
{
user.ControllingClient.SendBulkUpdateInventory(item);
}
}
// Fix up binary bucket since this may be 17 chars long here
Byte[] bucket = new Byte[1];
bucket[0] = im.binaryBucket[0];
im.binaryBucket = bucket;
user.ControllingClient.SendInstantMessage(im);
}
else if (im.dialog == (byte)InstantMessageDialog.InventoryAccepted ||
im.dialog == (byte)InstantMessageDialog.InventoryDeclined ||
im.dialog == (byte)InstantMessageDialog.TaskInventoryDeclined ||
im.dialog == (byte)InstantMessageDialog.TaskInventoryAccepted)
{
user.ControllingClient.SendInstantMessage(im);
}
}
public virtual UUID DeleteToInventory(DeRezAction action, UUID folderID,
SceneObjectGroup objectGroup, IClientAPI remoteClient)
{
UUID assetID = UUID.Zero;
Vector3 inventoryStoredPosition = new Vector3
(((objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
? 250
: objectGroup.AbsolutePosition.X)
,
(objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
? 250
: objectGroup.AbsolutePosition.X,
objectGroup.AbsolutePosition.Z);
Vector3 originalPosition = objectGroup.AbsolutePosition;
objectGroup.AbsolutePosition = inventoryStoredPosition;
string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(objectGroup);
objectGroup.AbsolutePosition = originalPosition;
// Get the user info of the item destination
//
UUID userID = UUID.Zero;
if (action == DeRezAction.Take || action == DeRezAction.TakeCopy ||
action == DeRezAction.SaveToExistingUserInventoryItem)
{
// Take or take copy require a taker
// Saving changes requires a local user
//
if (remoteClient == null)
{
return(UUID.Zero);
}
userID = remoteClient.AgentId;
}
else
{
// All returns / deletes go to the object owner
//
userID = objectGroup.RootPart.OwnerID;
}
if (userID == UUID.Zero) // Can't proceed
{
return(UUID.Zero);
}
// If we're returning someone's item, it goes back to the
// owner's Lost And Found folder.
// Delete is treated like return in this case
// Deleting your own items makes them go to trash
//
InventoryFolderBase folder = null;
InventoryItemBase item = null;
if (DeRezAction.SaveToExistingUserInventoryItem == action)
{
item = new InventoryItemBase(objectGroup.RootPart.FromUserInventoryItemID, userID);
item = m_Scene.InventoryService.GetItem(item);
//item = userInfo.RootFolder.FindItem(
// objectGroup.RootPart.FromUserInventoryItemID);
if (null == item)
{
m_log.DebugFormat(
"[AGENT INVENTORY]: Object {0} {1} scheduled for save to inventory has already been deleted.",
objectGroup.Name, objectGroup.UUID);
return(UUID.Zero);
}
}
else
{
// Folder magic
//
if (action == DeRezAction.Delete)
{
// Deleting someone else's item
//
if (remoteClient == null ||
objectGroup.OwnerID != remoteClient.AgentId)
{
folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
}
else
{
folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
}
}
else if (action == DeRezAction.Return)
{
// Dump to lost + found unconditionally
//
folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
}
if (folderID == UUID.Zero && folder == null)
{
if (action == DeRezAction.Delete)
{
// Deletes go to trash by default
//
folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
}
else
{
// Catch all. Use lost & found
//
folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
}
}
if (folder == null) // None of the above
{
folder = new InventoryFolderBase(folderID);
if (folder == null) // Nowhere to put it
{
return(UUID.Zero);
}
}
item = new InventoryItemBase();
item.CreatorId = objectGroup.RootPart.CreatorID.ToString();
item.ID = UUID.Random();
item.InvType = (int)InventoryType.Object;
item.Folder = folder.ID;
item.Owner = userID;
}
AssetBase asset = CreateAsset(
objectGroup.GetPartName(objectGroup.RootPart.LocalId),
objectGroup.GetPartDescription(objectGroup.RootPart.LocalId),
(sbyte)AssetType.Object,
Utils.StringToBytes(sceneObjectXml),
objectGroup.OwnerID.ToString());
m_Scene.AssetService.Store(asset);
assetID = asset.FullID;
if (DeRezAction.SaveToExistingUserInventoryItem == action)
{
item.AssetID = asset.FullID;
m_Scene.InventoryService.UpdateItem(item);
}
else
{
item.AssetID = asset.FullID;
if (remoteClient != null && (remoteClient.AgentId != objectGroup.RootPart.OwnerID) && m_Scene.Permissions.PropagatePermissions())
{
uint perms = objectGroup.GetEffectivePermissions();
uint nextPerms = (perms & 7) << 13;
if ((nextPerms & (uint)PermissionMask.Copy) == 0)
{
perms &= ~(uint)PermissionMask.Copy;
}
if ((nextPerms & (uint)PermissionMask.Transfer) == 0)
{
perms &= ~(uint)PermissionMask.Transfer;
}
if ((nextPerms & (uint)PermissionMask.Modify) == 0)
{
perms &= ~(uint)PermissionMask.Modify;
}
item.BasePermissions = perms & objectGroup.RootPart.NextOwnerMask;
item.CurrentPermissions = item.BasePermissions;
item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask & objectGroup.RootPart.NextOwnerMask;
item.GroupPermissions = objectGroup.RootPart.GroupMask & objectGroup.RootPart.NextOwnerMask;
item.CurrentPermissions |= 8; // Slam!
}
else
{
item.BasePermissions = objectGroup.GetEffectivePermissions();
item.CurrentPermissions = objectGroup.GetEffectivePermissions();
item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask;
item.GroupPermissions = objectGroup.RootPart.GroupMask;
item.CurrentPermissions |= 8; // Slam!
}
// TODO: add the new fields (Flags, Sale info, etc)
item.CreationDate = Util.UnixTimeSinceEpoch();
item.Description = asset.Description;
item.Name = asset.Name;
item.AssetType = asset.Type;
m_Scene.InventoryService.AddItem(item);
if (remoteClient != null && item.Owner == remoteClient.AgentId)
{
remoteClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
ScenePresence notifyUser = m_Scene.GetScenePresence(item.Owner);
if (notifyUser != null)
{
notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
}
}
return(assetID);
}
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
// m_log.DebugFormat(
// "[INVENTORY TRANSFER]: {0} IM type received from client {1}. From={2} ({3}), To={4}",
// (InstantMessageDialog)im.dialog, client.Name,
// im.fromAgentID, im.fromAgentName, im.toAgentID);
Scene scene = FindClientScene(client.AgentId);
if (scene == null) // Something seriously wrong here.
{
return;
}
if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
{
//m_log.DebugFormat("Asset type {0}", ((AssetType)im.binaryBucket[0]));
if (im.binaryBucket.Length < 17) // Invalid
{
return;
}
UUID recipientID = new UUID(im.toAgentID);
ScenePresence user = scene.GetScenePresence(recipientID);
UUID copyID;
// First byte is the asset type
AssetType assetType = (AssetType)im.binaryBucket[0];
if (AssetType.Folder == assetType)
{
UUID folderID = new UUID(im.binaryBucket, 1);
m_log.DebugFormat(
"[INVENTORY TRANSFER]: Inserting original folder {0} into agent {1}'s inventory",
folderID, new UUID(im.toAgentID));
InventoryFolderBase folderCopy
= scene.GiveInventoryFolder(client, recipientID, client.AgentId, folderID, UUID.Zero);
if (folderCopy == null)
{
client.SendAgentAlertMessage("Can't find folder to give. Nothing given.", false);
return;
}
// The outgoing binary bucket should contain only the byte which signals an asset folder is
// being copied and the following bytes for the copied folder's UUID
copyID = folderCopy.ID;
byte[] copyIDBytes = copyID.GetBytes();
im.binaryBucket = new byte[1 + copyIDBytes.Length];
im.binaryBucket[0] = (byte)AssetType.Folder;
Array.Copy(copyIDBytes, 0, im.binaryBucket, 1, copyIDBytes.Length);
if (user != null)
{
user.ControllingClient.SendBulkUpdateInventory(folderCopy);
}
// HACK!!
// Insert the ID of the copied folder into the IM so that we know which item to move to trash if it
// is rejected.
// XXX: This is probably a misuse of the session ID slot.
im.imSessionID = copyID.Guid;
}
else
{
// First byte of the array is probably the item type
// Next 16 bytes are the UUID
UUID itemID = new UUID(im.binaryBucket, 1);
m_log.DebugFormat("[INVENTORY TRANSFER]: (giving) Inserting item {0} " +
"into agent {1}'s inventory",
itemID, new UUID(im.toAgentID));
string message;
InventoryItemBase itemCopy = scene.GiveInventoryItem(new UUID(im.toAgentID), client.AgentId, itemID, out message);
if (itemCopy == null)
{
client.SendAgentAlertMessage(message, false);
return;
}
copyID = itemCopy.ID;
Array.Copy(copyID.GetBytes(), 0, im.binaryBucket, 1, 16);
if (user != null)
{
user.ControllingClient.SendBulkUpdateInventory(itemCopy);
}
// HACK!!
// Insert the ID of the copied item into the IM so that we know which item to move to trash if it
// is rejected.
// XXX: This is probably a misuse of the session ID slot.
im.imSessionID = copyID.Guid;
}
im.offline = 0;
// Send the IM to the recipient. The item is already
// in their inventory, so it will not be lost if
// they are offline.
//
if (user != null)
{
user.ControllingClient.SendInstantMessage(im);
return;
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im, delegate(bool success)
{
if (!success)
{
client.SendAlertMessage("User not online. Inventory has been saved");
}
});
}
}
}
else if (im.dialog == (byte)InstantMessageDialog.InventoryAccepted ||
im.dialog == (byte)InstantMessageDialog.TaskInventoryAccepted)
{
UUID inventoryID = new UUID(im.imSessionID); // The inventory item/folder, back from it's trip
IInventoryService invService = scene.InventoryService;
// Special case: folder redirect.
// RLV uses this
if (im.dialog == (byte)InstantMessageDialog.TaskInventoryAccepted)
{
InventoryFolderBase folder = invService.GetFolder(client.AgentId, inventoryID);
if (folder != null)
{
if (im.binaryBucket.Length >= 16)
{
UUID destFolderID = new UUID(im.binaryBucket, 0);
if (destFolderID != UUID.Zero)
{
InventoryFolderBase destFolder = invService.GetFolder(client.AgentId, destFolderID);
if (destFolder != null)
{
if (folder.ParentID != destFolder.ID)
{
folder.ParentID = destFolder.ID;
invService.MoveFolder(folder);
client.SendBulkUpdateInventory(folder);
}
}
}
}
}
}
ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
if (user != null) // Local
{
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im, delegate(bool success) {});
}
}
}
// XXX: This code was placed here to try and accomodate RLV which moves given folders named #RLV/~<name>
// to the requested folder, which in this case is #RLV. However, it is the viewer that appears to be
// response from renaming the #RLV/~example folder to ~example. For some reason this is not yet
// happening, possibly because we are not sending the correct inventory update messages with the correct
// transaction IDs
else if (im.dialog == (byte)InstantMessageDialog.TaskInventoryAccepted)
{
UUID destinationFolderID = UUID.Zero;
if (im.binaryBucket != null && im.binaryBucket.Length >= 16)
{
destinationFolderID = new UUID(im.binaryBucket, 0);
}
if (destinationFolderID != UUID.Zero)
{
InventoryFolderBase destinationFolder = new InventoryFolderBase(destinationFolderID, client.AgentId);
IInventoryService invService = scene.InventoryService;
UUID inventoryID = new UUID(im.imSessionID); // The inventory item/folder, back from it's trip
InventoryItemBase item = invService.GetItem(client.AgentId, inventoryID);
InventoryFolderBase folder = null;
UUID?previousParentFolderID = null;
if (item != null) // It's an item
{
previousParentFolderID = item.Folder;
item.Folder = destinationFolderID;
invService.DeleteItems(item.Owner, new List <UUID>()
{
item.ID
});
scene.AddInventoryItem(client, item);
}
else
{
folder = invService.GetFolder(client.AgentId, inventoryID);
if (folder != null) // It's a folder
{
previousParentFolderID = folder.ParentID;
folder.ParentID = destinationFolderID;
invService.MoveFolder(folder);
}
}
// Tell client about updates to original parent and new parent (this should probably be factored with existing move item/folder code).
if (previousParentFolderID != null)
{
InventoryFolderBase previousParentFolder = invService.GetFolder(client.AgentId, (UUID)previousParentFolderID);
scene.SendInventoryUpdate(client, previousParentFolder, true, true);
scene.SendInventoryUpdate(client, destinationFolder, true, true);
}
}
}
else if (
im.dialog == (byte)InstantMessageDialog.InventoryDeclined ||
im.dialog == (byte)InstantMessageDialog.TaskInventoryDeclined)
{
// Here, the recipient is local and we can assume that the
// inventory is loaded. Courtesy of the above bulk update,
// It will have been pushed to the client, too
//
IInventoryService invService = scene.InventoryService;
InventoryFolderBase trashFolder =
invService.GetFolderForType(client.AgentId, FolderType.Trash);
UUID inventoryID = new UUID(im.imSessionID); // The inventory item/folder, back from it's trip
InventoryItemBase item = invService.GetItem(client.AgentId, inventoryID);
InventoryFolderBase folder = null;
UUID?previousParentFolderID = null;
if (item != null && trashFolder != null)
{
previousParentFolderID = item.Folder;
item.Folder = trashFolder.ID;
// Diva comment: can't we just update this item???
List <UUID> uuids = new List <UUID>();
uuids.Add(item.ID);
invService.DeleteItems(item.Owner, uuids);
scene.AddInventoryItem(client, item);
}
else
{
folder = invService.GetFolder(client.AgentId, inventoryID);
if (folder != null && trashFolder != null)
{
previousParentFolderID = folder.ParentID;
folder.ParentID = trashFolder.ID;
invService.MoveFolder(folder);
client.SendBulkUpdateInventory(folder);
}
}
if ((null == item && null == folder) || null == trashFolder)
{
string reason = String.Empty;
if (trashFolder == null)
{
reason += " Trash folder not found.";
}
if (item == null)
{
reason += " Item not found.";
}
if (folder == null)
{
reason += " Folder not found.";
}
client.SendAgentAlertMessage("Unable to delete " +
"received inventory" + reason, false);
}
// Tell client about updates to original parent and new parent (this should probably be factored with existing move item/folder code).
else if (previousParentFolderID != null)
{
InventoryFolderBase previousParentFolder = invService.GetFolder(client.AgentId, (UUID)previousParentFolderID);
scene.SendInventoryUpdate(client, previousParentFolder, true, true);
scene.SendInventoryUpdate(client, trashFolder, true, true);
}
if (im.dialog == (byte)InstantMessageDialog.InventoryDeclined)
{
ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
if (user != null) // Local
{
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im, delegate(bool success) { });
}
}
}
}
}
private void RecursiveCollectFullPermTextureIds(OpenSim.Data.IInventoryStorage inv, InventoryFolderBase parentFolder, HashSet <UUID> fullPermTextures)
{
//depth first
foreach (var childFolder in parentFolder.SubFolders)
{
InventoryFolderBase fullChild = inv.GetFolder(childFolder.ID);
RecursiveCollectFullPermTextureIds(inv, fullChild, fullPermTextures);
}
foreach (var item in parentFolder.Items)
{
if (item.AssetType == (int)AssetType.Texture)
{
if (((item.CurrentPermissions & (uint)PermissionMask.Copy) != 0) &&
((item.CurrentPermissions & (uint)PermissionMask.Modify) != 0) &&
((item.CurrentPermissions & (uint)PermissionMask.Transfer) != 0))
{
fullPermTextures.Add(item.AssetID);
}
}
}
}
private void CreateLink()
{
if (!_scene.Permissions.CanCreateUserInventory((int)InventoryType.Wearable, _avatarID))
{
return;
}
ScenePresence presence;
if ((presence = _scene.GetScenePresence(_avatarID)) != null)
{
// Don't link to default items
if ((_wearableInventoryItemID == AvatarWearable.DEFAULT_EYES_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_BODY_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_HAIR_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_PANTS_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_SHIRT_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_SKIN_ITEM))
{
return;
}
CachedUserInfo userInfo = _scene.CommsManager.UserService.GetUserDetails(_avatarID);
if (userInfo != null)
{
InventoryItemBase oldItem = null;
try
{
oldItem = userInfo.FindItem(_wearableInventoryItemID);
}
catch { }
if (oldItem == null)
{
return;//Item doesn't exist?
}
InventoryFolderBase CurrentOutfitFolder = GetCurrentOutfitFolder(userInfo);
if (CurrentOutfitFolder == null)
{
return; //No COF, just ignore
}
CurrentOutfitFolder.Version++;
userInfo.UpdateFolder(CurrentOutfitFolder);
InventoryItemBase item = new InventoryItemBase();
item.Owner = _avatarID;
item.CreatorId = _avatarID.ToString();
item.ID = UUID.Random();
item.AssetID = _wearableInventoryItemID;
item.Description = oldItem.Description;
item.Name = oldItem.Name;
item.Flags = oldItem.Flags;
item.AssetType = (int)AssetType.Link;
item.InvType = (int)InventoryType.Wearable;
item.Folder = CurrentOutfitFolder.ID;
item.CreationDate = Util.UnixTimeSinceEpoch();
item.BasePermissions = (uint)(PermissionMask.All | PermissionMask.Export);
item.CurrentPermissions = (uint)(PermissionMask.All | PermissionMask.Export);
item.GroupPermissions = (uint)PermissionMask.None;
item.EveryOnePermissions = (uint)PermissionMask.None;
item.NextPermissions = (uint)PermissionMask.All;
userInfo.AddItem(item);
presence.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
m_log.WarnFormat(
"No user details associated with client {0} uuid {1} in CreateNewInventoryItem!",
presence.Name, presence.UUID);
}
}
else
{
m_log.ErrorFormat(
"ScenePresence for agent uuid {0} unexpectedly not found in HandleLinkInventoryItem",
_avatarID);
}
}
public void addInventoryFolder(InventoryFolderBase folder) { m_wrappedPlugin.addInventoryFolder(folder); }
/// <summary>
/// See IInventoryDataPlugin
/// </summary>
/// <param name="parentID"></param>
/// <returns></returns>
public List <InventoryFolderBase> getFolderHierarchy(UUID parentID)
{
/* Note: There are subtle changes between this implementation of getFolderHierarchy and the previous one
* - We will only need to hit the database twice instead of n times.
* - We assume the database is well-formed - no stranded/dangling folders, all folders in heirarchy owned
* by the same person, each user only has 1 inventory heirarchy
* - The returned list is not ordered, instead of breadth-first ordered
* There are basically 2 usage cases for getFolderHeirarchy:
* 1) Getting the user's entire inventory heirarchy when they log in
* 2) Finding a subfolder heirarchy to delete when emptying the trash.
* This implementation will pull all inventory folders from the database, and then prune away any folder that
* is not part of the requested sub-heirarchy. The theory is that it is cheaper to make 1 request from the
* database than to make n requests. This pays off only if requested heirarchy is large.
* By making this choice, we are making the worst case better at the cost of making the best case worse
* - Francis
*/
List <InventoryFolderBase> folders = new List <InventoryFolderBase>();
DataRow[] folderRows = null, parentRow;
InventoryFolderBase parentFolder = null;
lock (ds)
{
/* Fetch the parent folder from the database to determine the agent ID.
* Then fetch all inventory folders for that agent from the agent ID.
*/
DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
string selectExp = "UUID = '" + parentID + "'";
parentRow = inventoryFolderTable.Select(selectExp); // Assume at most 1 result
if (parentRow.GetLength(0) >= 1) // No result means parent folder does not exist
{
parentFolder = buildFolder(parentRow[0]);
UUID agentID = parentFolder.Owner;
selectExp = "agentID = '" + agentID + "'";
folderRows = inventoryFolderTable.Select(selectExp);
}
if (folderRows != null && folderRows.GetLength(0) >= 1) // No result means parent folder does not exist
{ // or has no children
/* if we're querying the root folder, just return an unordered list of all folders in the user's
* inventory
*/
if (parentFolder.ParentID == UUID.Zero)
{
foreach (DataRow row in folderRows)
{
InventoryFolderBase curFolder = buildFolder(row);
if (curFolder.ID != parentID) // Return all folders except the parent folder of heirarchy
{
folders.Add(buildFolder(row));
}
}
} // If requesting root folder
/* else we are querying a non-root folder. We currently have a list of all of the user's folders,
* we must construct a list of all folders in the heirarchy below parentID.
* Our first step will be to construct a hash table of all folders, indexed by parent ID.
* Once we have constructed the hash table, we will do a breadth-first traversal on the tree using the
* hash table to find child folders.
*/
else
{ // Querying a non-root folder
// Build a hash table of all user's inventory folders, indexed by each folder's parent ID
Dictionary <UUID, List <InventoryFolderBase> > hashtable =
new Dictionary <UUID, List <InventoryFolderBase> >(folderRows.GetLength(0));
foreach (DataRow row in folderRows)
{
InventoryFolderBase curFolder = buildFolder(row);
if (curFolder.ParentID != UUID.Zero) // Discard root of tree - not needed
{
if (hashtable.ContainsKey(curFolder.ParentID))
{
// Current folder already has a sibling - append to sibling list
hashtable[curFolder.ParentID].Add(curFolder);
}
else
{
List <InventoryFolderBase> siblingList = new List <InventoryFolderBase>();
siblingList.Add(curFolder);
// Current folder has no known (yet) siblings
hashtable.Add(curFolder.ParentID, siblingList);
}
}
} // For all inventory folders
// Note: Could release the ds lock here - we don't access folderRows or the database anymore.
// This is somewhat of a moot point as the callers of this function usually lock db anyways.
if (hashtable.ContainsKey(parentID)) // if requested folder does have children
{
folders.AddRange(hashtable[parentID]);
}
// BreadthFirstSearch build inventory tree **Note: folders.Count is *not* static
for (int i = 0; i < folders.Count; i++)
{
if (hashtable.ContainsKey(folders[i].ID))
{
folders.AddRange(hashtable[folders[i].ID]);
}
}
} // if requesting a subfolder heirarchy
} // if folder parentID exists and has children
} // lock ds
return(folders);
}
public void moveInventoryFolder(InventoryFolderBase folder) { m_wrappedPlugin.moveInventoryFolder(folder); }
/// <summary>
/// Adds a new folder specified by folder
/// </summary>
/// <param name="folder">The inventory folder</param>
public void addInventoryFolder(InventoryFolderBase folder)
{
addFolder(folder, true);
}
public bool QueryFolder(InventoryFolderBase folder)
{
return true;
}
/// <summary>
/// Updates a folder based on its ID with folder
/// </summary>
/// <param name="folder">The inventory folder</param>
public void updateInventoryFolder(InventoryFolderBase folder)
{
addFolder(folder, false);
}
private InventoryItemBase GiveInventoryItem(UUID senderId, UUID recipient, UUID itemId, InventoryFolderBase parentFolder)
{
InventoryItemBase item = new InventoryItemBase(itemId, senderId);
item = m_scene.InventoryService.GetItem(item);
InventoryItemBase itemCopy = new InventoryItemBase();
itemCopy.Owner = recipient;
itemCopy.CreatorId = item.CreatorId;
itemCopy.ID = UUID.Random();
itemCopy.AssetID = item.AssetID;
itemCopy.Description = item.Description;
itemCopy.Name = item.Name;
itemCopy.AssetType = item.AssetType;
itemCopy.InvType = item.InvType;
itemCopy.Folder = UUID.Zero;
//Give full permissions for them
itemCopy.NextPermissions = (uint)PermissionMask.All;
itemCopy.GroupPermissions = (uint)PermissionMask.All;
itemCopy.EveryOnePermissions = (uint)PermissionMask.All;
itemCopy.CurrentPermissions = (uint)PermissionMask.All;
if (parentFolder == null)
{
InventoryFolderBase folder = m_scene.InventoryService.GetFolderForType(recipient, (AssetType)itemCopy.AssetType);
if (folder != null)
itemCopy.Folder = folder.ID;
else
{
InventoryFolderBase root = m_scene.InventoryService.GetRootFolder(recipient);
if (root != null)
itemCopy.Folder = root.ID;
else
return null; // No destination
}
}
else
itemCopy.Folder = parentFolder.ID; //We already have a folder to put it in
itemCopy.GroupID = UUID.Zero;
itemCopy.GroupOwned = false;
itemCopy.Flags = item.Flags;
itemCopy.SalePrice = item.SalePrice;
itemCopy.SaleType = item.SaleType;
if (m_scene.InventoryService.AddItem(itemCopy))
{
IInventoryAccessModule invAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>();
if (invAccess != null)
invAccess.TransferInventoryAssets(itemCopy, senderId, recipient);
}
return itemCopy;
}
/// <summary>
/// Handle a client request to update the inventory folder
/// </summary>
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// 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="folderID"></param>
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="parentID"></param>
public bool UpdateFolder(string name, UUID folderID, ushort type, UUID parentID)
{
// m_log.DebugFormat(
// "[AGENT INVENTORY]: Updating inventory folder {0} {1} for {2} {3}", folderID, name, remoteClient.Name, remoteClient.AgentId);
if (m_hasReceivedInventory)
{
InventoryFolderImpl folder = RootFolder.FindFolder(folderID);
// Delegate movement if updated parent id isn't the same as the existing parentId
if (folder.ParentID != parentID)
MoveFolder(folderID, parentID);
InventoryFolderBase baseFolder = new InventoryFolderBase();
baseFolder.Owner = m_userProfile.ID;
baseFolder.ID = folderID;
baseFolder.Name = name;
baseFolder.ParentID = parentID;
baseFolder.Type = (short)type;
baseFolder.Version = RootFolder.Version;
m_InventoryService.UpdateFolder(baseFolder);
folder.Name = name;
folder.Type = (short)type;
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(UpdateFolderDelegate), this, "UpdateFolder"),
new object[] { name, folderID, type, parentID }));
}
return true;
}
private void LoadItems(OSDMap items, UUID OwnerID, InventoryFolderBase folderForAppearance, AvatarAppearance appearance, out List<InventoryItemBase> litems)
{
litems = new List<InventoryItemBase>();
foreach (KeyValuePair<string, OSD> kvp in items)
{
string serialization = kvp.Value.AsString();
InventoryItemBase item = OpenSim.Framework.Serialization.External.UserInventoryItemSerializer.Deserialize(serialization);
m_log.Info("[AvatarArchive]: Loading item " + item.ID.ToString());
UUID oldID = item.ID;
item = GiveInventoryItem(item.CreatorIdAsUuid, OwnerID, item, folderForAppearance);
litems.Add(item);
FixItemIDs(oldID, item, appearance);
}
}
public AvatarArchive LoadAvatarArchive(string fileName, UUID principalID)
{
AvatarArchive archive = new AvatarArchive();
UserAccount account = userAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[Avatar Archiver]: User not found!");
return(null);
}
// need to be smart here...
fileName = PathHelpers.VerifyReadFile(fileName, ".aa", m_storeDirectory);
if (!File.Exists(fileName))
{
MainConsole.Instance.Error("[Avatar Archiver]: Unable to load from file: file does not exist!");
return(null);
}
MainConsole.Instance.Info("[Avatar Archiver]: Loading archive from " + fileName);
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(fileName)));
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(archive.BodyMap);
appearance.Owner = principalID;
InventoryFolderBase AppearanceFolder = inventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
FolderType.Clothing);
if (AppearanceFolder == null)
{
AppearanceFolder = new InventoryFolderBase(); // does not exist so...
AppearanceFolder.Owner = account.PrincipalID;
AppearanceFolder.ID = UUID.Random();
AppearanceFolder.Type = (short)FolderType.Clothing;
}
List <InventoryItemBase> items;
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), archive.FolderName, account.PrincipalID,
(short)FolderType.None, AppearanceFolder.ID, 1);
inventoryService.AddFolder(folderForAppearance);
folderForAppearance = inventoryService.GetFolder(folderForAppearance);
try {
LoadAssets(archive.AssetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance,
account.PrincipalID, archive.ItemsMap, out items);
} catch (Exception ex) {
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
/* implement fully if we need to
* // inform the client if needed
*
* ScenePresence SP;
* MainConsole.Instance.ConsoleScenes[0].TryGetScenePresence(account.PrincipalID, out SP);
* if (SP == null)
* return; // nobody home!
*
* SP.ControllingClient.SendAlertMessage("Appearance loading in progress...");
* SP.ControllingClient.SendBulkUpdateInventory(folderForAppearance);
*/
MainConsole.Instance.Info("[Avatar Archiver]: Loaded archive from " + fileName);
archive.Appearance = appearance;
return(archive);
}
/// <summary>
/// Moves a folder based on its ID with folder
/// </summary>
/// <param name="folder">The inventory folder</param>
public void moveInventoryFolder(InventoryFolderBase folder)
{
moveFolder(folder);
}
////////////////////////////////////////////////
// User-to-user inventory offers
private void UserInventoryOffer(IClientAPI client, Scene scene, GridInstantMessage im)
{
InventoryFolderBase folder = null;
InventoryItemBase item = null;
UUID toAgentID = new UUID(im.toAgentID);
IMuteListModule m_muteListModule = scene.RequestModuleInterface <IMuteListModule>();
if (m_muteListModule != null)
{
if (m_muteListModule.IsMuted(client.AgentId, toAgentID))
{
client.SendAgentAlertMessage("Inventory offer was automatically declined.", false);
return; // recipient has sender muted
}
}
// Unpack the binary bucket
AssetType assetType = (AssetType)im.binaryBucket[0];
UUID destID = new UUID(im.binaryBucket, 1);
UUID copyID;
bool isFolder = (assetType == AssetType.Folder);
ScenePresence recipient = scene.GetScenePresence(toAgentID);
if (recipient != null && recipient.IsBot)
{
client.SendAgentAlertMessage("Can't give inventory to bots.", false);
return;//can't give objects to bots
}
if (assetType == AssetType.Folder)
{
folder = scene.GiveInventoryFolder(toAgentID, client.AgentId, destID, UUID.Zero);
if (folder == null)
{
client.SendAgentAlertMessage("Can't find folder to give. Nothing given.", false);
return;
}
copyID = folder.ID;
}
else
{
item = scene.GiveInventoryItem(toAgentID, client.AgentId, destID);
if (item == null)
{
client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
return;
}
copyID = item.ID;
}
// m_log.InfoFormat("[AGENT INVENTORY]: Offering {0} {1} to user {2} inventory as {3}", isFolder ? "folder" : "item", destID, toAgentID, copyID);
// Update the asset type and destination ID into the outgoing IM.
im.binaryBucket = new byte[17];
im.binaryBucket[0] = (byte)assetType;
Array.Copy(copyID.GetBytes(), 0, im.binaryBucket, 1, 16);
// Also stuff the destination ID into the session ID field for retrieval in accept/decline
im.imSessionID = copyID.Guid;
CachedUserInfo recipientInfo = scene.CommsManager.UserService.GetUserDetails(toAgentID);
if (recipientInfo != null && recipient != null)
{
if ((!isFolder) && (item != null))
{
// item offer?
recipient.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
if (isFolder && (folder != null))
{
// folder offer?
folder = recipientInfo.GetFolder(folder.ID);
if (folder != null)
{
recipient.ControllingClient.SendBulkUpdateInventory(folder);
recipientInfo.SendInventoryDecendents(recipient.ControllingClient, folder.ID, false, true);
}
}
}
// Send the IM to the recipient. The item is already in their inventory, so
// it will not be lost if they are offline. Transaction ID is the item ID.
// We get that same ID back on the reply so we know what to act on.
RelayInventoryOfferIM(scene, recipient, im);
}
/// <summary>
/// This method will delete all the items and folders in the given folder.
/// </summary>
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// <param name="folderID"></param>
public bool PurgeFolder(UUID folderID)
{
// m_log.InfoFormat("[AGENT INVENTORY]: Purging folder {0} for {1} uuid {2}",
// folderID, remoteClient.Name, remoteClient.AgentId);
if (m_hasReceivedInventory)
{
InventoryFolderImpl purgedFolder = RootFolder.FindFolder(folderID);
if (purgedFolder != null)
{
// XXX Nasty - have to create a new object to hold details we already have
InventoryFolderBase purgedBaseFolder = new InventoryFolderBase();
purgedBaseFolder.Owner = purgedFolder.Owner;
purgedBaseFolder.ID = purgedFolder.ID;
purgedBaseFolder.Name = purgedFolder.Name;
purgedBaseFolder.ParentID = purgedFolder.ParentID;
purgedBaseFolder.Type = purgedFolder.Type;
purgedBaseFolder.Version = purgedFolder.Version;
m_InventoryService.PurgeFolder(purgedBaseFolder);
purgedFolder.Purge();
return true;
}
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(PurgeFolderDelegate), this, "PurgeFolder"),
new object[] { folderID }));
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="row"></param>
/// <param name="folder"></param>
private static void moveFolderRow(DataRow row, InventoryFolderBase folder)
{
row["UUID"] = folder.ID.ToString();
row["parentID"] = folder.ParentID.ToString();
}
public virtual bool PurgeFolder(InventoryFolderBase folder)
{
if (!m_AllowDelete && !ParentIsLinkFolder(folder.ID))
return false;
if (!ParentIsTrash(folder.ID))
return false;
List<InventoryFolderBase> subFolders = m_Database.GetFolders(
new string[] { "parentFolderID" },
new string[] { folder.ID.ToString() });
foreach (InventoryFolderBase x in subFolders)
{
PurgeFolder(x);
m_Database.DeleteFolders("folderID", x.ID.ToString(), true);
}
m_Database.DeleteItems("parentFolderID", folder.ID.ToString());
return true;
}
public void TestWearAttachmentFromGround()
{
TestHelpers.InMethod();
// TestHelpers.EnableLogging();
Scene scene = CreateTestScene();
UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
SceneObjectGroup so2 = SceneHelpers.AddSceneObject(scene, "att2", sp.UUID);
{
SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, "att1", sp.UUID);
m_numberOfAttachEventsFired = 0;
scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Default, false, true, false);
// Check status on scene presence
Assert.That(sp.HasAttachments(), Is.True);
List <SceneObjectGroup> attachments = sp.GetAttachments();
Assert.That(attachments.Count, Is.EqualTo(1));
SceneObjectGroup attSo = attachments[0];
Assert.That(attSo.Name, Is.EqualTo(so.Name));
Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
Assert.That(attSo.IsAttachment);
Assert.That(attSo.UsesPhysics, Is.False);
Assert.That(attSo.IsTemporary, Is.False);
// Check item status
Assert.That(
sp.Appearance.GetAttachpoint(attSo.FromItemID),
Is.EqualTo((int)AttachmentPoint.LeftHand));
InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
Assert.That(attachmentItem, Is.Not.Null);
Assert.That(attachmentItem.Name, Is.EqualTo(so.Name));
InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object);
Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(2));
// Check events
Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
}
// Test wearing a different attachment from the ground.
{
scene.AttachmentsModule.AttachObject(sp, so2, (uint)AttachmentPoint.Default, false, true, false);
// Check status on scene presence
Assert.That(sp.HasAttachments(), Is.True);
List <SceneObjectGroup> attachments = sp.GetAttachments();
Assert.That(attachments.Count, Is.EqualTo(1));
SceneObjectGroup attSo = attachments[0];
Assert.That(attSo.Name, Is.EqualTo(so2.Name));
Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
Assert.That(attSo.IsAttachment);
Assert.That(attSo.UsesPhysics, Is.False);
Assert.That(attSo.IsTemporary, Is.False);
// Check item status
Assert.That(
sp.Appearance.GetAttachpoint(attSo.FromItemID),
Is.EqualTo((int)AttachmentPoint.LeftHand));
InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
Assert.That(attachmentItem, Is.Not.Null);
Assert.That(attachmentItem.Name, Is.EqualTo(so2.Name));
InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object);
Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
// Check events
Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
}
// Test rewearing an already worn attachment from ground. Nothing should happen.
{
scene.AttachmentsModule.AttachObject(sp, so2, (uint)AttachmentPoint.Default, false, true, false);
// Check status on scene presence
Assert.That(sp.HasAttachments(), Is.True);
List <SceneObjectGroup> attachments = sp.GetAttachments();
Assert.That(attachments.Count, Is.EqualTo(1));
SceneObjectGroup attSo = attachments[0];
Assert.That(attSo.Name, Is.EqualTo(so2.Name));
Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
Assert.That(attSo.IsAttachment);
Assert.That(attSo.UsesPhysics, Is.False);
Assert.That(attSo.IsTemporary, Is.False);
// Check item status
Assert.That(
sp.Appearance.GetAttachpoint(attSo.FromItemID),
Is.EqualTo((int)AttachmentPoint.LeftHand));
InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
Assert.That(attachmentItem, Is.Not.Null);
Assert.That(attachmentItem.Name, Is.EqualTo(so2.Name));
InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object);
Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
// Check events
Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
}
}
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 ();
rootFolder.Name = "My Inventory";
rootFolder.Type = (short)AssetType.RootFolder;
rootFolder.Version = 1;
rootFolder.ID = rootFolders[0].ParentID;
rootFolder.Owner = principalID;
rootFolder.ParentID = UUID.Zero;
m_Database.StoreFolder(rootFolder);
}
result = true;
}
return result;
}
/// <summary>
/// Execute the request
/// </summary>
/// <returns>
/// A list of the inventory nodes loaded. If folders were loaded then only the root folders are
/// returned
/// </returns>
public HashSet <InventoryNodeBase> Execute(bool loadAll)
{
if (m_loadStream == null)
{
return(new HashSet <InventoryNodeBase> ());
}
string filePath = "ERROR";
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
int successfulItemRestores = 0;
HashSet <InventoryNodeBase> loadedNodes = loadAll ? new HashSet <InventoryNodeBase> () : null;
try {
List <InventoryFolderBase> folderCandidates
= InventoryArchiveUtils.FindFolderByPath(m_inventoryService, m_userInfo.PrincipalID, m_invPath);
if (folderCandidates.Count == 0)
{
// try and create requested folder
var rootFolder = m_inventoryService.GetRootFolder(m_userInfo.PrincipalID);
if (rootFolder == null)
{
if (m_inventoryService.CreateUserInventory(m_userInfo.PrincipalID, true))
{
rootFolder = m_inventoryService.GetRootFolder(m_userInfo.PrincipalID);
}
else
{
MainConsole.Instance.Error("[Inventory Archiver]: Unable to create Inventory root folder");
return(loadedNodes); // major bummer
}
}
InventoryFolderBase iarImportFolder = new InventoryFolderBase();
iarImportFolder.ID = UUID.Random();
iarImportFolder.Name = m_invPath; // the path
iarImportFolder.Owner = m_userInfo.PrincipalID; // owner
iarImportFolder.ParentID = rootFolder.ID; // the root folder
iarImportFolder.Type = (short)FolderType.None; // user defined folder
iarImportFolder.Version = 1; // initial version
m_inventoryService.AddFolder(iarImportFolder);
// ensure that it now exists...
folderCandidates = InventoryArchiveUtils.FindFolderByPath(m_inventoryService, m_userInfo.PrincipalID, m_invPath);
if (folderCandidates.Count == 0)
{
MainConsole.Instance.ErrorFormat("[Inventory Archiver]: Unable to create Inventory path {0}", m_invPath);
return(loadedNodes);
}
}
// we have the base folder... do it...
InventoryFolderBase rootDestinationFolder = folderCandidates [0];
archive = new TarArchiveReader(m_loadStream);
// In order to load identically named folders, we need to keep track of the folders that we have already
// resolved
Dictionary <string, InventoryFolderBase> resolvedFolders = new Dictionary <string, InventoryFolderBase> ();
MainConsole.Instance.Info("[Archiver]: Commencing load from archive");
int ticker = 0;
byte [] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_NORMAL_FILE == entryType)
{
string fName;
try {
fName = Path.GetFileName(filePath);
if (fName.StartsWith(".", StringComparison.Ordinal)) // ignore hidden files
{
continue;
}
} catch {
MainConsole.Instance.ErrorFormat("[Archiver]: Invalid file name in archive: {0}", filePath);
continue;
}
}
ticker++;
if (ticker % 5 == 0)
{
MainConsole.Instance.Ticker();
}
if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH, StringComparison.Ordinal))
{
if (LoadAsset(filePath, data))
{
successfulAssetRestores++;
}
else
{
failedAssetRestores++;
}
if ((successfulAssetRestores) % 50 == 0)
{
MainConsole.Instance.Ticker(
string.Format(" [Inventory Archiver]: Loaded {0} assets...", successfulAssetRestores), true);
}
}
else if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH, StringComparison.Ordinal))
{
filePath = filePath.Substring(ArchiveConstants.INVENTORY_PATH.Length);
// Trim off the file portion if we aren't already dealing with a directory path
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType)
{
filePath = filePath.Remove(filePath.LastIndexOf("/", StringComparison.Ordinal) + 1);
}
InventoryFolderBase foundFolder
= ReplicateArchivePathToUserInventory(
filePath, rootDestinationFolder, ref resolvedFolders, ref loadedNodes);
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType)
{
InventoryItemBase item = LoadItem(data, foundFolder);
if (item != null)
{
successfulItemRestores++;
if ((successfulItemRestores) % 50 == 0)
{
MainConsole.Instance.Ticker(
string.Format("[Inventory Archiver]: Restored {0} items...", successfulItemRestores),
true);
}
// If we aren't loading the folder containing the item then well need to update the
// viewer separately for that item.
if (loadAll && !loadedNodes.Contains(foundFolder))
{
loadedNodes.Add(item);
}
}
item = null;
}
}
else if (filePath == ArchiveConstants.CONTROL_FILE_PATH)
{
LoadControlFile(data);
}
data = null;
}
MainConsole.Instance.CleanInfo("");
MainConsole.Instance.Info("[Inventory Archiver]: Saving loaded inventory items");
ticker = 0;
int successfulItemLoaded = 0;
foreach (InventoryItemBase item in itemsSavedOff)
{
ticker++;
if (ticker % 5 == 0)
{
MainConsole.Instance.Ticker();
}
AddInventoryItem(item);
successfulItemLoaded++;
if ((successfulItemLoaded) % 50 == 0)
{
MainConsole.Instance.Ticker(
string.Format("[Inventory Archiver]: Restored {0} items of {1}...",
successfulItemLoaded, itemsSavedOff.Count),
true);
}
}
itemsSavedOff.Clear();
assets2Save.Clear();
MainConsole.Instance.CleanInfo("");
MainConsole.Instance.InfoFormat(
"[Inventory Archiver]: Successfully loaded {0} assets with {1} failures",
successfulAssetRestores, failedAssetRestores);
MainConsole.Instance.InfoFormat("[Inventory Archiver]: Successfully loaded {0} items",
successfulItemRestores);
} finally {
m_loadStream.Close();
}
return(loadedNodes);
}
private void CreateInventorySkel(UserProfileData userProf)
{
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
IInventoryStorage storage = inventorySelect.GetProvider(userProf.ID);
InventoryFolderBase folder = new InventoryFolderBase();
UUID user = userProf.ID;
folder.ParentID = UUID.Zero;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "My Inventory";
folder.Type = (short)AssetType.Folder;
folder.Version = 1;
storage.CreateFolder(folder);
UUID rootFolder = folder.ID;
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Animations";
folder.Type = (short)AssetType.Animation;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Body Parts";
folder.Type = (short)AssetType.Bodypart;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Calling Cards";
folder.Type = (short)AssetType.CallingCard;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Clothing";
folder.Type = (short)AssetType.Clothing;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Gestures";
folder.Type = (short)AssetType.Gesture;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Landmarks";
folder.Type = (short)AssetType.Landmark;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Lost And Found";
folder.Type = (short)AssetType.LostAndFoundFolder;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Notecards";
folder.Type = (short)AssetType.Notecard;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Objects";
folder.Type = (short)AssetType.Object;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Photo Album";
folder.Type = (short)AssetType.SnapshotFolder;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Scripts";
folder.Type = (short)AssetType.LSLText;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Sounds";
folder.Type = (short)AssetType.Sound;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Textures";
folder.Type = (short)AssetType.Texture;
folder.Version = 1;
storage.CreateFolder(folder);
folder = new InventoryFolderBase();
folder.ParentID = rootFolder;
folder.Owner = user;
folder.ID = UUID.Random();
folder.Name = "Trash";
folder.Type = (short)AssetType.TrashFolder;
folder.Version = 1;
storage.CreateFolder(folder);
}
/// <summary>
/// Create a set of folders for the given path.
/// </summary>
/// <param name="destFolder">
/// The root folder from which the creation will take place.
/// </param>
/// <param name="iarPathExisting">
/// the part of the iar path that already exists
/// </param>
/// <param name="iarPathToReplicate">
/// The path to replicate in the user's inventory from iar
/// </param>
/// <param name="resolvedFolders">
/// The folders that we have resolved so far for a given archive path.
/// </param>
/// <param name="loadedNodes">
/// Track the inventory nodes created.
/// </param>
protected void CreateFoldersForPath(
InventoryFolderBase destFolder,
string iarPathExisting,
string iarPathToReplicate,
ref Dictionary <string, InventoryFolderBase> resolvedFolders,
ref HashSet <InventoryNodeBase> loadedNodes)
{
string [] rawDirsToCreate = iarPathToReplicate.Split(new [] { '/' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < rawDirsToCreate.Length; i++)
{
//MainConsole.Instance.DebugFormat("[Inventory Archiver]: Creating folder {0} from IAR", rawDirsToCreate[i]);
if (!rawDirsToCreate [i].Contains(ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR))
{
continue;
}
int identicalNameIdentifierIndex
= rawDirsToCreate [i].LastIndexOf(
ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR, StringComparison.Ordinal);
string newFolderName = rawDirsToCreate [i].Remove(identicalNameIdentifierIndex);
newFolderName = InventoryArchiveUtils.UnescapeArchivePath(newFolderName);
UUID newFolderId = UUID.Random(); // assume we need a new ID
// Asset type has to be Unknown here rather than Folder, otherwise the created folder can't be
// deleted once the client has relogged.
// The root folder appears to be labelled AssetType.Folder (shows up as "Category" in the client)
// even though there is a AssetType.RootCategory
destFolder
= new InventoryFolderBase(
newFolderId, newFolderName, m_userInfo.PrincipalID,
(short)FolderType.None, destFolder.ID, 1);
// Check for existing folders
string resPath = "";
foreach (var rPath in resolvedFolders)
{
var pName = rPath.Key;
if (pName.Contains(ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR))
{
int splitIndex =
pName.LastIndexOf(ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR, StringComparison.Ordinal);
pName = pName.Remove(splitIndex);
}
resPath += pName + "/";
}
var existingFolder = m_inventoryService.GetUserFolderID(m_userInfo.PrincipalID, resPath + newFolderName);
if (existingFolder.Count == 0)
{
m_inventoryService.AddFolder(destFolder); // add the folder
}
else
{
destFolder.ID = (UUID)existingFolder [0]; // use the existing ID
}
// Record that we have now created this folder
iarPathExisting += rawDirsToCreate [i] + "/";
MainConsole.Instance.DebugFormat("[Inventory Archiver]: Created folder {0} from IAR", iarPathExisting);
resolvedFolders [iarPathExisting] = destFolder;
if (0 == i && loadedNodes != null)
{
loadedNodes.Add(destFolder);
}
}
}
public void updateInventoryFolder(InventoryFolderBase folder) { m_wrappedPlugin.updateInventoryFolder(folder); }
public virtual bool MoveFolder(InventoryFolderBase folder)
{
return(m_Database.MoveFolder(folder.ID.ToString(), folder.ParentID.ToString()));
}
/// <summary>
/// Create a folder in this agent's inventory.
/// </summary>
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// <param name="parentID"></param>
/// <returns></returns>
public InventoryFolderBase CreateFolder(string folderName, UUID folderID, short folderType, UUID parentID)
{
InventoryFolderBase createdBaseFolder = new InventoryFolderBase();
createdBaseFolder.Owner = UserProfile.ID;
createdBaseFolder.ID = folderID;
createdBaseFolder.Name = folderName;
createdBaseFolder.ParentID = parentID;
createdBaseFolder.Type = (short)folderType;
createdBaseFolder.Version = 1;
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
inventorySelect.GetCheckedProvider(m_userProfile.ID).CreateFolder(UserProfile.ID, createdBaseFolder);
return createdBaseFolder;
}
public virtual bool PurgeFolder(InventoryFolderBase folder)
{
return(PurgeFolder(folder, true));
}
/// <summary>
/// This method will delete all the items and folders in the given folder.
/// </summary>
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// <param name="folderID"></param>
public bool PurgeFolder(InventoryFolderBase folder)
{
try
{
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
inventorySelect.GetProvider(m_userProfile.ID).PurgeFolderContents(folder);
return true;
}
catch (InventoryStorageException)
{
}
return false;
}
/// <summary>
/// Execute the inventory write request
/// </summary>
public void Execute(Dictionary <string, object> options, IUserAccountService userAccountService)
{
if (options.ContainsKey("noassets") && (bool)options["noassets"])
{
SaveAssets = false;
}
try
{
InventoryFolderBase inventoryFolder = null;
InventoryItemBase inventoryItem = null;
InventoryFolderBase rootFolder = m_scene.InventoryService.GetRootFolder(m_userInfo.PrincipalID);
bool saveFolderContentsOnly = false;
// Eliminate double slashes and any leading / on the path.
string[] components
= m_invPath.Split(
new string[] { InventoryFolderImpl.PATH_DELIMITER }, StringSplitOptions.RemoveEmptyEntries);
int maxComponentIndex = components.Length - 1;
// If the path terminates with a STAR then later on we want to archive all nodes in the folder but not the
// folder itself. This may get more sophisicated later on
if (maxComponentIndex >= 0 && components[maxComponentIndex] == STAR_WILDCARD)
{
saveFolderContentsOnly = true;
maxComponentIndex--;
}
else if (maxComponentIndex == -1)
{
// If the user has just specified "/", then don't save the root "My Inventory" folder. This is
// more intuitive then requiring the user to specify "/*" for this.
saveFolderContentsOnly = true;
}
m_invPath = String.Empty;
for (int i = 0; i <= maxComponentIndex; i++)
{
m_invPath += components[i] + InventoryFolderImpl.PATH_DELIMITER;
}
// Annoyingly Split actually returns the original string if the input string consists only of delimiters
// Therefore if we still start with a / after the split, then we need the root folder
if (m_invPath.Length == 0)
{
inventoryFolder = rootFolder;
}
else
{
m_invPath = m_invPath.Remove(m_invPath.LastIndexOf(InventoryFolderImpl.PATH_DELIMITER));
List <InventoryFolderBase> candidateFolders
= InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, rootFolder, m_invPath);
if (candidateFolders.Count > 0)
{
inventoryFolder = candidateFolders[0];
}
}
// The path may point to an item instead
if (inventoryFolder == null)
{
inventoryItem = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, rootFolder, m_invPath);
}
if (null == inventoryFolder && null == inventoryItem)
{
// We couldn't find the path indicated
string errorMessage = string.Format("Aborted save. Could not find inventory path {0}", m_invPath);
Exception e = new InventoryArchiverException(errorMessage);
m_module.TriggerInventoryArchiveSaved(m_id, false, m_userInfo, m_invPath, m_saveStream, e);
throw e;
}
m_archiveWriter = new TarArchiveWriter(m_saveStream);
m_log.InfoFormat("[INVENTORY ARCHIVER]: Adding control file to archive.");
// Write out control file. This has to be done first so that subsequent loaders will see this file first
// XXX: I know this is a weak way of doing it since external non-OAR aware tar executables will not do this
// not sure how to fix this though, short of going with a completely different file format.
m_archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, CreateControlFile(options));
if (inventoryFolder != null)
{
m_log.DebugFormat(
"[INVENTORY ARCHIVER]: Found folder {0} {1} at {2}",
inventoryFolder.Name,
inventoryFolder.ID,
m_invPath == String.Empty ? InventoryFolderImpl.PATH_DELIMITER : m_invPath);
//recurse through all dirs getting dirs and files
SaveInvFolder(inventoryFolder, ArchiveConstants.INVENTORY_PATH, !saveFolderContentsOnly, options, userAccountService);
}
else if (inventoryItem != null)
{
m_log.DebugFormat(
"[INVENTORY ARCHIVER]: Found item {0} {1} at {2}",
inventoryItem.Name, inventoryItem.ID, m_invPath);
SaveInvItem(inventoryItem, ArchiveConstants.INVENTORY_PATH, options, userAccountService);
}
// Don't put all this profile information into the archive right now.
//SaveUsers();
if (SaveAssets)
{
m_assetGatherer.GatherAll();
int errors = m_assetGatherer.FailedUUIDs.Count;
m_log.DebugFormat(
"[INVENTORY ARCHIVER]: The items to save reference {0} possible assets", m_assetGatherer.GatheredUuids.Count + errors);
if (errors > 0)
{
m_log.DebugFormat("[INVENTORY ARCHIVER]: {0} of these have problems or are not assets and will be ignored", errors);
}
AssetsRequest ar = new AssetsRequest(
new AssetsArchiver(m_archiveWriter),
m_assetGatherer.GatheredUuids,
m_scene.AssetService,
m_scene.UserAccountService, m_scene.RegionInfo.ScopeID,
options, ReceivedAllAssets);
ar.Execute();
}
else
{
m_log.DebugFormat("[INVENTORY ARCHIVER]: Not saving assets since --noassets was specified");
ReceivedAllAssets(new List <UUID>(), new List <UUID>(), false);
}
}
catch (Exception)
{
m_saveStream.Close();
throw;
}
}
public void MoveItemToTrash(InventoryItemBase item, InventoryFolderBase trashFolder)
{
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
inventorySelect.GetProvider(item.Owner).SendItemToTrash(item, trashFolder.ID);
}
/// <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));
}
private AvatarAppearance CopyWearablesAndAttachments(UUID destination, UUID source,
AvatarAppearance avatarAppearance,
InventoryFolderBase destinationFolder, UUID agentid,
OSDMap itemsMap,
out List<InventoryItemBase> items)
{
if (destinationFolder == null)
throw new Exception("Cannot locate folder(s)");
items = new List<InventoryItemBase>();
List<InventoryItemBase> litems = new List<InventoryItemBase>();
foreach (KeyValuePair<string, OSD> kvp in itemsMap)
{
InventoryItemBase item = new InventoryItemBase();
item.FromOSD((OSDMap)kvp.Value);
MainConsole.Instance.Info("[AvatarArchive]: Loading item " + item.ID.ToString());
litems.Add(item);
}
// Wearables
AvatarWearable[] wearables = avatarAppearance.Wearables;
for (int i = 0; i < wearables.Length; i++)
{
AvatarWearable wearable = wearables[i];
for (int ii = 0; ii < wearable.Count; ii++)
{
if (wearable[ii].ItemID != UUID.Zero)
{
// Get inventory item and copy it
InventoryItemBase item = InventoryService.GetItem(UUID.Zero, wearable[ii].ItemID);
if (item == null)
{
//Attempt to get from the map if it doesn't already exist on the grid
item = litems.First((itm) => itm.ID == wearable[ii].ItemID);
}
if (item != null)
{
InventoryItemBase destinationItem = InventoryService.InnerGiveInventoryItem(destination,
destination,
item,
destinationFolder
.ID,
false, false);
items.Add(destinationItem);
MainConsole.Instance.DebugFormat("[RADMIN]: Added item {0} to folder {1}",
destinationItem.ID, destinationFolder.ID);
// Wear item
AvatarWearable newWearable = new AvatarWearable();
newWearable.Wear(destinationItem.ID, destinationItem.AssetID);
avatarAppearance.SetWearable(i, newWearable);
}
else
{
MainConsole.Instance.WarnFormat("[RADMIN]: Error transferring {0} to folder {1}",
wearable[ii].ItemID, destinationFolder.ID);
}
}
}
}
// Attachments
List<AvatarAttachment> attachments = avatarAppearance.GetAttachments();
foreach (AvatarAttachment attachment in attachments)
{
int attachpoint = attachment.AttachPoint;
UUID itemID = attachment.ItemID;
if (itemID != UUID.Zero)
{
// Get inventory item and copy it
InventoryItemBase item = InventoryService.GetItem(UUID.Zero, itemID);
if (item != null)
{
InventoryItemBase destinationItem = InventoryService.InnerGiveInventoryItem(destination,
destination, item,
destinationFolder.ID,
false, false);
items.Add(destinationItem);
MainConsole.Instance.DebugFormat("[RADMIN]: Added item {0} to folder {1}", destinationItem.ID,
destinationFolder.ID);
// Attach item
avatarAppearance.SetAttachment(attachpoint, destinationItem.ID, destinationItem.AssetID);
MainConsole.Instance.DebugFormat("[RADMIN]: Attached {0}", destinationItem.ID);
}
else
{
MainConsole.Instance.WarnFormat("[RADMIN]: Error transferring {0} to folder {1}", itemID,
destinationFolder.ID);
}
}
}
return avatarAppearance;
}
private UUID CreateCallingCard(UUID userID, UUID creatorID, UUID folderID, bool isGod)
{
IUserAccountService userv = m_Scenes[0].UserAccountService;
if (userv == null)
{
return(UUID.Zero);
}
UserAccount info = userv.GetUserAccount(UUID.Zero, creatorID);
if (info == null)
{
return(UUID.Zero);
}
IInventoryService inv = m_Scenes[0].InventoryService;
if (inv == null)
{
return(UUID.Zero);
}
if (folderID == UUID.Zero)
{
InventoryFolderBase folder = inv.GetFolderForType(userID,
FolderType.CallingCard);
if (folder == null) // Nowhere to put it
{
return(UUID.Zero);
}
folderID = folder.ID;
}
m_log.DebugFormat("[XCALLINGCARD]: Creating calling card for {0} in inventory of {1}", info.Name, userID);
InventoryItemBase item = new InventoryItemBase();
item.AssetID = UUID.Zero;
item.AssetType = (int)AssetType.CallingCard;
item.BasePermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify);
if (isGod)
{
item.BasePermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Move);
}
item.EveryOnePermissions = (uint)PermissionMask.None;
item.CurrentPermissions = item.BasePermissions;
item.NextPermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify);
item.ID = UUID.Random();
item.CreatorId = creatorID.ToString();
item.Owner = userID;
item.GroupID = UUID.Zero;
item.GroupOwned = false;
item.Folder = folderID;
item.CreationDate = Util.UnixTimeSinceEpoch();
item.InvType = (int)InventoryType.CallingCard;
item.Flags = 0;
item.Name = info.Name;
item.Description = "";
item.SalePrice = 10;
item.SaleType = (byte)SaleType.Not;
inv.AddItem(item);
IClientAPI client = FindClientObject(userID);
if (client != null)
{
client.SendBulkUpdateInventory(item);
}
return(item.ID);
}
public void LoadAvatarArchive(string FileName, string First, string Last)
{
UserAccount account = m_scene.UserAccountService.GetUserAccount(UUID.Zero, First, Last);
m_log.Debug("[AvatarArchive] Loading archive from " + FileName);
if (account == null)
{
m_log.Error("[AvatarArchive] User not found!");
return;
}
StreamReader reader = new StreamReader(FileName);
string line = reader.ReadToEnd();
string[] lines = line.Split('\n');
List<string> file = new List<string>(lines);
reader.Close();
reader.Dispose();
ScenePresence SP;
m_scene.TryGetScenePresence(account.PrincipalID, out SP);
if (SP == null)
return; //Bad people!
SP.ControllingClient.SendAlertMessage("Appearance loading in progress...");
SP.Appearance.ClearWearables();
SP.Appearance.ClearAttachments();
SP.SendWearables();
string FolderNameToLoadInto = "";
List<UUID> AttachmentUUIDs = new List<UUID>();
List<string> AttachmentPoints = new List<string>();
List<string> AttachmentAssets = new List<string>();
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(file, out AttachmentUUIDs, out AttachmentPoints, out AttachmentAssets, out FolderNameToLoadInto);
appearance.Owner = account.PrincipalID;
List<InventoryItemBase> items = new List<InventoryItemBase>();
InventoryFolderBase AppearanceFolder = m_scene.InventoryService.GetFolderForType(account.PrincipalID, AssetType.Clothing);
UUID newFolderId = UUID.Random();
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
newFolderId, FolderNameToLoadInto, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
m_scene.InventoryService.AddFolder(folderForAppearance);
folderForAppearance = m_scene.InventoryService.GetFolder(folderForAppearance);
#region Appearance setup
if (appearance.BodyItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.BodyItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.BodyItem, folderForAppearance);
items.Add(IB);
appearance.BodyItem = IB.ID;
}
if (appearance.EyesItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.EyesItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.EyesItem, folderForAppearance);
items.Add(IB);
appearance.EyesItem = IB.ID;
}
if (appearance.GlovesItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.GlovesItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.GlovesItem, folderForAppearance);
items.Add(IB);
appearance.GlovesItem = IB.ID;
}
if (appearance.HairItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.HairItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.HairItem, folderForAppearance);
items.Add(IB);
appearance.HairItem = IB.ID;
}
if (appearance.JacketItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.JacketItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.JacketItem, folderForAppearance);
items.Add(IB);
appearance.JacketItem = IB.ID;
}
if (appearance.PantsItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.PantsItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.PantsItem, folderForAppearance);
items.Add(IB);
appearance.PantsItem = IB.ID;
}
if (appearance.ShirtItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.ShirtItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.ShirtItem, folderForAppearance);
items.Add(IB);
appearance.ShirtItem = IB.ID;
}
if (appearance.ShoesItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.ShoesItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.ShoesItem, folderForAppearance);
items.Add(IB);
appearance.ShoesItem = IB.ID;
}
if (appearance.SkinItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.SkinItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.SkinItem, folderForAppearance);
items.Add(IB);
appearance.SkinItem = IB.ID;
}
if (appearance.SkirtItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.SkirtItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.SkirtItem, folderForAppearance);
items.Add(IB);
appearance.SkirtItem = IB.ID;
}
if (appearance.SocksItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.SocksItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.SocksItem, folderForAppearance);
items.Add(IB);
appearance.SocksItem = IB.ID;
}
if (appearance.UnderPantsItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.UnderPantsItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.UnderPantsItem, folderForAppearance);
items.Add(IB);
appearance.UnderPantsItem = IB.ID;
}
if (appearance.UnderShirtItem != UUID.Zero)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(appearance.UnderShirtItem));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, appearance.UnderShirtItem, folderForAppearance);
items.Add(IB);
appearance.UnderShirtItem = IB.ID;
}
appearance.ClearAttachments(); //Clear so that we can rebuild
int i = 0;
foreach (UUID uuid in AttachmentUUIDs)
{
InventoryItemBase IB = m_scene.InventoryService.GetItem(new InventoryItemBase(uuid));
IB = GiveInventoryItem(IB.CreatorIdAsUuid, appearance.Owner, uuid, folderForAppearance);
items.Add(IB);
appearance.SetAttachment(int.Parse(AttachmentPoints[i]), IB.ID, UUID.Parse(AttachmentAssets[i]));
i++;
}
#endregion
foreach (InventoryItemBase itemCopy in items)
{
if (itemCopy == null)
{
SP.ControllingClient.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
continue;
}
if (!SP.IsChildAgent)
{
SP.ControllingClient.SendBulkUpdateInventory(itemCopy);
}
}
appearance.Owner = account.PrincipalID;
AvatarData adata = new AvatarData(appearance);
m_scene.AvatarService.SetAvatar(account.PrincipalID, adata);
SP.Appearance = appearance;
SP.SendAppearanceToOtherAgent(SP);
SP.SendWearables();
SP.SendAppearanceToAllOtherAgents();
if (appearance.Texture != null)
{
for (i = 0; i < appearance.Texture.FaceTextures.Length; i++)
{
Primitive.TextureEntryFace face = (appearance.Texture.FaceTextures[i]);
if (face != null && face.TextureID != AppearanceManager.DEFAULT_AVATAR_TEXTURE)
{
m_log.Warn("[APPEARANCE]: Missing baked texture " + face.TextureID + " (" + i + ") for avatar " + this.Name);
SP.ControllingClient.SendRebakeAvatarTextures(face.TextureID);
}
}
}
m_log.Debug("[AvatarArchive] Loaded archive from " + FileName);
}
/// <summary>
/// Handle the caps inventory descendents fetch.
/// </summary>
/// <param name="agentID"></param>
/// <param name="folderID"></param>
/// <param name="ownerID"></param>
/// <param name="fetchFolders"></param>
/// <param name="fetchItems"></param>
/// <param name="sortOrder"></param>
/// <param name="version"></param>
/// <returns>An empty InventoryCollection if the inventory look up failed</returns>
private InventoryCollection Fetch(
UUID agentID, UUID folderID, UUID ownerID,
bool fetchFolders, bool fetchItems, int sortOrder, out int version)
{
// m_log.DebugFormat(
// "[WEB FETCH INV DESC HANDLER]: Fetching folders ({0}), items ({1}) from {2} for agent {3}",
// fetchFolders, fetchItems, folderID, agentID);
// FIXME MAYBE: We're not handling sortOrder!
version = 0;
InventoryFolderImpl fold;
if (m_LibraryService != null && m_LibraryService.LibraryRootFolder != null && agentID == m_LibraryService.LibraryRootFolder.Owner)
{
if ((fold = m_LibraryService.LibraryRootFolder.FindFolder(folderID)) != null)
{
InventoryCollection ret = new InventoryCollection();
ret.Folders = new List <InventoryFolderBase>();
ret.Items = fold.RequestListOfItems();
return(ret);
}
}
InventoryCollection contents = new InventoryCollection();
if (folderID != UUID.Zero)
{
contents = m_InventoryService.GetFolderContent(agentID, folderID);
InventoryFolderBase containingFolder = new InventoryFolderBase();
containingFolder.ID = folderID;
containingFolder.Owner = agentID;
containingFolder = m_InventoryService.GetFolder(containingFolder);
if (containingFolder != null)
{
// m_log.DebugFormat(
// "[WEB FETCH INV DESC HANDLER]: Retrieved folder {0} {1} for agent id {2}",
// containingFolder.Name, containingFolder.ID, agentID);
version = containingFolder.Version;
// if (fetchItems)
// {
// List<InventoryItemBase> linkedItemsToAdd = new List<InventoryItemBase>();
//
// foreach (InventoryItemBase item in contents.Items)
// {
// if (item.AssetType == (int)AssetType.Link)
// {
// InventoryItemBase linkedItem = m_InventoryService.GetItem(new InventoryItemBase(item.AssetID));
//
// // Take care of genuinely broken links where the target doesn't exist
// // HACK: Also, don't follow up links that just point to other links. In theory this is legitimate,
// // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
// // rather than having to keep track of every folder requested in the recursion.
// if (linkedItem != null && linkedItem.AssetType != (int)AssetType.Link)
// linkedItemsToAdd.Insert(0, linkedItem);
// }
// }
//
// foreach (InventoryItemBase linkedItem in linkedItemsToAdd)
// {
// m_log.DebugFormat(
// "[WEB FETCH INV DESC HANDLER]: Inserted linked item {0} for link in folder {1} for agent {2}",
// linkedItem.Name, folderID, agentID);
//
// contents.Items.Add(linkedItem);
// }
//
// // If the folder requested contains links, then we need to send those folders first, otherwise the links
// // will be broken in the viewer.
// HashSet<UUID> linkedItemFolderIdsToSend = new HashSet<UUID>();
// foreach (InventoryItemBase item in contents.Items)
// {
// if (item.AssetType == (int)AssetType.Link)
// {
// InventoryItemBase linkedItem = m_InventoryService.GetItem(new InventoryItemBase(item.AssetID));
//
// // Take care of genuinely broken links where the target doesn't exist
// // HACK: Also, don't follow up links that just point to other links. In theory this is legitimate,
// // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
// // rather than having to keep track of every folder requested in the recursion.
// if (linkedItem != null && linkedItem.AssetType != (int)AssetType.Link)
// {
// // We don't need to send the folder if source and destination of the link are in the same
// // folder.
// if (linkedItem.Folder != containingFolder.ID)
// linkedItemFolderIdsToSend.Add(linkedItem.Folder);
// }
// }
// }
//
// foreach (UUID linkedItemFolderId in linkedItemFolderIdsToSend)
// {
// m_log.DebugFormat(
// "[WEB FETCH INV DESC HANDLER]: Recursively fetching folder {0} linked by item in folder {1} for agent {2}",
// linkedItemFolderId, folderID, agentID);
//
// int dummyVersion;
// InventoryCollection linkedCollection
// = Fetch(
// agentID, linkedItemFolderId, ownerID, fetchFolders, fetchItems, sortOrder, out dummyVersion);
//
// InventoryFolderBase linkedFolder = new InventoryFolderBase(linkedItemFolderId);
// linkedFolder.Owner = agentID;
// linkedFolder = m_InventoryService.GetFolder(linkedFolder);
//
//// contents.Folders.AddRange(linkedCollection.Folders);
//
// contents.Folders.Add(linkedFolder);
// contents.Items.AddRange(linkedCollection.Items);
// }
// }
}
}
else
{
// Lost items don't really need a version
version = 1;
}
return(contents);
}
private InventoryItemBase GiveInventoryItem(UUID senderId, UUID recipient, InventoryItemBase item, InventoryFolderBase parentFolder)
{
InventoryItemBase itemCopy = new InventoryItemBase();
itemCopy.Owner = recipient;
itemCopy.CreatorId = item.CreatorId;
itemCopy.CreatorData = item.CreatorData;
itemCopy.ID = UUID.Random();
itemCopy.AssetID = item.AssetID;
itemCopy.Description = item.Description;
itemCopy.Name = item.Name;
itemCopy.AssetType = item.AssetType;
itemCopy.InvType = item.InvType;
itemCopy.Folder = UUID.Zero;
//Give full permissions for them
itemCopy.NextPermissions = (uint)PermissionMask.All;
itemCopy.GroupPermissions = (uint)PermissionMask.All;
itemCopy.EveryOnePermissions = (uint)PermissionMask.All;
itemCopy.CurrentPermissions = (uint)PermissionMask.All;
if (parentFolder == null)
{
InventoryFolderBase folder = InventoryService.GetFolderForType (recipient, (InventoryType)itemCopy.InvType, (AssetType)itemCopy.AssetType);
if (folder != null)
itemCopy.Folder = folder.ID;
else
{
InventoryFolderBase root = InventoryService.GetRootFolder(recipient);
if (root != null)
itemCopy.Folder = root.ID;
else
return null; // No destination
}
}
else
itemCopy.Folder = parentFolder.ID; //We already have a folder to put it in
itemCopy.GroupID = UUID.Zero;
itemCopy.GroupOwned = false;
itemCopy.Flags = item.Flags;
itemCopy.SalePrice = item.SalePrice;
itemCopy.SaleType = item.SaleType;
InventoryService.AddItem(itemCopy);
return itemCopy;
}
public virtual bool CreateUserInventory(UUID principalID)
{
// This is braindeaad. We can't ever communicate that we fixed
// an existing inventory. Well, just return root folder status,
// but check sanity anyway.
//
bool result = false;
InventoryFolderBase rootFolder = GetRootFolder(principalID);
if (rootFolder == null)
{
rootFolder = ConvertToOpenSim(CreateFolder(principalID, UUID.Zero, (int)AssetType.RootFolder, "My Inventory"));
result = true;
}
XInventoryFolder[] sysFolders = GetSystemFolders(principalID);
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Animation)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Animation, "Animations");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Bodypart)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Bodypart, "Body Parts");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.CallingCard)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.CallingCard, "Calling Cards");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Clothing)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Clothing, "Clothing");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Gesture)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Gesture, "Gestures");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Landmark)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Landmark, "Landmarks");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LostAndFoundFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.LostAndFoundFolder, "Lost And Found");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Notecard)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Notecard, "Notecards");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Object)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Object, "Objects");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.SnapshotFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.SnapshotFolder, "Photo Album");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LSLText)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.LSLText, "Scripts");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Sound)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Sound, "Sounds");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Texture)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Texture, "Textures");
}
if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.TrashFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.TrashFolder, "Trash");
}
return(result);
}
public AvatarAppearance WearFolder(AvatarAppearance avappearance, UUID user, UUID folderOwnerID)
{
InventoryFolderBase Folder2Wear = m_InventoryService.GetFolderByOwnerAndName(folderOwnerID,
m_forceUserToWearFolderName);
if (Folder2Wear != null)
{
List<InventoryItemBase> itemsInFolder = m_InventoryService.GetFolderItems(UUID.Zero, Folder2Wear.ID);
InventoryFolderBase appearanceFolder = m_InventoryService.GetFolderForType(user, InventoryType.Wearable,
AssetType.Clothing);
InventoryFolderBase folderForAppearance = new InventoryFolderBase(UUID.Random(), "GridWear", user, -1,
appearanceFolder.ID, 1);
List<InventoryFolderBase> userFolders = m_InventoryService.GetFolderFolders(user, appearanceFolder.ID);
bool alreadyThere = false;
List<UUID> items2RemoveFromAppearence = new List<UUID>();
List<UUID> toDelete = new List<UUID>();
foreach (InventoryFolderBase folder in userFolders)
{
if (folder.Name == folderForAppearance.Name)
{
List<InventoryItemBase> itemsInCurrentFolder = m_InventoryService.GetFolderItems(UUID.Zero,
folder.ID);
foreach (InventoryItemBase itemBase in itemsInCurrentFolder)
{
items2RemoveFromAppearence.Add(itemBase.AssetID);
items2RemoveFromAppearence.Add(itemBase.ID);
toDelete.Add(itemBase.ID);
}
folderForAppearance = folder;
alreadyThere = true;
m_InventoryService.DeleteItems(user, toDelete);
break;
}
}
if (!alreadyThere)
m_InventoryService.AddFolder(folderForAppearance);
else
{
// we have to remove all the old items if they are currently wearing them
for (int i = 0; i < avappearance.Wearables.Length; i++)
{
AvatarWearable wearable = avappearance.Wearables[i];
for (int ii = 0; ii < wearable.Count; ii++)
{
if (items2RemoveFromAppearence.Contains(wearable[ii].ItemID))
{
avappearance.Wearables[i] = AvatarWearable.DefaultWearables[i];
break;
}
}
}
List<AvatarAttachment> attachments = avappearance.GetAttachments();
foreach (AvatarAttachment attachment in attachments)
{
if ((items2RemoveFromAppearence.Contains(attachment.AssetID)) ||
(items2RemoveFromAppearence.Contains(attachment.ItemID)))
{
avappearance.DetachAttachment(attachment.ItemID);
}
}
}
// ok, now we have a empty folder, lets add the items
foreach (InventoryItemBase itemBase in itemsInFolder)
{
InventoryItemBase newcopy = m_InventoryService.InnerGiveInventoryItem(user, folderOwnerID, itemBase,
folderForAppearance.ID,
true, true);
if (newcopy.InvType == (int) InventoryType.Object)
{
byte[] attobj = m_AssetService.GetData(newcopy.AssetID.ToString());
if (attobj != null)
{
string xmlData = Utils.BytesToString(attobj);
XmlDocument doc = new XmlDocument();
try
{
doc.LoadXml(xmlData);
}
catch
{
continue;
}
if (doc.FirstChild.OuterXml.StartsWith("<groups>") ||
(doc.FirstChild.NextSibling != null &&
doc.FirstChild.NextSibling.OuterXml.StartsWith("<groups>")))
continue;
string xml = "";
if ((doc.FirstChild.NodeType == XmlNodeType.XmlDeclaration) &&
(doc.FirstChild.NextSibling != null))
xml = doc.FirstChild.NextSibling.OuterXml;
else
xml = doc.FirstChild.OuterXml;
doc.LoadXml(xml);
if (doc.DocumentElement == null) continue;
XmlNodeList xmlNodeList = doc.DocumentElement.SelectNodes("//State");
int attchspot;
if ((xmlNodeList != null) && (int.TryParse(xmlNodeList[0].InnerText, out attchspot)))
{
AvatarAttachment a = new AvatarAttachment(attchspot, newcopy.ID, newcopy.AssetID);
Dictionary<int, List<AvatarAttachment>> ac = avappearance.Attachments;
if (!ac.ContainsKey(attchspot))
ac[attchspot] = new List<AvatarAttachment>();
ac[attchspot].Add(a);
avappearance.Attachments = ac;
}
}
}
m_InventoryService.AddItem(newcopy);
}
}
return avappearance;
}
public virtual bool CreateUserInventory(UUID principalID)
{
// This is braindeaad. We can't ever communicate that we fixed
// an existing inventory. Well, just return root folder status,
// but check sanity anyway.
//
bool result = false;
InventoryFolderBase rootFolder = GetRootFolder(principalID);
if (rootFolder == null)
{
rootFolder = CreateFolder(principalID, UUID.Zero, (int)AssetType.RootFolder, "My Inventory");
result = true;
}
InventoryFolderBase[] sysFolders = GetSystemFolders(principalID);
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Animation)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Animation, "Animations");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Bodypart)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Bodypart, "Body Parts");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.CallingCard)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.CallingCard, "Calling Cards");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Clothing)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Clothing, "Clothing");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Gesture)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Gesture, "Gestures");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Landmark)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Landmark, "Landmarks");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.LostAndFoundFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.LostAndFoundFolder, "Lost And Found");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Notecard)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Notecard, "Notecards");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Object)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Object, "Objects");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.SnapshotFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.SnapshotFolder, "Photo Album");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.LSLText)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.LSLText, "Scripts");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Sound)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Sound, "Sounds");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.Texture)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.Texture, "Textures");
}
if (!Array.Exists(sysFolders, delegate(InventoryFolderBase f) { if (f.Type == (short)AssetType.TrashFolder)
{
return(true);
}
return(false); }))
{
CreateFolder(principalID, rootFolder.ID, (int)AssetType.TrashFolder, "Trash");
}
if (m_LibraryService != null)
{
InventoryFolderBase bodypartFolder = GetFolderForType(principalID, AssetType.Bodypart);
InventoryFolderBase clothingFolder = GetFolderForType(principalID, AssetType.Clothing);
// Default items
InventoryItemBase defaultShape = new InventoryItemBase();
defaultShape.Name = "Default shape";
defaultShape.Description = "Default shape description";
defaultShape.AssetType = (int)AssetType.Bodypart;
defaultShape.InvType = (int)InventoryType.Wearable;
defaultShape.Flags = (uint)WearableType.Shape;
defaultShape.ID = AvatarWearable.DEFAULT_BODY_ITEM;
//Give a new copy to every person
AssetBase asset = m_AssetService.Get(AvatarWearable.DEFAULT_BODY_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultShape.AssetID = asset.FullID;
defaultShape.Folder = bodypartFolder.ID;
defaultShape.CreatorId = UUID.Zero.ToString();
AddItem(defaultShape);
}
InventoryItemBase defaultSkin = new InventoryItemBase();
defaultSkin.Name = "Default skin";
defaultSkin.Description = "Default skin description";
defaultSkin.AssetType = (int)AssetType.Bodypart;
defaultSkin.InvType = (int)InventoryType.Wearable;
defaultSkin.Flags = (uint)WearableType.Skin;
defaultSkin.ID = AvatarWearable.DEFAULT_SKIN_ITEM;
//Give a new copy to every person
asset = m_AssetService.Get(AvatarWearable.DEFAULT_SKIN_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultSkin.AssetID = asset.FullID;
defaultSkin.Folder = bodypartFolder.ID;
defaultSkin.CreatorId = m_LibraryService.LibraryOwner.ToString();
defaultSkin.Owner = principalID;
defaultSkin.BasePermissions = (uint)PermissionMask.All;
defaultSkin.CurrentPermissions = (uint)PermissionMask.All;
defaultSkin.EveryOnePermissions = (uint)PermissionMask.None;
defaultSkin.NextPermissions = (uint)PermissionMask.All;
AddItem(defaultSkin);
}
InventoryItemBase defaultHair = new InventoryItemBase();
defaultHair.Name = "Default hair";
defaultHair.Description = "Default hair description";
defaultHair.AssetType = (int)AssetType.Bodypart;
defaultHair.InvType = (int)InventoryType.Wearable;
defaultHair.Flags = (uint)WearableType.Hair;
defaultHair.ID = AvatarWearable.DEFAULT_HAIR_ITEM;
//Give a new copy to every person
asset = m_AssetService.Get(AvatarWearable.DEFAULT_HAIR_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultHair.AssetID = asset.FullID;
defaultHair.Folder = bodypartFolder.ID;
defaultHair.CreatorId = m_LibraryService.LibraryOwner.ToString();
defaultHair.Owner = principalID;
defaultHair.BasePermissions = (uint)PermissionMask.All;
defaultHair.CurrentPermissions = (uint)PermissionMask.All;
defaultHair.EveryOnePermissions = (uint)PermissionMask.None;
defaultHair.NextPermissions = (uint)PermissionMask.All;
AddItem(defaultHair);
}
InventoryItemBase defaultEyes = new InventoryItemBase();
defaultEyes.Name = "Default eyes";
defaultEyes.Description = "Default eyes description";
defaultEyes.AssetType = (int)AssetType.Bodypart;
defaultEyes.InvType = (int)InventoryType.Wearable;
defaultEyes.Flags = (uint)WearableType.Eyes;
defaultEyes.ID = AvatarWearable.DEFAULT_EYES_ITEM;
//Give a new copy to every person
asset = m_AssetService.Get(AvatarWearable.DEFAULT_EYES_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultEyes.AssetID = asset.FullID;
defaultEyes.Folder = bodypartFolder.ID;
defaultEyes.CreatorId = m_LibraryService.LibraryOwner.ToString();
defaultEyes.Owner = principalID;
defaultEyes.BasePermissions = (uint)PermissionMask.All;
defaultEyes.CurrentPermissions = (uint)PermissionMask.All;
defaultEyes.EveryOnePermissions = (uint)PermissionMask.None;
defaultEyes.NextPermissions = (uint)PermissionMask.All;
AddItem(defaultEyes);
}
InventoryItemBase defaultShirt = new InventoryItemBase();
defaultShirt.Name = "Default shirt";
defaultShirt.Description = "Default shirt description";
defaultShirt.AssetType = (int)AssetType.Clothing;
defaultShirt.InvType = (int)InventoryType.Wearable;
defaultShirt.Flags = (uint)WearableType.Shirt;
defaultShirt.ID = AvatarWearable.DEFAULT_SHIRT_ITEM;
//Give a new copy to every person
asset = m_AssetService.Get(AvatarWearable.DEFAULT_SHIRT_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultShirt.AssetID = asset.FullID;
defaultShirt.Folder = clothingFolder.ID;
defaultShirt.CreatorId = m_LibraryService.LibraryOwner.ToString();
defaultShirt.Owner = principalID;
defaultShirt.BasePermissions = (uint)PermissionMask.All;
defaultShirt.CurrentPermissions = (uint)PermissionMask.All;
defaultShirt.EveryOnePermissions = (uint)PermissionMask.None;
defaultShirt.NextPermissions = (uint)PermissionMask.All;
AddItem(defaultShirt);
}
InventoryItemBase defaultPants = new InventoryItemBase();
defaultPants.Name = "Default pants";
defaultPants.Description = "Default pants description";
defaultPants.AssetType = (int)AssetType.Clothing;
defaultPants.InvType = (int)InventoryType.Wearable;
defaultPants.Flags = (uint)WearableType.Pants;
defaultPants.ID = AvatarWearable.DEFAULT_PANTS_ITEM;
//Give a new copy to every person
asset = m_AssetService.Get(AvatarWearable.DEFAULT_PANTS_ASSET.ToString());
if (asset != null)
{
asset.FullID = UUID.Random();
m_AssetService.Store(asset);
defaultPants.AssetID = asset.FullID;
defaultPants.Folder = clothingFolder.ID;
defaultPants.CreatorId = m_LibraryService.LibraryOwner.ToString();
defaultPants.Owner = principalID;
defaultPants.BasePermissions = (uint)PermissionMask.All;
defaultPants.CurrentPermissions = (uint)PermissionMask.All;
defaultPants.EveryOnePermissions = (uint)PermissionMask.None;
defaultPants.NextPermissions = (uint)PermissionMask.All;
AddItem(defaultPants);
}
}
return(result);
}
public bool StoreFolder (InventoryFolderBase folder)
{
GD.Delete(m_foldersrealm, new string[1] { "folderID" }, new object[1] { folder.ID });
return GD.Insert(m_foldersrealm, new string[6]{"folderName","type","version","folderID","agentID","parentFolderID"},
new object[6]{folder.Name, folder.Type, folder.Version, folder.ID, folder.Owner, folder.ParentID});
}
/// <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)
{
return(m_InventoryService.AddFolder(folder));
}
/// <summary>
/// Create a folder in this agent's inventory.
/// </summary>
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
///
/// <param name="parentID"></param>
/// <returns></returns>
public bool CreateFolder(string folderName, UUID folderID, ushort folderType, UUID parentID)
{
// m_log.DebugFormat(
// "[AGENT INVENTORY]: Creating inventory folder {0} {1} for {2} {3}", folderID, folderName, remoteClient.Name, remoteClient.AgentId);
if (m_hasReceivedInventory)
{
InventoryFolderImpl parentFolder = RootFolder.FindFolder(parentID);
if (null == parentFolder)
{
m_log.WarnFormat(
"[AGENT INVENTORY]: Tried to create folder {0} {1} but the parent {2} does not exist",
folderName, folderID, parentID);
return false;
}
InventoryFolderImpl createdFolder = parentFolder.CreateChildFolder(folderID, folderName, folderType);
if (createdFolder != null)
{
InventoryFolderBase createdBaseFolder = new InventoryFolderBase();
createdBaseFolder.Owner = createdFolder.Owner;
createdBaseFolder.ID = createdFolder.ID;
createdBaseFolder.Name = createdFolder.Name;
createdBaseFolder.ParentID = createdFolder.ParentID;
createdBaseFolder.Type = createdFolder.Type;
createdBaseFolder.Version = createdFolder.Version;
m_InventoryService.AddFolder(createdBaseFolder);
return true;
}
else
{
m_log.WarnFormat(
"[AGENT INVENTORY]: Tried to create folder {0} {1} but the folder already exists",
folderName, folderID);
return false;
}
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(CreateFolderDelegate), this, "CreateFolder"),
new object[] { folderName, folderID, folderType, parentID }));
return true;
}
}
/// <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(m_InventoryService.UpdateFolder(folder));
}
/// <summary>
/// Handle an inventory folder move request from the client.
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
/// </summary>
///
/// <param name="folderID"></param>
/// <param name="parentID"></param>
/// <returns>
/// true if the delete was successful, or if it was queued pending folder receipt
/// false if the folder to be deleted did not exist.
/// </returns>
public bool MoveFolder(UUID folderID, UUID parentID)
{
// m_log.DebugFormat(
// "[AGENT INVENTORY]: Moving inventory folder {0} into folder {1} for {2} {3}",
// parentID, remoteClient.Name, remoteClient.Name, remoteClient.AgentId);
if (m_hasReceivedInventory)
{
InventoryFolderBase baseFolder = new InventoryFolderBase();
baseFolder.Owner = m_userProfile.ID;
baseFolder.ID = folderID;
baseFolder.ParentID = parentID;
m_InventoryService.MoveFolder(baseFolder);
InventoryFolderImpl folder = RootFolder.FindFolder(folderID);
InventoryFolderImpl parentFolder = RootFolder.FindFolder(parentID);
if (parentFolder != null && folder != null)
{
InventoryFolderImpl oldParentFolder = RootFolder.FindFolder(folder.ParentID);
if (oldParentFolder != null)
{
oldParentFolder.RemoveChildFolder(folderID);
parentFolder.AddChildFolder(folder);
}
else
{
return false;
}
}
else
{
return false;
}
return true;
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(MoveFolderDelegate), this, "MoveFolder"),
new object[] { folderID, parentID }));
return true;
}
}
/// <summary>
/// Move an inventory folder to a new location
/// </summary>
/// <param name="folder">A folder containing the details of the new location</param>
/// <returns>true if the folder was successfully moved</returns>
public bool MoveFolder(InventoryFolderBase folder)
{
return(m_InventoryService.MoveFolder(folder));
}
public bool QueryFolder(InventoryFolderBase folder)
{
if (m_hasReceivedInventory)
{
InventoryFolderBase invFolder = RootFolder.FindFolder(folder.ID);
if (invFolder != null)
{
// Folder is in local cache, just update client
//
return true;
}
InventoryFolderBase folderInfo = null;
folderInfo = m_InventoryService.GetFolder(folder);
if (folderInfo != null)
{
InventoryFolderImpl createdFolder = RootFolder.CreateChildFolder(folderInfo.ID, folderInfo.Name, (ushort)folderInfo.Type);
createdFolder.Version = folderInfo.Version;
createdFolder.Owner = folderInfo.Owner;
createdFolder.ParentID = folderInfo.ParentID;
return true;
}
return false;
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(QueryFolderDelegate), this, "QueryFolder"),
new object[] { folder.ID }));
return true;
}
}
AvatarAppearance CopyWearablesAndAttachments(UUID destination, UUID source,
AvatarAppearance avatarAppearance,
InventoryFolderBase destinationFolder, UUID agentid,
OSDMap itemsMap,
out List <InventoryItemBase> items)
{
items = new List <InventoryItemBase> ();
if (destinationFolder == null)
{
MainConsole.Instance.Error("[Avatar Archiver]: Cannot locate folder(s) for copying wearables!");
return(avatarAppearance);
}
List <InventoryItemBase> litems = new List <InventoryItemBase> ();
foreach (KeyValuePair <string, OSD> kvp in itemsMap)
{
InventoryItemBase item = new InventoryItemBase();
item.FromOSD((OSDMap)kvp.Value);
MainConsole.Instance.Info("[Avatar Archiver]: Loading item " + item.ID);
litems.Add(item);
}
// Wearables
AvatarWearable [] wearables = avatarAppearance.Wearables;
MainConsole.Instance.InfoFormat("[Avatar Archiver] Adding {0} wearables", wearables.Length);
for (int i = 0; i < wearables.Length; i++)
{
AvatarWearable wearable = wearables [i];
for (int ii = 0; ii < wearable.Count; ii++)
{
if (wearable [ii].ItemID != UUID.Zero)
{
// Get inventory item and copy it
InventoryItemBase item = inventoryService.GetItem(UUID.Zero, wearable [ii].ItemID);
if (item == null)
{
//Attempt to get from the map if it doesn't already exist on the grid
item = litems.First((itm) => itm.ID == wearable [ii].ItemID);
}
if (item != null)
{
InventoryItemBase destinationItem = inventoryService.InnerGiveInventoryItem(destination,
destination,
item,
destinationFolder
.ID,
false, false);
items.Add(destinationItem);
MainConsole.Instance.DebugFormat("[Avatar Archiver]: Added item {0} to folder {1}",
destinationItem.ID, destinationFolder.ID);
// Wear item
AvatarWearable newWearable = new AvatarWearable();
newWearable.Wear(destinationItem.ID, destinationItem.AssetID);
avatarAppearance.SetWearable(i, newWearable);
}
else
{
MainConsole.Instance.WarnFormat("[Avatar Archiver]: Unable to transfer {0} to folder {1}",
wearable [ii].ItemID, destinationFolder.ID);
}
}
}
}
// Attachments
List <AvatarAttachment> attachments = avatarAppearance.GetAttachments();
MainConsole.Instance.InfoFormat("[Avatar Archiver] Adding {0} attachments", attachments.Count);
foreach (AvatarAttachment attachment in attachments)
{
int attachpoint = attachment.AttachPoint;
UUID itemID = attachment.ItemID;
if (itemID != UUID.Zero)
{
// Get inventory item and copy it
InventoryItemBase item = inventoryService.GetItem(UUID.Zero, itemID);
if (item == null)
{
//Attempt to get from the map if it doesn't already exist on the grid
item = litems.First((itm) => itm.ID == itemID);
}
if (item != null)
{
InventoryItemBase destinationItem = inventoryService.InnerGiveInventoryItem(destination,
destination, item,
destinationFolder.ID,
false, false);
items.Add(destinationItem);
MainConsole.Instance.DebugFormat("[Avatar Archiver]: Added item {0} to folder {1}", destinationItem.ID,
destinationFolder.ID);
// Attach item
avatarAppearance.SetAttachment(attachpoint, destinationItem.ID, destinationItem.AssetID);
MainConsole.Instance.DebugFormat("[Avatar Archiver]: Attached {0}", destinationItem.ID);
}
else
{
MainConsole.Instance.WarnFormat("[Avatar Archiver]: Error transferring {0} to folder {1}", itemID,
destinationFolder.ID);
}
}
}
return(avatarAppearance);
}
