/// <summary>
/// Create the calling card inventory item in the user's inventory
/// </summary>
/// <param name="client"></param>
/// <param name="creator"></param>
/// <param name="folder"></param>
/// <param name="name"></param>
public void CreateCallingCard(IClientAPI client, UUID creator, UUID folder, string name)
{
m_log.Debug("[AURORA CALLING CARD MODULE]: Creating calling card for " + client.Name);
InventoryItemBase item = new InventoryItemBase();
item.AssetID = UUID.Zero;
item.AssetType = (int)AssetType.CallingCard;
item.BasePermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify);
item.CreationDate = Util.UnixTimeSinceEpoch();
item.CreatorId = creator.ToString();
item.CurrentPermissions = item.BasePermissions;
item.Description = "";
item.EveryOnePermissions = (uint)PermissionMask.None;
item.Flags = 0;
item.Folder = folder;
item.GroupID = UUID.Zero;
item.GroupOwned = false;
item.ID = UUID.Random();
item.InvType = (int)InventoryType.CallingCard;
item.Name = name;
item.NextPermissions = item.EveryOnePermissions;
item.Owner = client.AgentId;
item.SalePrice = 10;
item.SaleType = (byte)SaleType.Not;
ILLClientInventory inventory = client.Scene.RequestModuleInterface <ILLClientInventory>();
if (inventory != null)
{
inventory.AddInventoryItem(client, item);
}
}
/// <summary>
/// Create the calling card inventory item in the user's inventory
/// </summary>
/// <param name = "client"></param>
/// <param name = "creator"></param>
/// <param name = "folder"></param>
/// <param name = "name"></param>
public void CreateCallingCard(IClientAPI client, UUID creator, UUID folder, string name)
{
MainConsole.Instance.Debug("[AURORA CALLING CARD MODULE]: Creating calling card for " + client.Name);
InventoryItemBase item = new InventoryItemBase
{
AssetID = UUID.Zero,
AssetType = (int)AssetType.CallingCard,
BasePermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify),
CurrentPermissions = (uint)(PermissionMask.Copy | PermissionMask.Modify),
NextPermissions = (uint)PermissionMask.None,
CreationDate = Util.UnixTimeSinceEpoch(),
CreatorId = creator.ToString(),
Description = "",
EveryOnePermissions = (uint)PermissionMask.None,
Flags = 0,
Folder = folder,
GroupID = UUID.Zero,
GroupOwned = false,
ID = UUID.Random(),
InvType = (int)InventoryType.CallingCard,
Name = name,
Owner = client.AgentId,
SalePrice = 10,
SaleType = (byte)SaleType.Not
};
ILLClientInventory inventory = client.Scene.RequestModuleInterface <ILLClientInventory>();
if (inventory != null)
{
inventory.AddInventoryItem(client, item);
}
}
private void DoCreateItem(uint callbackID, IClientAPI remoteClient)
{
m_asset.ID = m_userTransactions.Manager.MyScene.AssetService.Store(m_asset);
IMonitorModule monitorModule = m_userTransactions.Manager.MyScene.RequestModuleInterface <IMonitorModule>();
if (monitorModule != null)
{
INetworkMonitor networkMonitor =
(INetworkMonitor)
monitorModule.GetMonitor(m_userTransactions.Manager.MyScene.RegionInfo.RegionID.ToString(),
MonitorModuleHelper.NetworkMonitor);
networkMonitor.AddPendingUploads(-1);
}
InventoryItemBase item = new InventoryItemBase
{
Owner = remoteClient.AgentId,
CreatorId = remoteClient.AgentId.ToString(),
ID = UUID.Random(),
AssetID = m_asset.ID,
Description = m_description,
Name = m_name,
AssetType = type,
InvType = invType,
Folder = InventFolder,
BasePermissions = 0x7fffffff,
CurrentPermissions = 0x7fffffff,
GroupPermissions = 0,
EveryOnePermissions = 0,
NextPermissions = nextPerm,
Flags = wearableType,
CreationDate = Util.UnixTimeSinceEpoch()
};
ILLClientInventory inventoryModule =
m_userTransactions.Manager.MyScene.RequestModuleInterface <ILLClientInventory>();
if (inventoryModule != null && inventoryModule.AddInventoryItem(item))
{
remoteClient.SendInventoryItemCreateUpdate(item, callbackID);
}
else
{
remoteClient.SendAlertMessage("Unable to create inventory item");
}
}
public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
string assetType, UUID AgentID)
{
sbyte assType = 0;
sbyte inType = 0;
if (inventoryType == "sound")
{
inType = 1;
assType = 1;
}
else if (inventoryType == "animation")
{
inType = 19;
assType = 20;
}
else if (inventoryType == "wearable")
{
inType = 18;
switch (assetType)
{
case "bodypart":
assType = 13;
break;
case "clothing":
assType = 5;
break;
}
}
else if (inventoryType == "mesh")
{
inType = (sbyte)InventoryType.Mesh;
assType = (sbyte)AssetType.Mesh;
}
AssetBase asset;
asset = new AssetBase(assetID, assetName, assType, AgentID.ToString());
asset.Data = data;
if (m_scene.AssetService != null)
{
m_scene.AssetService.Store(asset);
}
InventoryItemBase item = new InventoryItemBase();
item.Owner = AgentID;
item.CreatorId = AgentID.ToString();
item.ID = inventoryItem;
item.AssetID = asset.FullID;
item.Description = assetDescription;
item.Name = assetName;
item.AssetType = assType;
item.InvType = inType;
item.Folder = parentFolder;
item.CurrentPermissions = (uint)PermissionMask.All;
item.BasePermissions = (uint)PermissionMask.All;
item.EveryOnePermissions = 0;
item.NextPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
item.CreationDate = Util.UnixTimeSinceEpoch();
ILLClientInventory inventoryModule = m_scene.RequestModuleInterface <ILLClientInventory>();
if (inventoryModule != null)
{
inventoryModule.AddInventoryItem(item);
}
}
public bool BuyObject(IClientAPI remoteClient, UUID categoryID, uint localID, byte saleType, int salePrice)
{
ISceneChildEntity part = m_scene.GetSceneObjectPart(localID);
if (part == null)
{
return(false);
}
if (part.ParentEntity == null)
{
return(false);
}
ISceneEntity group = part.ParentEntity;
ILLClientInventory inventoryModule = m_scene.RequestModuleInterface <ILLClientInventory>();
switch (saleType)
{
case 1: // Sell as original (in-place sale)
uint effectivePerms = group.GetEffectivePermissions();
if ((effectivePerms & (uint)PermissionMask.Transfer) == 0)
{
if (m_dialogModule != null)
{
m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
}
return(false);
}
group.SetOwnerId(remoteClient.AgentId);
group.SetRootPartOwner(part, remoteClient.AgentId, remoteClient.ActiveGroupId);
if (m_scene.Permissions.PropagatePermissions())
{
foreach (ISceneChildEntity child in group.ChildrenEntities())
{
child.Inventory.ChangeInventoryOwner(remoteClient.AgentId);
child.TriggerScriptChangedEvent(Changed.OWNER);
child.ApplyNextOwnerPermissions();
}
}
part.ObjectSaleType = 0;
part.SalePrice = 10;
group.HasGroupChanged = true;
part.GetProperties(remoteClient);
part.TriggerScriptChangedEvent(Changed.OWNER);
group.ResumeScripts();
part.ScheduleUpdate(PrimUpdateFlags.ForcedFullUpdate);
break;
case 2: // Sell a copy
Vector3 inventoryStoredPosition = new Vector3
(((group.AbsolutePosition.X > m_scene.RegionInfo.RegionSizeX)
? m_scene.RegionInfo.RegionSizeX - 1
: group.AbsolutePosition.X)
,
(group.AbsolutePosition.X > m_scene.RegionInfo.RegionSizeY)
? m_scene.RegionInfo.RegionSizeY - 1
: group.AbsolutePosition.X,
group.AbsolutePosition.Z);
Vector3 originalPosition = group.AbsolutePosition;
group.AbsolutePosition = inventoryStoredPosition;
string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat((SceneObjectGroup)group);
group.AbsolutePosition = originalPosition;
uint perms = group.GetEffectivePermissions();
if ((perms & (uint)PermissionMask.Transfer) == 0)
{
if (m_dialogModule != null)
{
m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
}
return(false);
}
AssetBase asset = new AssetBase(UUID.Random(), part.Name,
AssetType.Object, group.OwnerID)
{
Description = part.Description, Data = Utils.StringToBytes(sceneObjectXml)
};
asset.ID = m_scene.AssetService.Store(asset);
InventoryItemBase item = new InventoryItemBase
{
CreatorId = part.CreatorID.ToString(),
CreatorData = part.CreatorData,
ID = UUID.Random(),
Owner = remoteClient.AgentId,
AssetID = asset.ID,
Description = asset.Description,
Name = asset.Name,
AssetType = asset.Type,
InvType = (int)InventoryType.Object,
Folder = categoryID
};
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 & part.NextOwnerMask;
item.CurrentPermissions = perms & part.NextOwnerMask;
item.NextPermissions = part.NextOwnerMask;
item.EveryOnePermissions = part.EveryoneMask &
part.NextOwnerMask;
item.GroupPermissions = part.GroupMask &
part.NextOwnerMask;
item.CurrentPermissions |= 16; // Slam!
item.CreationDate = Util.UnixTimeSinceEpoch();
if (inventoryModule != null)
{
if (inventoryModule.AddInventoryItem(item))
{
remoteClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
if (m_dialogModule != null)
{
m_dialogModule.SendAlertToUser(remoteClient,
"Cannot buy now. Your inventory is unavailable");
}
return(false);
}
}
break;
case 3: // Sell contents
List <UUID> invList = part.Inventory.GetInventoryList();
#if (!ISWIN)
bool okToSell = true;
foreach (UUID invId in invList)
{
TaskInventoryItem item1 = part.Inventory.GetInventoryItem(invId);
if ((item1.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
{
okToSell = false;
break;
}
}
#else
bool okToSell = invList.Select(invID => part.Inventory.GetInventoryItem(invID)).All(item1 => (item1.CurrentPermissions & (uint)PermissionMask.Transfer) != 0);
#endif
if (!okToSell)
{
if (m_dialogModule != null)
{
m_dialogModule.SendAlertToUser(
remoteClient, "This item's inventory doesn't appear to be for sale");
}
return(false);
}
if (invList.Count > 0)
{
if (inventoryModule != null)
{
inventoryModule.MoveTaskInventoryItemsToUserInventory(remoteClient.AgentId, part.Name, part,
invList);
}
}
break;
}
return(true);
}
/// <summary>
/// Delete a scene object from a scene and place in the given avatar's inventory.
/// Returns the UUID of the newly created asset.
/// </summary>
/// <param name="action"></param>
/// <param name="folderID"></param>
/// <param name="objectGroup"></param>
/// <param name="remoteClient"> </param>
public virtual UUID DeleteToInventory(DeRezAction action, UUID folderID,
List <ISceneEntity> objectGroups, UUID agentId, out UUID itemID)
{
itemID = UUID.Zero;
if (objectGroups.Count == 0)
{
return(UUID.Zero);
}
UUID assetID = UUID.Zero;
Vector3 GroupMiddle = Vector3.Zero;
string AssetXML = "<groups>";
if (objectGroups.Count == 1)
{
m_scene.AuroraEventManager.FireGenericEventHandler("DeleteToInventory", objectGroups[0]);
AssetXML = ((ISceneObject)objectGroups[0]).ToXml2();
}
else
{
foreach (ISceneEntity objectGroup in objectGroups)
{
Vector3 inventoryStoredPosition = new Vector3
(((objectGroup.AbsolutePosition.X > m_scene.RegionInfo.RegionSizeX)
? m_scene.RegionInfo.RegionSizeX - 1
: objectGroup.AbsolutePosition.X)
,
(objectGroup.AbsolutePosition.Y > m_scene.RegionInfo.RegionSizeY)
? m_scene.RegionInfo.RegionSizeY - 1
: objectGroup.AbsolutePosition.Y,
objectGroup.AbsolutePosition.Z);
GroupMiddle += inventoryStoredPosition;
Vector3 originalPosition = objectGroup.AbsolutePosition;
objectGroup.AbsolutePosition = inventoryStoredPosition;
m_scene.AuroraEventManager.FireGenericEventHandler("DeleteToInventory", objectGroup);
AssetXML += ((ISceneObject)objectGroup).ToXml2();
objectGroup.AbsolutePosition = originalPosition;
}
GroupMiddle.X /= objectGroups.Count;
GroupMiddle.Y /= objectGroups.Count;
GroupMiddle.Z /= objectGroups.Count;
AssetXML += "<middle>";
AssetXML += "<mid>" + GroupMiddle.ToRawString() + "</mid>";
AssetXML += "</middle>";
AssetXML += "</groups>";
}
// Get the user info of the item destination
//
IScenePresence SP = m_scene.GetScenePresence(agentId);
UUID userID = UUID.Zero;
if (action == DeRezAction.Take || action == DeRezAction.AcquireToUserInventory ||
action == DeRezAction.SaveToExistingUserInventoryItem)
{
// Take or take copy require a taker
// Saving changes requires a local user
//
if (SP == null || SP.ControllingClient == null)
{
return(UUID.Zero);
}
userID = agentId;
}
else
{
// All returns / deletes go to the object owner
//
userID = objectGroups[0].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(objectGroups[0].RootChild.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.",
objectGroups[0].Name, objectGroups[0].UUID);
return(UUID.Zero);
}
}
else
{
// Folder magic
//
if (action == DeRezAction.Delete)
{
// Deleting someone else's item
//
if (SP == null || SP.ControllingClient == null ||
objectGroups[0].OwnerID != 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
{
if (SP == null || SP.ControllingClient == null ||
objectGroups[0].OwnerID != agentId)
{
folder = m_scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
}
else
{
folder = m_scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
}
}
}
// Override and put into where it came from, if it came
// from anywhere in inventory
//
if (action == DeRezAction.Attachment || action == DeRezAction.Take || action == DeRezAction.AcquireToUserInventory)
{
if (objectGroups[0].RootChild.FromUserInventoryItemID != UUID.Zero)
{
InventoryFolderBase f = new InventoryFolderBase(objectGroups[0].RootChild.FromUserInventoryItemID, userID);
folder = m_scene.InventoryService.GetFolder(f);
}
else
{
folder = m_scene.InventoryService.GetFolderForType(userID, AssetType.Object);
}
}
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 = objectGroups[0].RootChild.CreatorID.ToString();
item.ID = UUID.Random();
item.InvType = (int)InventoryType.Object;
item.Folder = folder.ID;
item.Owner = userID;
}
AssetBase asset = CreateAsset(
objectGroups[0].Name,
objectGroups[0].RootChild.Description,
(sbyte)AssetType.Object,
Utils.StringToBytes(AssetXML),
objectGroups[0].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 (SP != null && SP.ControllingClient != null && (SP.ControllingClient.AgentId != objectGroups[0].OwnerID) && m_scene.Permissions.PropagatePermissions())
{
foreach (SceneObjectGroup group in objectGroups)
{
uint perms = group.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;
}
// Make sure all bits but the ones we want are clear
// on take.
// This will be applied to the current perms, so
// it will do what we want.
group.RootPart.NextOwnerMask &=
((uint)PermissionMask.Copy |
(uint)PermissionMask.Transfer |
(uint)PermissionMask.Modify);
group.RootPart.NextOwnerMask |=
(uint)PermissionMask.Move;
item.BasePermissions = perms & group.RootPart.NextOwnerMask;
item.CurrentPermissions = item.BasePermissions;
item.NextPermissions = group.RootPart.NextOwnerMask;
item.EveryOnePermissions = group.RootPart.EveryoneMask & group.RootPart.NextOwnerMask;
item.GroupPermissions = group.RootPart.GroupMask & group.RootPart.NextOwnerMask;
// Magic number badness. Maybe this deserves an enum.
// bit 4 (16) is the "Slam" bit, it means treat as passed
// and apply next owner perms on rez
item.CurrentPermissions |= 16; // Slam!
}
}
else
{
foreach (SceneObjectGroup group in objectGroups)
{
item.BasePermissions = group.GetEffectivePermissions();
item.CurrentPermissions = group.GetEffectivePermissions();
item.NextPermissions = group.RootPart.NextOwnerMask;
item.EveryOnePermissions = group.RootPart.EveryoneMask;
item.GroupPermissions = group.RootPart.GroupMask;
item.CurrentPermissions &=
((uint)PermissionMask.Copy |
(uint)PermissionMask.Transfer |
(uint)PermissionMask.Modify |
(uint)PermissionMask.Move |
7); // Preserve folded permissions
}
}
// TODO: add the new fields (Flags, Sale info, etc)
if (objectGroups.Count != 1)
{
item.Flags |= (uint)OpenMetaverse.InventoryItemFlags.ObjectHasMultipleItems;
}
item.CreationDate = Util.UnixTimeSinceEpoch();
item.Description = asset.Description;
item.Name = asset.Name;
item.AssetType = asset.Type;
m_LLCLientInventoryModule.AddInventoryItem(item);
if (SP != null && SP.ControllingClient != null && item.Owner == SP.ControllingClient.AgentId)
{
SP.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
IScenePresence notifyUser = m_scene.GetScenePresence(item.Owner);
if (notifyUser != null)
{
notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
}
}
if (item != null)
{
itemID = item.ID;
}
return(assetID);
}
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
//MainConsole.Instance.InfoFormat("[INVENTORY TRANSFER]: OnInstantMessage {0}", im.dialog);
IScene scene = FindClientScene(client.AgentId);
if (scene == null) // Something seriously wrong here.
{
return;
}
if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
{
//MainConsole.Instance.DebugFormat("Asset type {0}", ((AssetType)im.binaryBucket[0]));
if (im.binaryBucket.Length < 17) // Invalid
{
return;
}
UUID receipientID = im.toAgentID;
IScenePresence user = scene.GetScenePresence(receipientID);
UUID copyID;
// 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)
{
// First byte is the asset type
AssetType assetType = (AssetType)im.binaryBucket[0];
if (AssetType.Folder == assetType)
{
UUID folderID = new UUID(im.binaryBucket, 1);
MainConsole.Instance.DebugFormat("[INVENTORY TRANSFER]: Inserting original folder {0} " +
"into agent {1}'s inventory",
folderID, im.toAgentID);
InventoryFolderBase folderCopy = null;
ILLClientInventory inventoryModule = scene.RequestModuleInterface <ILLClientInventory>();
if (inventoryModule != null)
{
folderCopy = inventoryModule.GiveInventoryFolder(receipientID, 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);
}
im.imSessionID = folderID;
}
else
{
// First byte of the array is probably the item type
// Next 16 bytes are the UUID
UUID itemID = new UUID(im.binaryBucket, 1);
MainConsole.Instance.DebugFormat("[INVENTORY TRANSFER]: (giving) Inserting item {0} " +
"into agent {1}'s inventory",
itemID, im.toAgentID);
InventoryItemBase itemCopy = null;
ILLClientInventory inventoryModule = scene.RequestModuleInterface <ILLClientInventory>();
if (inventoryModule != null)
{
itemCopy = inventoryModule.GiveInventoryItem(
im.toAgentID,
im.fromAgentID, itemID, UUID.Zero);
}
if (itemCopy == null)
{
client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
return;
}
copyID = itemCopy.ID;
Array.Copy(copyID.GetBytes(), 0, im.binaryBucket, 1, 16);
if (user != null)
{
user.ControllingClient.SendBulkUpdateInventory(itemCopy);
}
im.imSessionID = itemID;
}
user.ControllingClient.SendInstantMessage(im);
return;
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
}
}
else if (im.dialog == (byte)InstantMessageDialog.InventoryAccepted)
{
IScenePresence user = scene.GetScenePresence(im.toAgentID);
if (user != null) // Local
{
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
}
}
else if (im.dialog == (byte)InstantMessageDialog.InventoryDeclined)
{
// 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, InventoryType.Unknown, AssetType.TrashFolder);
UUID inventoryID = im.imSessionID; // The inventory item/folder, back from it's trip
InventoryItemBase item = new InventoryItemBase(inventoryID, client.AgentId);
item = invService.GetItem(item);
InventoryFolderBase folder = null;
if (item != null && trashFolder != null)
{
item.Folder = trashFolder.ID;
// Diva comment: can't we just update this item???
List <UUID> uuids = new List <UUID> {
item.ID
};
invService.DeleteItems(item.Owner, uuids);
ILLClientInventory inventory = client.Scene.RequestModuleInterface <ILLClientInventory>();
if (inventory != null)
{
inventory.AddInventoryItem(client, item);
}
}
else
{
folder = new InventoryFolderBase(inventoryID, client.AgentId);
folder = invService.GetFolder(folder);
if (folder != null & trashFolder != null)
{
folder.ParentID = trashFolder.ID;
invService.MoveFolder(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);
}
IScenePresence user = scene.GetScenePresence(im.toAgentID);
if (user != null) // Local
{
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
}
}
}
