public virtual void ShowDialog(string title, string description, string yes, string no, int minValue, int maxValue, InventoryItemBase item, ItemBuySellDialogAction action, VendorTriggerer vendor, IntValDialogCallback yesCallback, IntValDialogCallback noCallback)
{
// Don't call base class going directly to this.ShowDialog()
inventoryItem = item;
this.action = action;
this.vendor = vendor;
ShowDialog(string.Format(string.Format(title, item.name, item.description)), string.Format(description, item.name, item.description), yes, no, minValue, maxValue, yesCallback, noCallback);
}
public void CharacterOnUnEquippedItem(InventoryItemBase item, uint itemID, uint slot, uint amount)
{
if (onUnEquippedItemEvents.Count > 0)
{
RunEvents(onUnEquippedItemEvents,
new plyEventArg("item", item),
new plyEventArg("itemID", (int)itemID),
new plyEventArg("slot", (int)slot),
new plyEventArg("amount", (int)amount));
}
}
public void OnBoughtItemBackFromVendor(InventoryItemBase item, uint amount, VendorTriggerer vendor)
{
if (onBoughtItemBackFromVendor.Count > 0)
{
RunEvents(onBoughtItemBackFromVendor,
new plyEventArg("item", item),
new plyEventArg("itemID", (int)item.ID),
new plyEventArg("amount", (int)amount),
new plyEventArg("vendor", vendor));
}
}
public void OnCraftSuccess(InventoryCraftingCategory category, InventoryCraftingBlueprint blueprint, InventoryItemBase result)
{
if (onCraftingSuccess.Count > 0)
{
RunEvents(onCraftingSuccess,
new plyEventArg("item", result),
new plyEventArg("itemID", (int)result.ID),
new plyEventArg("category", category),
new plyEventArg("categoryID", (int)category.ID),
new plyEventArg("blueprint", blueprint),
new plyEventArg("blueprintID", (int)blueprint.ID));
}
}
public InventoryItemBase GetInventoryItem(InventoryItemBase item)
{
System.Console.WriteLine("[HGrid] GetInventory " + item.ID + " from " + ServerURL);
try
{
item = SynchronousRestSessionObjectPoster<Guid, InventoryItemBase>.BeginPostObject("POST", ServerURL + "/GetItem/", item.ID.Guid, "", "");
return item;
}
catch (Exception e)
{
System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
return null;
}
public void GetInventoryItemAsync(InventoryItemBase item, ReturnResponse<InventoryItemBase> callBack)
{
System.Console.WriteLine("[HGrid] GetInventory from " + ServerURL);
try
{
RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase> requester
= new RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(ServerURL + "/GetItem/", item, string.Empty, string.Empty);
}
catch (Exception e)
{
System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
/// <summary>
/// Deserialize item
/// </summary>
/// <param name = "serializedSettings"></param>
/// <returns></returns>
/// <exception cref = "System.Xml.XmlException"></exception>
public static InventoryItemBase Deserialize(byte[] serialization)
{
InventoryItemBase item = new InventoryItemBase();
StringReader reader = new StringReader(Encoding.ASCII.GetString(serialization, 0, serialization.Length));
XmlReader xtr = XmlReader.Create(reader);
//Uses byte[] directly... should be used once issues with it are fixed
//MemoryStream mr = new MemoryStream (serialization);
//StreamReader sr = new StreamReader (mr, Encoding.ASCII);
//XmlReader xtr = XmlTextReader.Create (sr);
xtr.ReadStartElement("InventoryItem");
item.Name = xtr.ReadElementString("Name");
item.ID = UUID.Parse(xtr.ReadElementString("ID"));
item.InvType = Convert.ToInt32(xtr.ReadElementString("InvType"));
item.CreatorId = xtr.ReadElementString("CreatorUUID");
try
{
item.CreatorData = xtr.ReadElementString("CreatorData");
}
catch
{
}
item.CreationDate = Convert.ToInt32(xtr.ReadElementString("CreationDate"));
item.Owner = UUID.Parse(xtr.ReadElementString("Owner"));
item.Description = xtr.ReadElementString("Description");
item.AssetType = Convert.ToInt32(xtr.ReadElementString("AssetType"));
item.AssetID = UUID.Parse(xtr.ReadElementString("AssetID"));
item.SaleType = Convert.ToByte(xtr.ReadElementString("SaleType"));
item.SalePrice = Convert.ToInt32(xtr.ReadElementString("SalePrice"));
item.BasePermissions = Convert.ToUInt32(xtr.ReadElementString("BasePermissions"));
item.CurrentPermissions = Convert.ToUInt32(xtr.ReadElementString("CurrentPermissions"));
item.EveryOnePermissions = Convert.ToUInt32(xtr.ReadElementString("EveryOnePermissions"));
item.NextPermissions = Convert.ToUInt32(xtr.ReadElementString("NextPermissions"));
item.Flags = Convert.ToUInt32(xtr.ReadElementString("Flags"));
item.GroupID = UUID.Parse(xtr.ReadElementString("GroupID"));
item.GroupOwned = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));
xtr.ReadEndElement();
xtr.Close();
return item;
}
public InventoryItemBase CreateItem(UUID inventoryID, UUID assetID, string name, string description,
int assetType, int invType, UUID parentFolderID)
{
InventoryItemBase item = new InventoryItemBase();
item.Owner = libOwner;
item.CreatorId = libOwner.ToString();
item.ID = inventoryID;
item.AssetID = assetID;
item.Description = description;
item.Name = name;
item.AssetType = assetType;
item.InvType = invType;
item.Folder = parentFolderID;
item.BasePermissions = 0x7FFFFFFF;
item.EveryOnePermissions = 0x7FFFFFFF;
item.CurrentPermissions = 0x7FFFFFFF;
item.NextPermissions = 0x7FFFFFFF;
return item;
}
public override OSDArray GetLLSDItems(string[] fields, string[] vals)
{
string query = "";
for (int i = 0; i < fields.Length; i++)
{
query += String.Format("where {0} = '{1}' and ", fields[i], vals[i]);
i++;
}
query = query.Remove(query.Length - 5);
if (fields[0] == "inventoryID")
{
IInventoryService invService = m_registry.RequestModuleInterface<IInventoryService>();
if (invService != null)
{
InventoryItemBase baseItem = new InventoryItemBase(UUID.Parse(vals[0]));
return BuildLLSDInventoryItems(invService.GetItem(baseItem));
}
}
return null;
}
private void SetLootableItemsClients(string itemIDsString, PhotonMessageInfo info)
{
if (itemIDsString == "")
{
lootable.items = new InventoryItemBase[0];
return;
}
string[] itemIDs = itemIDsString.Split(',');
UnityEngine.Debug.Log("Received message from server to set items for lootable: " + itemIDs.Length);
var items = new InventoryItemBase[itemIDs.Length];
for (int i = 0; i < itemIDs.Length; i++)
{
var item = UnityEngine.Object.Instantiate<InventoryItemBase>(ItemManager.instance.items[int.Parse(itemIDs[i])]);
item.gameObject.SetActive(false);
item.transform.SetParent(transform);
items[i] = item;
}
lootable.items = items; // Set the lootable items for this object.
}
public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
string assetType, UUID AgentID)
{
// m_log.DebugFormat(
// "[NEW FILE AGENT INVENTORY VARIABLE PRICE MODULE]: Upload complete for {0}", inventoryItem);
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.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
item.BasePermissions = (uint)PermissionMask.All;
item.EveryOnePermissions = 0;
item.NextPermissions = (uint)PermissionMask.All;
item.CreationDate = Util.UnixTimeSinceEpoch();
m_scene.AddInventoryItem(item);
}
public virtual SceneObjectGroup RezObject(
IClientAPI remoteClient, InventoryItemBase item, UUID assetID, Vector3 RayEnd, Vector3 RayStart,
UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
{
AssetBase rezAsset = m_Scene.AssetService.Get(assetID.ToString());
if (rezAsset == null)
{
if (item != null)
{
m_log.WarnFormat(
"[InventoryAccessModule]: Could not find asset {0} for item {1} {2} for {3} in RezObject()",
assetID, item.Name, item.ID, remoteClient.Name);
remoteClient.SendAgentAlertMessage(string.Format("Unable to rez: could not find asset {0} for item {1}.", assetID, item.Name), false);
}
else
{
m_log.WarnFormat(
"[INVENTORY ACCESS MODULE]: Could not find asset {0} for {1} in RezObject()",
assetID, remoteClient.Name);
remoteClient.SendAgentAlertMessage(string.Format("Unable to rez: could not find asset {0}.", assetID), false);
}
return(null);
}
SceneObjectGroup group = null;
List <SceneObjectGroup> objlist;
List <Vector3> veclist;
Vector3 bbox;
float offsetHeight;
byte bRayEndIsIntersection = (byte)(RayEndIsIntersection ? 1 : 0);
Vector3 pos;
bool single = m_Scene.GetObjectsToRez(rezAsset.Data, attachment, out objlist, out veclist, out bbox, out offsetHeight);
if (single)
{
pos = m_Scene.GetNewRezLocation(
RayStart, RayEnd, RayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true, bbox, false);
pos.Z += offsetHeight;
}
else
{
pos = m_Scene.GetNewRezLocation(RayStart, RayEnd,
RayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true,
bbox, false);
pos -= bbox / 2;
}
if (item != null && !DoPreRezWhenFromItem(remoteClient, item, objlist, pos, veclist, attachment))
{
return(null);
}
for (int i = 0; i < objlist.Count; i++)
{
group = objlist[i];
// m_log.DebugFormat(
// "[INVENTORY ACCESS MODULE]: Preparing to rez {0} {1} {2} ownermask={3:X} nextownermask={4:X} groupmask={5:X} everyonemask={6:X} for {7}",
// group.Name, group.LocalId, group.UUID,
// group.RootPart.OwnerMask, group.RootPart.NextOwnerMask, group.RootPart.GroupMask, group.RootPart.EveryoneMask,
// remoteClient.Name);
// Vector3 storedPosition = group.AbsolutePosition;
if (group.UUID == UUID.Zero)
{
m_log.Debug("[INVENTORY ACCESS MODULE]: Object has UUID.Zero! Position 3");
}
// if this was previously an attachment and is now being rezzed,
// save the old attachment info.
if (group.IsAttachment == false && group.RootPart.Shape.State != 0)
{
group.RootPart.AttachedPos = group.AbsolutePosition;
group.RootPart.Shape.LastAttachPoint = (byte)group.AttachmentPoint;
}
if (item == null)
{
// Change ownership. Normally this is done in DoPreRezWhenFromItem(), but in this case we must do it here.
foreach (SceneObjectPart part in group.Parts)
{
// Make the rezzer the owner, as this is not necessarily set correctly in the serialized asset.
part.LastOwnerID = part.OwnerID;
part.OwnerID = remoteClient.AgentId;
}
}
if (!attachment)
{
// If it's rezzed in world, select it. Much easier to
// find small items.
//
foreach (SceneObjectPart part in group.Parts)
{
part.CreateSelected = true;
}
}
group.ResetIDs();
if (attachment)
{
group.RootPart.Flags |= PrimFlags.Phantom;
group.IsAttachment = true;
}
// If we're rezzing an attachment then don't ask
// AddNewSceneObject() to update the client since
// we'll be doing that later on. Scheduling more than
// one full update during the attachment
// process causes some clients to fail to display the
// attachment properly.
m_Scene.AddNewSceneObject(group, true, false);
// if attachment we set it's asset id so object updates
// can reflect that, if not, we set it's position in world.
if (!attachment)
{
group.ScheduleGroupForFullUpdate();
group.AbsolutePosition = pos + veclist[i];
}
group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
if (!attachment)
{
SceneObjectPart rootPart = group.RootPart;
if (rootPart.Shape.PCode == (byte)PCode.Prim)
{
group.ClearPartAttachmentData();
}
// Fire on_rez
group.CreateScriptInstances(0, true, m_Scene.DefaultScriptEngine, 1);
rootPart.ParentGroup.ResumeScripts();
rootPart.ScheduleFullUpdate();
}
// m_log.DebugFormat(
// "[INVENTORY ACCESS MODULE]: Rezzed {0} {1} {2} ownermask={3:X} nextownermask={4:X} groupmask={5:X} everyonemask={6:X} for {7}",
// group.Name, group.LocalId, group.UUID,
// group.RootPart.OwnerMask, group.RootPart.NextOwnerMask, group.RootPart.GroupMask, group.RootPart.EveryoneMask,
// remoteClient.Name);
}
if (item != null)
{
DoPostRezWhenFromItem(item, attachment);
}
return(group);
}
public override void Awake()
{
base.Awake();
item = this.Owner.GetComponent <InventoryItemBase>();
}
public bool StoreItem (InventoryItemBase item)
{
GD.Delete(m_itemsrealm, new string[1] { "inventoryID" }, new object[1] { item.ID });
return GD.Insert (m_itemsrealm, new string[20]{"assetID","assetType","inventoryName","inventoryDescription",
"inventoryNextPermissions","inventoryCurrentPermissions","invType","creatorID","inventoryBasePermissions",
"inventoryEveryOnePermissions","salePrice","saleType","creationDate","groupID","groupOwned",
"flags","inventoryID","avatarID","parentFolderID","inventoryGroupPermissions"}, new object[20]{
item.AssetID, item.AssetType, item.Name, item.Description, item.NextPermissions, item.CurrentPermissions,
item.InvType, item.CreatorId, item.BasePermissions, item.EveryOnePermissions, item.SalePrice, item.SaleType,
item.CreationDate, item.GroupID, item.GroupOwned ? "1" : "0", item.Flags, item.ID, item.Owner,
item.Folder, item.GroupPermissions});
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="userID"></param>
/// <param name="itemInfo"></param>
public void UpdateItem(InventoryItemBase item)
{
if (m_hasReceivedInventory)
{
m_InventoryService.UpdateItem(item);
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(UpdateItemDelegate), this, "UpdateItem"),
new object[] { item }));
}
}
public bool BuyObject(IClientAPI remoteClient, UUID categoryID, uint localID, byte saleType, int salePrice)
{
SceneObjectPart part = m_scene.GetSceneObjectPart(localID);
if (part == null)
{
return(false);
}
SceneObjectGroup group = part.ParentGroup;
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 (SceneObjectPart child in group.Parts)
{
child.Inventory.ChangeInventoryOwner(remoteClient.AgentId);
child.TriggerScriptChangedEvent(Changed.OWNER);
child.ApplyNextOwnerPermissions();
}
}
part.ObjectSaleType = 0;
part.SalePrice = 10;
part.ClickAction = Convert.ToByte(0);
group.HasGroupChanged = true;
part.SendPropertiesToClient(remoteClient);
part.TriggerScriptChangedEvent(Changed.OWNER);
group.ResumeScripts();
part.ScheduleFullUpdate();
break;
case 2: // Sell a copy
Vector3 inventoryStoredPosition = new Vector3(
Math.Min(group.AbsolutePosition.X, m_scene.RegionInfo.RegionSizeX - 6),
Math.Min(group.AbsolutePosition.Y, m_scene.RegionInfo.RegionSizeY - 6),
group.AbsolutePosition.Z);
Vector3 originalPosition = group.AbsolutePosition;
group.AbsolutePosition = inventoryStoredPosition;
string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(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 = m_scene.CreateAsset(
group.GetPartName(localID),
group.GetPartDescription(localID),
(sbyte)AssetType.Object,
Utils.StringToBytes(sceneObjectXml),
group.OwnerID);
m_scene.AssetService.Store(asset);
InventoryItemBase item = new InventoryItemBase();
item.CreatorId = part.CreatorID.ToString();
item.CreatorData = part.CreatorData;
item.ID = UUID.Random();
item.Owner = remoteClient.AgentId;
item.AssetID = asset.FullID;
item.Description = asset.Description;
item.Name = asset.Name;
item.AssetType = asset.Type;
item.InvType = (int)InventoryType.Object;
item.Folder = categoryID;
PermissionsUtil.ApplyFoldedPermissions(perms, ref perms);
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.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
item.CreationDate = Util.UnixTimeSinceEpoch();
if (m_scene.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();
bool okToSell = true;
foreach (UUID invID in invList)
{
TaskInventoryItem item1 = part.Inventory.GetInventoryItem(invID);
if ((item1.CurrentPermissions &
(uint)PermissionMask.Transfer) == 0)
{
okToSell = false;
break;
}
}
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)
{
m_scene.MoveTaskInventoryItems(remoteClient.AgentId, part.Name, part, invList);
}
break;
}
return(true);
}
public InventoryItemEventArgs(InventoryItemBase item)
{
Item = item;
}
private IEnumerator DestroyImmediateThis(InventoryItemBase obj)
{
yield return(null);
DestroyImmediate(obj.gameObject, false); // Destroy this object
}
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,
AssetType.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);
}
void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
//MainConsole.Instance.InfoFormat("[Inventory transfer]: OnInstantMessage {0}", im.dialog);
IScene clientScene = FindClientScene(client.AgentId);
if (clientScene == null)
{
// Something seriously wrong here.
MainConsole.Instance.DebugFormat("[Inventory transfer]: Cannot find originating user scene");
return;
}
if (im.Dialog == (byte)InstantMessageDialog.InventoryOffered)
{
//MainConsole.Instance.DebugFormat("Asset type {0}", ((AssetType)im.binaryBucket[0]));
if (im.BinaryBucket.Length < 17) // Invalid
{
MainConsole.Instance.DebugFormat("[Inventory transfer]: Invalid length {0} for asset type {1}",
im.BinaryBucket.Length, ((AssetType)im.BinaryBucket [0]));
return;
}
UUID recipientID = im.ToAgentID;
IScenePresence recipientUser = null;
IScene recipientUserScene = FindClientScene(recipientID);
if (recipientUserScene != null)
{
recipientUser = recipientUserScene.GetScenePresence(recipientID);
}
UUID copyID;
// give the item to the recipient, assuming they will accept it
// First byte is the asset type
AssetType assetType = (AssetType)im.BinaryBucket [0];
if (assetType == AssetType.Folder)
{
var folderID = new UUID(im.BinaryBucket, 1);
if (im.SessionID == folderID)
{
// this must be an offline message being processed. just pass it through
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
return;
}
MainConsole.Instance.DebugFormat(
"[Inventory transfer]: Inserting original folder {0} into agent {1}'s inventory",
folderID, im.ToAgentID);
clientScene.InventoryService.GiveInventoryFolderAsync(
recipientID,
client.AgentId,
folderID,
UUID.Zero,
(folder) => {
if (folder == 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 = folder.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);
im.SessionID = copyID;
if (moneyService != null)
{
moneyService.Transfer(im.ToAgentID, im.FromAgentID, 0,
"Inworld inventory folder transfer", TransactionType.GiveInventory);
}
if (recipientUser != null)
{
// user is on this region... update them
recipientUser.ControllingClient.SendBulkUpdateInventory(folder);
recipientUser.ControllingClient.SendInstantMessage(im);
}
else if (m_TransferModule != null)
{
// user is not in this region or not online... let them know
m_TransferModule.SendInstantMessage(im);
}
});
}
else
{
// Inventory item
// First byte of the array is probably the item type
// Next 16 bytes are the UUID
var itemID = new UUID(im.BinaryBucket, 1);
if (im.SessionID == itemID)
{
// this must be an offline message being processed. just pass it through
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
return;
}
MainConsole.Instance.DebugFormat(
"[Inventory transfer]: (giving) Inserting item {0} into agent {1}'s inventory",
itemID, im.ToAgentID);
clientScene.InventoryService.GiveInventoryItemAsync(
im.ToAgentID,
im.FromAgentID,
itemID,
UUID.Zero,
false,
(itemCopy) => {
if (itemCopy == null)
{
MainConsole.Instance.DebugFormat(
"[Inventory transfer]: (giving) Unable to find item {0} to give to agent {1}'s inventory",
itemID, im.ToAgentID);
client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
return;
}
copyID = itemCopy.ID;
Array.Copy(copyID.GetBytes(), 0, im.BinaryBucket, 1, 16);
im.SessionID = itemCopy.ID;
if (moneyService != null)
{
moneyService.Transfer(im.ToAgentID, im.FromAgentID, 0,
"Inworld inventory item transfer", TransactionType.GiveInventory);
}
if (recipientUser != null)
{
// user is on this region...
recipientUser.ControllingClient.SendBulkUpdateInventory(itemCopy);
recipientUser.ControllingClient.SendInstantMessage(im);
}
else if (m_TransferModule != null)
{
// user is not present on this region or offline... let them know
m_TransferModule.SendInstantMessage(im);
}
});
}
}
else if (im.Dialog == (byte)InstantMessageDialog.InventoryAccepted)
{
IScenePresence user = clientScene.GetScenePresence(im.ToAgentID);
MainConsole.Instance.DebugFormat("[Inventory transfer]: Acceptance message received");
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 = clientScene.InventoryService;
MainConsole.Instance.DebugFormat("[Inventory transfer]: Declined message received");
InventoryFolderBase trashFolder =
invService.GetFolderForType(client.AgentId, InventoryType.Unknown, FolderType.Trash);
UUID inventoryID = im.SessionID; // The inventory item/folder, back from it's trip
InventoryItemBase item = invService.GetItem(client.AgentId, inventoryID);
InventoryFolderBase folder = null;
// cannot delete if we do not have somewhere to put it
if (trashFolder != null)
{
// Deleting an item
if (item != null)
{
item.Folder = trashFolder.ID;
var uuids = new List <UUID> {
item.ID
};
invService.DeleteItems(item.Owner, uuids); // delete the item from the client's inventory
ILLClientInventory inventory = client.Scene.RequestModuleInterface <ILLClientInventory> ();
if (inventory != null)
{
inventory.AddInventoryItemAsync(client, item); // send an inventory update to the client
}
}
else
{
// deleting a folder
folder = new InventoryFolderBase(inventoryID, client.AgentId);
folder = invService.GetFolder(folder);
if (folder != null)
{
folder.ParentID = trashFolder.ID;
invService.MoveFolder(folder);
client.SendBulkUpdateInventory(folder);
}
}
}
if ((item == null && folder == null) | trashFolder == null)
{
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);
}
if (moneyService != null)
{
moneyService.Transfer(im.ToAgentID, im.FromAgentID, 0,
"Inworld inventory transfer declined", TransactionType.GiveInventory);
}
IScenePresence user = clientScene.GetScenePresence(im.ToAgentID);
if (user != null) // Local
{
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (m_TransferModule != null)
{
m_TransferModule.SendInstantMessage(im);
}
}
}
}
private void CreateDefaultAppearanceEntries(UUID principalID)
{
m_log.DebugFormat("[USER ACCOUNT SERVICE]: Creating default appearance items for {0}", principalID);
InventoryFolderBase bodyPartsFolder = m_InventoryService.GetFolderForType(principalID, AssetType.Bodypart);
InventoryItemBase eyes = new InventoryItemBase(UUID.Random(), principalID);
eyes.AssetID = new UUID("4bb6fa4d-1cd2-498a-a84c-95c1a0e745a7");
eyes.Name = "Default Eyes";
eyes.CreatorId = principalID.ToString();
eyes.AssetType = (int)AssetType.Bodypart;
eyes.InvType = (int)InventoryType.Wearable;
eyes.Folder = bodyPartsFolder.ID;
eyes.BasePermissions = (uint)PermissionMask.All;
eyes.CurrentPermissions = (uint)PermissionMask.All;
eyes.EveryOnePermissions = (uint)PermissionMask.All;
eyes.GroupPermissions = (uint)PermissionMask.All;
eyes.NextPermissions = (uint)PermissionMask.All;
eyes.Flags = (uint)WearableType.Eyes;
m_InventoryService.AddItem(eyes);
InventoryItemBase shape = new InventoryItemBase(UUID.Random(), principalID);
shape.AssetID = AvatarWearable.DEFAULT_BODY_ASSET;
shape.Name = "Default Shape";
shape.CreatorId = principalID.ToString();
shape.AssetType = (int)AssetType.Bodypart;
shape.InvType = (int)InventoryType.Wearable;
shape.Folder = bodyPartsFolder.ID;
shape.BasePermissions = (uint)PermissionMask.All;
shape.CurrentPermissions = (uint)PermissionMask.All;
shape.EveryOnePermissions = (uint)PermissionMask.All;
shape.GroupPermissions = (uint)PermissionMask.All;
shape.NextPermissions = (uint)PermissionMask.All;
shape.Flags = (uint)WearableType.Shape;
m_InventoryService.AddItem(shape);
InventoryItemBase skin = new InventoryItemBase(UUID.Random(), principalID);
skin.AssetID = AvatarWearable.DEFAULT_SKIN_ASSET;
skin.Name = "Default Skin";
skin.CreatorId = principalID.ToString();
skin.AssetType = (int)AssetType.Bodypart;
skin.InvType = (int)InventoryType.Wearable;
skin.Folder = bodyPartsFolder.ID;
skin.BasePermissions = (uint)PermissionMask.All;
skin.CurrentPermissions = (uint)PermissionMask.All;
skin.EveryOnePermissions = (uint)PermissionMask.All;
skin.GroupPermissions = (uint)PermissionMask.All;
skin.NextPermissions = (uint)PermissionMask.All;
skin.Flags = (uint)WearableType.Skin;
m_InventoryService.AddItem(skin);
InventoryItemBase hair = new InventoryItemBase(UUID.Random(), principalID);
hair.AssetID = AvatarWearable.DEFAULT_HAIR_ASSET;
hair.Name = "Default Hair";
hair.CreatorId = principalID.ToString();
hair.AssetType = (int)AssetType.Bodypart;
hair.InvType = (int)InventoryType.Wearable;
hair.Folder = bodyPartsFolder.ID;
hair.BasePermissions = (uint)PermissionMask.All;
hair.CurrentPermissions = (uint)PermissionMask.All;
hair.EveryOnePermissions = (uint)PermissionMask.All;
hair.GroupPermissions = (uint)PermissionMask.All;
hair.NextPermissions = (uint)PermissionMask.All;
hair.Flags = (uint)WearableType.Hair;
m_InventoryService.AddItem(hair);
InventoryFolderBase clothingFolder = m_InventoryService.GetFolderForType(principalID, AssetType.Clothing);
InventoryItemBase shirt = new InventoryItemBase(UUID.Random(), principalID);
shirt.AssetID = AvatarWearable.DEFAULT_SHIRT_ASSET;
shirt.Name = "Default Shirt";
shirt.CreatorId = principalID.ToString();
shirt.AssetType = (int)AssetType.Clothing;
shirt.InvType = (int)InventoryType.Wearable;
shirt.Folder = clothingFolder.ID;
shirt.BasePermissions = (uint)PermissionMask.All;
shirt.CurrentPermissions = (uint)PermissionMask.All;
shirt.EveryOnePermissions = (uint)PermissionMask.All;
shirt.GroupPermissions = (uint)PermissionMask.All;
shirt.NextPermissions = (uint)PermissionMask.All;
shirt.Flags = (uint)WearableType.Shirt;
m_InventoryService.AddItem(shirt);
InventoryItemBase pants = new InventoryItemBase(UUID.Random(), principalID);
pants.AssetID = AvatarWearable.DEFAULT_PANTS_ASSET;
pants.Name = "Default Pants";
pants.CreatorId = principalID.ToString();
pants.AssetType = (int)AssetType.Clothing;
pants.InvType = (int)InventoryType.Wearable;
pants.Folder = clothingFolder.ID;
pants.BasePermissions = (uint)PermissionMask.All;
pants.CurrentPermissions = (uint)PermissionMask.All;
pants.EveryOnePermissions = (uint)PermissionMask.All;
pants.GroupPermissions = (uint)PermissionMask.All;
pants.NextPermissions = (uint)PermissionMask.All;
pants.Flags = (uint)WearableType.Pants;
m_InventoryService.AddItem(pants);
if (m_AvatarService != null)
{
m_log.DebugFormat("[USER ACCOUNT SERVICE]: Creating default avatar entries for {0}", principalID);
AvatarWearable[] wearables = new AvatarWearable[6];
wearables[AvatarWearable.EYES] = new AvatarWearable(eyes.ID, eyes.AssetID);
wearables[AvatarWearable.BODY] = new AvatarWearable(shape.ID, shape.AssetID);
wearables[AvatarWearable.SKIN] = new AvatarWearable(skin.ID, skin.AssetID);
wearables[AvatarWearable.HAIR] = new AvatarWearable(hair.ID, hair.AssetID);
wearables[AvatarWearable.SHIRT] = new AvatarWearable(shirt.ID, shirt.AssetID);
wearables[AvatarWearable.PANTS] = new AvatarWearable(pants.ID, pants.AssetID);
AvatarAppearance ap = new AvatarAppearance();
for (int i = 0; i < 6; i++)
{
ap.SetWearable(i, wearables[i]);
}
m_AvatarService.SetAppearance(principalID, ap);
}
}
public void TestRezCoalescedObject()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
// Create asset
SceneObjectGroup object1 = SceneHelpers.CreateSceneObject(1, m_userId, "Object1", 0x20);
object1.AbsolutePosition = new Vector3(15, 30, 45);
SceneObjectGroup object2 = SceneHelpers.CreateSceneObject(1, m_userId, "Object2", 0x40);
object2.AbsolutePosition = new Vector3(25, 50, 75);
CoalescedSceneObjects coa = new CoalescedSceneObjects(m_userId, object1, object2);
UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060");
AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, coa);
m_scene.AssetService.Store(asset1);
// Create item
UUID item1Id = UUID.Parse("00000000-0000-0000-0000-000000000080");
string item1Name = "My Little Dog";
InventoryItemBase item1 = new InventoryItemBase();
item1.Name = item1Name;
item1.AssetID = asset1.FullID;
item1.ID = item1Id;
InventoryFolderBase objsFolder
= InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, m_userId, "Objects")[0];
item1.Folder = objsFolder.ID;
m_scene.AddInventoryItem(item1);
SceneObjectGroup so
= m_iam.RezObject(
m_tc, item1Id, new Vector3(100, 100, 100), Vector3.Zero, UUID.Zero, 1, false, false, false, UUID.Zero, false);
Assert.That(so, Is.Not.Null);
Assert.That(m_scene.SceneGraph.GetTotalObjectsCount(), Is.EqualTo(2));
SceneObjectPart retrievedObj1Part = m_scene.GetSceneObjectPart(object1.Name);
Assert.That(retrievedObj1Part, Is.Null);
retrievedObj1Part = m_scene.GetSceneObjectPart(item1.Name);
Assert.That(retrievedObj1Part, Is.Not.Null);
Assert.That(retrievedObj1Part.Name, Is.EqualTo(item1.Name));
// Bottom of coalescence is placed on ground, hence we end up with 100.5 rather than 85 since the bottom
// object is unit square.
Assert.That(retrievedObj1Part.AbsolutePosition, Is.EqualTo(new Vector3(95, 90, 100.5f)));
SceneObjectPart retrievedObj2Part = m_scene.GetSceneObjectPart(object2.Name);
Assert.That(retrievedObj2Part, Is.Not.Null);
Assert.That(retrievedObj2Part.Name, Is.EqualTo(object2.Name));
Assert.That(retrievedObj2Part.AbsolutePosition, Is.EqualTo(new Vector3(105, 110, 130.5f)));
}
public void SendInventoryItemCreateUpdate(InventoryItemBase Item, UUID transactionID, uint callbackId)
{
}
private AvatarAppearance CopyWearablesAndAttachments(UUID destination, UUID source, AvatarAppearance avatarAppearance, InventoryFolderBase destinationFolder)
{
if (destinationFolder == null)
{
throw new Exception("Cannot locate folder(s)");
}
// 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 = new InventoryItemBase(wearable[ii].ItemID);
item = InventoryService.GetItem(item);
if (item != null)
{
InventoryItemBase destinationItem = new InventoryItemBase(UUID.Random(), destination)
{
Name = item.Name,
Description = item.Description,
InvType = item.InvType,
CreatorId = item.CreatorId,
CreatorData = item.CreatorData,
CreatorIdAsUuid = item.CreatorIdAsUuid,
NextPermissions = item.NextPermissions,
CurrentPermissions = item.CurrentPermissions,
BasePermissions = item.BasePermissions,
EveryOnePermissions = item.EveryOnePermissions,
GroupPermissions = item.GroupPermissions,
AssetType = item.AssetType,
AssetID = item.AssetID,
GroupID = item.GroupID,
GroupOwned = item.GroupOwned,
SalePrice = item.SalePrice,
SaleType = item.SaleType,
Flags = item.Flags,
CreationDate = item.CreationDate,
Folder = destinationFolder.ID
};
if (InventoryService != null)
{
InventoryService.AddItem(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, wearable[ii].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 = new InventoryItemBase(itemID, source);
item = InventoryService.GetItem(item);
if (item != null)
{
InventoryItemBase destinationItem = new InventoryItemBase(UUID.Random(), destination)
{
Name = item.Name,
Description = item.Description,
InvType = item.InvType,
CreatorId = item.CreatorId,
CreatorData = item.CreatorData,
CreatorIdAsUuid = item.CreatorIdAsUuid,
NextPermissions = item.NextPermissions,
CurrentPermissions = item.CurrentPermissions,
BasePermissions = item.BasePermissions,
EveryOnePermissions = item.EveryOnePermissions,
GroupPermissions = item.GroupPermissions,
AssetType = item.AssetType,
AssetID = item.AssetID,
GroupID = item.GroupID,
GroupOwned = item.GroupOwned,
SalePrice = item.SalePrice,
SaleType = item.SaleType,
Flags = item.Flags,
CreationDate = item.CreationDate,
Folder = destinationFolder.ID
};
if (InventoryService != null)
{
InventoryService.AddItem(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 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 string FetchInventoryRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
//m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capability request {0}", request);
OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
OSDArray itemsRequested = (OSDArray)requestmap["items"];
UUID[] itemIDs = new UUID[itemsRequested.Count];
int i = 0;
foreach (OSDMap osdItemId in itemsRequested)
{
itemIDs[i++] = osdItemId["item_id"].AsUUID();
}
InventoryItemBase[] items = null;
if (m_agentID != UUID.Zero)
{
items = m_inventoryService.GetMultipleItems(m_agentID, itemIDs);
}
else
{
items = new InventoryItemBase[itemsRequested.Count];
foreach (UUID id in itemIDs)
{
items[i++] = m_inventoryService.GetItem(UUID.Zero, id);
}
}
StringBuilder lsl = LLSDxmlEncode.Start(4096);
LLSDxmlEncode.AddMap(lsl);
if (m_agentID == UUID.Zero && items.Length > 0)
{
LLSDxmlEncode.AddElem("agent_id", items[0].Owner, lsl);
}
else
{
LLSDxmlEncode.AddElem("agent_id", m_agentID, lsl);
}
if (items == null || items.Length == 0)
{
LLSDxmlEncode.AddEmptyArray("items", lsl);
}
else
{
LLSDxmlEncode.AddArray("items", lsl);
foreach (InventoryItemBase item in items)
{
if (item != null)
{
item.ToLLSDxml(lsl, 0xff);
}
}
LLSDxmlEncode.AddEndArray(lsl);
}
LLSDxmlEncode.AddEndMap(lsl);
return(LLSDxmlEncode.End(lsl));
}
/// <summary>
/// Callback invoked when an item is received from an async request to the inventory service.
///
/// We're assuming here that items are always received after all the folders
/// received.
/// If folder is null, we will search for it starting from RootFolder (an O(n) operation),
/// otherwise we'll just put it into folder
/// </summary>
/// <param name="folderInfo"></param>
private void ItemReceive(InventoryItemBase itemInfo, InventoryFolderImpl folder)
{
// m_log.DebugFormat(
// "[INVENTORY CACHE]: Received item {0} {1} for user {2}",
// itemInfo.Name, itemInfo.ID, userID);
if (folder == null && RootFolder != null)
folder = RootFolder.FindFolder(itemInfo.Folder);
if (null == folder)
{
m_log.WarnFormat(
"Received item {0} {1} but its folder {2} does not exist",
itemInfo.Name, itemInfo.ID, itemInfo.Folder);
return;
}
lock (folder.Items)
{
folder.Items[itemInfo.ID] = itemInfo;
}
if (OnItemReceived != null)
OnItemReceived(itemInfo.ID);
}
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 receipientID = new UUID(im.toAgentID);
ScenePresence user = scene.GetScenePresence(receipientID);
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(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);
}
// 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));
InventoryItemBase itemCopy = scene.GiveInventoryItem(
new UUID(im.toAgentID),
client.AgentId, itemID);
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);
}
// 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;
}
// 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)
{
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) {
// justincc - FIXME: Comment out for now. This code was added in commit db91044 Mon Aug 22 2011
// and is apparently supposed to fix bulk inventory updates after accepting items. But
// instead it appears to cause two copies of an accepted folder for the receiving user in
// at least some cases. Folder/item update is already done when the offer is made (see code above)
// // Send BulkUpdateInventory
// IInventoryService invService = scene.InventoryService;
// UUID inventoryEntityID = new UUID(im.imSessionID); // The inventory item /folder, back from it's trip
//
// InventoryFolderBase folder = new InventoryFolderBase(inventoryEntityID, client.AgentId);
// folder = invService.GetFolder(folder);
//
// ScenePresence fromUser = scene.GetScenePresence(new UUID(im.fromAgentID));
//
// // If the user has left the scene by the time the message comes back then we can't send
// // them the update.
// if (fromUser != null)
// fromUser.ControllingClient.SendBulkUpdateInventory(folder);
});
}
}
}
// 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);
if (destinationFolder == null)
{
m_log.WarnFormat(
"[INVENTORY TRANSFER]: TaskInventoryAccepted message from {0} in {1} specified folder {2} which does not exist",
client.Name, scene.Name, destinationFolderID);
return;
}
IInventoryService invService = scene.InventoryService;
UUID inventoryID = new UUID(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;
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 = new InventoryFolderBase(inventoryID, client.AgentId);
folder = invService.GetFolder(folder);
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
= new InventoryFolderBase((UUID)previousParentFolderID, client.AgentId);
previousParentFolder = invService.GetFolder(previousParentFolder);
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, AssetType.TrashFolder);
UUID inventoryID = new UUID(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;
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 = new InventoryFolderBase(inventoryID, client.AgentId);
folder = invService.GetFolder(folder);
if (folder != null & trashFolder != null)
{
previousParentFolderID = folder.ParentID;
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);
}
// 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
= new InventoryFolderBase((UUID)previousParentFolderID, client.AgentId);
previousParentFolder = invService.GetFolder(previousParentFolder);
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 OnRemovedItemPly(InventoryItemBase item, uint itemID, uint slot, uint amount)
{
if (eventHandler != null)
eventHandler.CharacterOnUnEquippedItem(item, itemID, slot, amount);
}
/// <summary>
/// Callback invoked when an item is received from an async request to the inventory service.
///
/// We're assuming here that items are always received after all the folders
/// received.
/// If folder is null, we will search for it starting from RootFolder (an O(n) operation),
/// otherwise we'll just put it into folder
/// </summary>
/// <param name="folderInfo"></param>
private void ItemReceive(InventoryItemBase itemInfo, InventoryFolderImpl folder)
{
if (OnItemReceived != null)
OnItemReceived(itemInfo.ID);
}
/// <summary>
/// Update what the avatar is wearing using an item from their inventory.
/// </summary>
/// <param name="client"></param>
/// <param name="e"></param>
public void AvatarIsWearing(IClientAPI client, AvatarWearingArgs e)
{
IScenePresence sp = m_scene.GetScenePresence(client.AgentId);
if (sp == null)
{
MainConsole.Instance.WarnFormat("[Avatar Factory]: AvatarIsWearing unable to find presence for {0}",
client.AgentId);
return;
}
MainConsole.Instance.DebugFormat("[Avatar Factory]: AvatarIsWearing called for {0}", client.AgentId);
// operate on a copy of the appearance so we don't have to lock anything
IAvatarAppearanceModule appearance = sp.RequestModuleInterface <IAvatarAppearanceModule> ();
AvatarAppearance avatAppearance = new AvatarAppearance(appearance.Appearance, false);
#region Teen Mode Stuff
IOpenRegionSettingsModule module = m_scene.RequestModuleInterface <IOpenRegionSettingsModule> ();
bool NeedsRebake = false;
if (module != null && module.EnableTeenMode)
{
foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
{
if (wear.Type == 10 & wear.ItemID == UUID.Zero && module.DefaultUnderpants != UUID.Zero)
{
NeedsRebake = true;
wear.ItemID = module.DefaultUnderpants;
InventoryItemBase item = new InventoryItemBase(UUID.Random())
{
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Underpants",
Folder =
m_scene.InventoryService.GetFolderForType(client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0,
CreatorId = UUID.Zero.ToString(),
AssetID = module.DefaultUnderpants
};
//Locked
client.SendInventoryItemCreateUpdate(item, 0);
}
else if (wear.Type == 10 & wear.ItemID == UUID.Zero)
{
NeedsRebake = true;
InventoryItemBase item = new InventoryItemBase(UUID.Random())
{
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Underpants",
Folder =
m_scene.InventoryService.GetFolderForType(client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0
};
//Locked
if (m_underPantsUUID == UUID.Zero)
{
m_underPantsUUID = UUID.Random();
AssetBase asset = new AssetBase(m_underPantsUUID, "Default Underpants", AssetType.Clothing,
UUID.Zero)
{
Data = Utils.StringToBytes(m_defaultUnderPants)
};
asset.ID = m_scene.AssetService.Store(asset);
m_underPantsUUID = asset.ID;
}
item.CreatorId = UUID.Zero.ToString();
item.AssetID = m_underPantsUUID;
m_scene.InventoryService.AddItemAsync(item, null);
client.SendInventoryItemCreateUpdate(item, 0);
wear.ItemID = item.ID;
}
if (wear.Type == 11 && wear.ItemID == UUID.Zero && module.DefaultUndershirt != UUID.Zero)
{
NeedsRebake = true;
wear.ItemID = module.DefaultUndershirt;
InventoryItemBase item = new InventoryItemBase(UUID.Random())
{
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Undershirt",
Folder =
m_scene.InventoryService.GetFolderForType(client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0,
CreatorId = UUID.Zero.ToString(),
AssetID = module.DefaultUndershirt
};
//Locked
client.SendInventoryItemCreateUpdate(item, 0);
}
else if (wear.Type == 11 & wear.ItemID == UUID.Zero)
{
NeedsRebake = true;
InventoryItemBase item = new InventoryItemBase(UUID.Random())
{
InvType = (int)InventoryType.Wearable,
AssetType = (int)AssetType.Clothing,
Name = "Default Undershirt",
Folder =
m_scene.InventoryService.GetFolderForType(client.AgentId, InventoryType.Wearable, FolderType.Clothing).ID,
Owner = client.AgentId,
CurrentPermissions = 0
};
//Locked
if (m_underShirtUUID == UUID.Zero)
{
m_underShirtUUID = UUID.Random();
AssetBase asset = new AssetBase(m_underShirtUUID, "Default Undershirt", AssetType.Clothing,
UUID.Zero)
{
Data = Utils.StringToBytes(m_defaultUnderShirt)
};
asset.ID = m_scene.AssetService.Store(asset);
m_underShirtUUID = asset.ID;
}
item.CreatorId = UUID.Zero.ToString();
item.AssetID = m_underShirtUUID;
m_scene.InventoryService.AddItemAsync(item, null);
client.SendInventoryItemCreateUpdate(item, 0);
wear.ItemID = item.ID;
}
}
}
#endregion
foreach (
AvatarWearingArgs.Wearable wear in e.NowWearing.Where(wear => wear.Type < AvatarWearable.MAX_WEARABLES))
{
avatAppearance.Wearables [wear.Type].Add(wear.ItemID, UUID.Zero);
}
avatAppearance.GetAssetsFrom(appearance.Appearance);
// This could take awhile since it needs to pull inventory
SetAppearanceAssets(sp.UUID, e.NowWearing, appearance.Appearance, ref avatAppearance);
// could get fancier with the locks here, but in the spirit of "last write wins"
// this should work correctly, also, we don't need to send the appearance here
// since the "iswearing" will trigger a new set of visual param and baked texture changes
// when those complete, the new appearance will be sent
appearance.Appearance = avatAppearance;
//This only occurs if something has been forced on afterwards (teen mode stuff)
if (NeedsRebake)
{
//Tell the client about the new things it is wearing
sp.ControllingClient.SendWearables(appearance.Appearance.Wearables, appearance.Appearance.Serial);
//Then forcefully tell it to rebake
foreach (
Primitive.TextureEntryFace face in
appearance.Appearance.Texture.FaceTextures.Select(t => (t)).Where(face => face != null))
{
sp.ControllingClient.SendRebakeAvatarTextures(face.TextureID);
}
}
QueueAppearanceSave(sp.UUID);
//Send the wearables HERE so that the client knows what it is wearing
//sp.ControllingClient.SendWearables(sp.Appearance.Wearables, sp.Appearance.Serial);
//Do not save or send the appearance! The client loops back and sends a bunch of SetAppearance
// (handled above) and that takes care of it
}
public InventoryItemBase ResolveLink(InventoryItemBase baseItem)
{
// Resolve Links if needed
const int LINK_RECURSION_LIMIT = 32;
int counter = 0;
while ((baseItem != null) && (baseItem.AssetType == (int)AssetType.Link) && (++counter < LINK_RECURSION_LIMIT))
{
baseItem = this.FindItem(baseItem.AssetID);
}
if (baseItem.AssetType == (int)AssetType.Link)
{
//recursion limit was hit
return null;
}
return baseItem;
}
private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
// m_log.DebugFormat(
// "[INVENTORY TRANSFER]: {0} IM type received from {1}",
// (InstantMessageDialog)im.dialog, client.Name);
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 receipientID = new UUID(im.toAgentID);
ScenePresence user = scene.GetScenePresence(receipientID);
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(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);
}
// HACK!!
im.imSessionID = folderID.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));
InventoryItemBase itemCopy = scene.GiveInventoryItem(
new UUID(im.toAgentID),
client.AgentId, itemID);
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);
}
// HACK!!
im.imSessionID = itemID.Guid;
}
// 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)
{
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) {});
}
}
}
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, AssetType.TrashFolder);
UUID inventoryID = new UUID(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>();
uuids.Add(item.ID);
invService.DeleteItems(item.Owner, uuids);
scene.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);
}
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) {});
}
}
}
}
/// <summary>
/// Delete an item from the user's inventory
///
/// If the inventory service has not yet delievered the inventory
/// for this user then the request will be queued.
/// </summary>
/// <param name="itemID"></param>
/// <returns>
/// true on a successful delete or a if the request is queued.
/// Returns false on an immediate failure
/// </returns>
public bool DeleteItem(InventoryItemBase item)
{
IInventoryProviderSelector selector = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
IInventoryStorage provider = selector.GetProvider(item.Owner);
provider.PurgeItem(item);
return true;
}
/// <summary>
/// Get an item, given by its UUID
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InventoryItemBase GetItem(InventoryItemBase item)
{
return(null);
}
public void ModifyAndMoveItem(InventoryItemBase item, UUID folderID)
{
IInventoryProviderSelector selector = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
ICheckedInventoryStorage provider = selector.GetCheckedProvider(m_userProfile.ID);
provider.ModifyAndMoveItem(m_userProfile.ID, item, folderID);
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item)
{
return(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;
}
public virtual void TransferInventoryAssets(InventoryItemBase item, UUID sender, UUID receiver)
{
}
public void SendInventoryItemCreateUpdate(InventoryItemBase Item, uint callbackID)
{
}
/// <summary>
/// Add an item to the user's inventory.
/// </summary>
/// If the item has no folder set (i.e. it is UUID.Zero), then it is placed in the most appropriate folder
/// for that type.
/// <param name="itemInfo"></param>
public void AddItem(InventoryItemBase item)
{
if (item.Folder == UUID.Zero)
{
InventoryFolderBase f = FindFolderForType(item.AssetType);
if (f != null)
{
item.Folder = f.ID;
}
else
{
InventoryFolderBase folder = FindFolderForType((int)AssetType.RootFolder);
item.Folder = folder.ID;
}
}
IInventoryProviderSelector selector = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
selector.GetCheckedProvider(m_userProfile.ID).CreateItem(m_userProfile.ID, item);
ItemReceive(item, null);
}
/// <summary>
/// Capability originating call to update the asset of an item in an agent's inventory
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="itemID"></param>
/// <param name="data"></param>
/// <returns></returns>
public virtual string CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
{
InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
item = m_scene.InventoryService.GetItem(item);
if (item != null)
{
if ((InventoryType)item.InvType == InventoryType.Notecard)
{
if (!m_scene.Permissions.CanEditNotecard(itemID, UUID.Zero, remoteClient.AgentId))
{
remoteClient.SendAlertMessage("Insufficient permissions to edit notecard");
return(FailedPermissionsNotecardCAPSUpdate(UUID.Zero, itemID));
}
AssetBase asset =
CreateAsset(item.Name, item.Description, (sbyte)item.AssetType, data, remoteClient.AgentId.ToString());
item.AssetID = asset.FullID;
m_scene.AssetService.Store(asset);
m_scene.InventoryService.UpdateItem(item);
return(SuccessNotecardCAPSUpdate(item.AssetID, itemID));
}
else if ((InventoryType)item.InvType == InventoryType.LSL)
{
if (!m_scene.Permissions.CanEditScript(itemID, UUID.Zero, remoteClient.AgentId))
{
return(FailedPermissionsScriptCAPSUpdate(UUID.Zero, itemID));
}
IScriptModule ScriptEngine = m_scene.RequestModuleInterface <IScriptModule>();
AssetBase asset =
CreateAsset(item.Name, item.Description, (sbyte)item.AssetType, data, remoteClient.AgentId.ToString());
item.AssetID = asset.FullID;
m_scene.AssetService.Store(asset);
m_scene.InventoryService.UpdateItem(item);
if (ScriptEngine != null)
{
string Errors = ScriptEngine.TestCompileScript(asset.FullID, itemID);
if (Errors != "")
{
return(FailedCompileScriptCAPSUpdate(item.AssetID, itemID, Errors));
}
}
return(SuccessScriptCAPSUpdate(item.AssetID, itemID));
}
return("");
}
else
{
m_log.ErrorFormat(
"[AGENT INVENTORY]: Could not find item {0} for caps inventory update",
itemID);
}
return("");
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="userID"></param>
/// <param name="itemInfo"></param>
public void UpdateItem(InventoryItemBase item)
{
IInventoryProviderSelector selector = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
selector.GetProvider(item.Owner).SaveItem(item);
}
/// <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;
item.AssetID = assetID;
if (DeRezAction.SaveToExistingUserInventoryItem != action)
{
item.Description = asset.Description;
item.Name = asset.Name;
item.AssetType = asset.Type;
}
AssetXML = null;
asset = null;
if (DeRezAction.SaveToExistingUserInventoryItem == action)
{
m_scene.InventoryService.UpdateItem(item);
}
else
{
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();
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);
}
public void MoveItemToTrash(InventoryItemBase item, InventoryFolderBase trashFolder)
{
IInventoryProviderSelector inventorySelect = ProviderRegistry.Instance.Get<IInventoryProviderSelector>();
inventorySelect.GetProvider(item.Owner).SendItemToTrash(item, trashFolder.ID);
}
/// <summary>
/// Rez an object into the scene from the user's inventory
/// </summary>
/// FIXME: It would be really nice if inventory access modules didn't also actually do the work of rezzing
/// things to the scene. The caller should be doing that, I think.
/// <param name="remoteClient"></param>
/// <param name="itemID"></param>
/// <param name="RayEnd"></param>
/// <param name="RayStart"></param>
/// <param name="RayTargetID"></param>
/// <param name="BypassRayCast"></param>
/// <param name="RayEndIsIntersection"></param>
/// <param name="RezSelected"></param>
/// <param name="RemoveItem"></param>
/// <param name="fromTaskID"></param>
/// <param name="attachment"></param>
/// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful.</returns>
public virtual SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
bool RezSelected, bool RemoveItem, UUID fromTaskID)
{
// Work out position details
byte bRayEndIsIntersection = (byte)0;
if (RayEndIsIntersection)
{
bRayEndIsIntersection = (byte)1;
}
else
{
bRayEndIsIntersection = (byte)0;
}
Vector3 scale = new Vector3(0.5f, 0.5f, 0.5f);
Vector3 pos = m_scene.SceneGraph.GetNewRezLocation(
RayStart, RayEnd, RayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true, scale, false);
System.Xml.XmlDocument doc;
InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
item = m_scene.InventoryService.GetItem(item);
SceneObjectGroup group = CreateObjectFromInventory(item, remoteClient, itemID, out doc);
if (doc == null)
{
//No asset, check task inventory
IEntity e;
m_scene.SceneGraph.TryGetEntity(fromTaskID, out e);
if (e != null && e is SceneObjectGroup)
{
SceneObjectGroup grp = (SceneObjectGroup)e;
TaskInventoryItem taskItem = grp.RootPart.Inventory.GetInventoryItem(itemID);
item = new InventoryItemBase();
item.ID = UUID.Random();
item.CreatorId = taskItem.CreatorID.ToString();
item.Owner = remoteClient.AgentId;
item.AssetID = taskItem.AssetID;
item.Description = taskItem.Description;
item.Name = taskItem.Name;
item.AssetType = taskItem.Type;
item.InvType = taskItem.InvType;
item.Flags = taskItem.Flags;
item.SalePrice = taskItem.SalePrice;
item.SaleType = taskItem.SaleType;
if (m_scene.Permissions.PropagatePermissions())
{
item.BasePermissions = taskItem.BasePermissions & (taskItem.NextPermissions | (uint)PermissionMask.Move);
if (taskItem.InvType == (int)InventoryType.Object)
{
item.CurrentPermissions = item.BasePermissions & (((taskItem.CurrentPermissions & 7) << 13) | (taskItem.CurrentPermissions & (uint)PermissionMask.Move));
}
else
{
item.CurrentPermissions = item.BasePermissions & taskItem.CurrentPermissions;
}
item.CurrentPermissions |= 16; // Slam
item.NextPermissions = taskItem.NextPermissions;
item.EveryOnePermissions = taskItem.EveryonePermissions & (taskItem.NextPermissions | (uint)PermissionMask.Move);
item.GroupPermissions = taskItem.GroupPermissions & taskItem.NextPermissions;
}
else
{
item.BasePermissions = taskItem.BasePermissions;
item.CurrentPermissions = taskItem.CurrentPermissions;
item.NextPermissions = taskItem.NextPermissions;
item.EveryOnePermissions = taskItem.EveryonePermissions;
item.GroupPermissions = taskItem.GroupPermissions;
}
group = CreateObjectFromInventory(item, remoteClient, itemID, out doc);
}
else
{
return(null);
}
}
if (group == null && doc.FirstChild.OuterXml.StartsWith("<groups>"))
{
List <SceneObjectGroup> Groups = RezMultipleObjectsFromInventory(doc.FirstChild.ChildNodes, itemID, remoteClient, pos, RezSelected, item, RayTargetID, BypassRayCast, RayEndIsIntersection, RayEnd, RayStart, bRayEndIsIntersection);
if (Groups.Count != 0)
{
return(Groups[0]);
}
else
{
return(null);
}
}
string reason;
if (!m_scene.Permissions.CanRezObject(
group.ChildrenList.Count, remoteClient.AgentId, pos, out reason))
{
// The client operates in no fail mode. It will
// have already removed the item from the folder
// if it's no copy.
// Put it back if it's not an attachment
//
if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
{
remoteClient.SendBulkUpdateInventory(item);
}
remoteClient.SendAlertMessage("You do not have permission to rez objects here.");
return(null);
}
if (RezSelected)
{
group.RootPart.AddFlag(PrimFlags.CreateSelected);
}
// If we're rezzing an attachment then don't ask AddNewSceneObject() to update the client since
// we'll be doing that later on. Scheduling more than one full update during the attachment
// process causes some clients to fail to display the attachment properly.
m_scene.SceneGraph.AddPrimToScene(group);
// m_log.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
// Set it's position in world.
float offsetHeight = 0;
pos = m_scene.SceneGraph.GetNewRezLocation(
RayStart, RayEnd, RayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true, group.GetAxisAlignedBoundingBox(out offsetHeight), false);
pos.Z += offsetHeight;
group.AbsolutePosition = pos;
// m_log.InfoFormat("rezx point for inventory rezz is {0} {1} {2} and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
SceneObjectPart rootPart = (SceneObjectPart)group.GetChildPart(group.UUID);
if (rootPart == null)
{
m_log.Error("[AGENT INVENTORY]: Error rezzing ItemID: " + itemID + " object has no rootpart.");
return(null);
}
// Since renaming the item in the inventory does not affect the name stored
// in the serialization, transfer the correct name from the inventory to the
// object itself before we rez.
rootPart.Name = item.Name;
rootPart.Description = item.Description;
List <SceneObjectPart> partList = new List <SceneObjectPart> (group.ChildrenList);
group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
item.Owner = remoteClient.AgentId;
if (rootPart.OwnerID != item.Owner)
{
//Need to kill the for sale here
rootPart.ObjectSaleType = 0;
rootPart.SalePrice = 10;
if (m_scene.Permissions.PropagatePermissions())
{
if ((item.CurrentPermissions & 8) != 0)
{
foreach (SceneObjectPart part in partList)
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
group.ApplyNextOwnerPermissions();
}
}
foreach (SceneObjectPart part in partList)
{
if (part.OwnerID != item.Owner)
{
part.LastOwnerID = part.OwnerID;
part.OwnerID = item.Owner;
part.Inventory.ChangeInventoryOwner(item.Owner);
}
else if ((item.CurrentPermissions & 8) != 0) // Slam!
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
rootPart.TrimPermissions();
if (group.RootPart.Shape.PCode == (byte)PCode.Prim)
{
group.ClearPartAttachmentData();
}
// Fire on_rez
group.CreateScriptInstances(0, true, 0, UUID.Zero);
rootPart.ParentGroup.ResumeScripts();
group.ScheduleGroupUpdate(PrimUpdateFlags.FullUpdate);
if (!m_scene.Permissions.BypassPermissions())
{
if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
{
List <UUID> uuids = new List <UUID> ();
uuids.Add(item.ID);
m_scene.InventoryService.DeleteItems(item.Owner, uuids);
}
}
return(group);
}
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 List <SceneObjectGroup> RezMultipleObjectsFromInventory(XmlNodeList nodes, UUID itemId, IClientAPI remoteClient, Vector3 pos, bool RezSelected,
InventoryItemBase item, UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection, Vector3 RayEnd, Vector3 RayStart, byte bRayEndIsIntersection)
{
Vector3 OldMiddlePos = Vector3.Zero;
List <SceneObjectGroup> NewGroup = new List <SceneObjectGroup>();
foreach (System.Xml.XmlNode aPrimNode in nodes)
{
if (aPrimNode.OuterXml.StartsWith("<middle>"))
{
string Position = aPrimNode.OuterXml.Remove(0, 13);
Position = Position.Remove(Position.Length - 16, 16);
string[] XYZ = Position.Split(' ');
OldMiddlePos = new Vector3(float.Parse(XYZ[0]), float.Parse(XYZ[1]), float.Parse(XYZ[2]));
continue;
}
SceneObjectGroup group
= SceneObjectSerializer.FromOriginalXmlFormat(aPrimNode.OuterXml, m_scene);
if (group == null)
{
return(null);
}
group.IsDeleted = false;
group.m_isLoaded = true;
foreach (SceneObjectPart part in group.ChildrenList)
{
part.IsLoading = false;
}
NewGroup.Add(group);
string reason;
if (!m_scene.Permissions.CanRezObject(
group.ChildrenList.Count, remoteClient.AgentId, pos, out reason))
{
// The client operates in no fail mode. It will
// have already removed the item from the folder
// if it's no copy.
// Put it back if it's not an attachment
//
if (((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0))
{
remoteClient.SendBulkUpdateInventory(item);
}
return(null);
}
if (RezSelected)
{
group.RootPart.AddFlag(PrimFlags.CreateSelected);
}
// If we're rezzing an attachment then don't ask AddNewSceneObject() to update the client since
// we'll be doing that later on. Scheduling more than one full update during the attachment
// process causes some clients to fail to display the attachment properly.
m_scene.SceneGraph.AddPrimToScene(group);
// m_log.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
// if attachment we set it's asset id so object updates can reflect that
// if not, we set it's position in world.
float offsetHeight = 0;
pos = m_scene.SceneGraph.GetNewRezLocation(
RayStart, RayEnd, RayTargetID, Quaternion.Identity,
BypassRayCast, bRayEndIsIntersection, true, group.GetAxisAlignedBoundingBox(out offsetHeight), false);
pos.Z += offsetHeight;
//group.AbsolutePosition = pos;
// m_log.InfoFormat("rezx point for inventory rezz is {0} {1} {2} and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
SceneObjectPart rootPart = (SceneObjectPart)group.GetChildPart(group.UUID);
// Since renaming the item in the inventory does not affect the name stored
// in the serialization, transfer the correct name from the inventory to the
// object itself before we rez.
rootPart.Name = item.Name;
rootPart.Description = item.Description;
List <SceneObjectPart> partList = new List <SceneObjectPart>(group.ChildrenList);
group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
item.Owner = remoteClient.AgentId;
if (rootPart.OwnerID != item.Owner)
{
//Need to kill the for sale here
rootPart.ObjectSaleType = 0;
rootPart.SalePrice = 10;
if (m_scene.Permissions.PropagatePermissions())
{
if ((item.CurrentPermissions & 8) != 0)
{
foreach (SceneObjectPart part in partList)
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
group.ApplyNextOwnerPermissions();
}
}
foreach (SceneObjectPart part in partList)
{
if (part.OwnerID != item.Owner)
{
part.LastOwnerID = part.OwnerID;
part.OwnerID = item.Owner;
part.Inventory.ChangeInventoryOwner(item.Owner);
}
else if ((item.CurrentPermissions & 8) != 0) // Slam!
{
part.EveryoneMask = item.EveryOnePermissions;
part.NextOwnerMask = item.NextPermissions;
part.GroupMask = 0; // DO NOT propagate here
}
}
rootPart.TrimPermissions();
if (group.RootPart.Shape.PCode == (byte)PCode.Prim)
{
group.ClearPartAttachmentData();
}
// Fire on_rez
group.CreateScriptInstances(0, true, 0, UUID.Zero);
rootPart.ParentGroup.ResumeScripts();
if (!m_scene.Permissions.BypassPermissions())
{
if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
{
// If this is done on attachments, no
// copy ones will be lost, so avoid it
//
List <UUID> uuids = new List <UUID>();
uuids.Add(item.ID);
m_scene.InventoryService.DeleteItems(item.Owner, uuids);
}
}
}
foreach (SceneObjectGroup group in NewGroup)
{
if (OldMiddlePos != Vector3.Zero)
{
Vector3 NewPosOffset = Vector3.Zero;
NewPosOffset.X = group.AbsolutePosition.X - OldMiddlePos.X;
NewPosOffset.Y = group.AbsolutePosition.Y - OldMiddlePos.Y;
NewPosOffset.Z = group.AbsolutePosition.Z - OldMiddlePos.Z;
group.AbsolutePosition = pos + NewPosOffset;
}
group.ScheduleGroupUpdate(PrimUpdateFlags.FullUpdate);
}
return(NewGroup);
}
protected void HandleSaveAvatarArchive(string module, string[] cmdparams)
{
if (cmdparams.Length != 7)
{
m_log.Debug("[AvatarArchive] Not enough parameters!");
}
UserAccount account = m_scene.UserAccountService.GetUserAccount(UUID.Zero, cmdparams[3], cmdparams[4]);
if (account == null)
{
m_log.Error("[AvatarArchive] User not found!");
return;
}
ScenePresence SP;
m_scene.TryGetScenePresence(account.PrincipalID, out SP);
if (SP == null)
return; //Bad people!
SP.ControllingClient.SendAlertMessage("Appearance saving in progress...");
AvatarData avatarData = m_scene.AvatarService.GetAvatar(account.PrincipalID);
AvatarAppearance appearance = avatarData.ToAvatarAppearance(account.PrincipalID);
StreamWriter writer = new StreamWriter(cmdparams[5]);
writer.Write("<avatar>\n");
writer.Write("<" + appearance.AvatarHeight + ">\n");
writer.Write("<" + appearance.BodyAsset + ">\n");
writer.Write("<" + appearance.BodyItem + ">\n");
writer.Write("<" + appearance.EyesAsset + ">\n");
writer.Write("<" + appearance.EyesItem + ">\n");
writer.Write("<" + appearance.GlovesAsset + ">\n");
writer.Write("<" + appearance.GlovesItem + ">\n");
writer.Write("<" + appearance.HairAsset + ">\n");
writer.Write("<" + appearance.HairItem + ">\n");
writer.Write("<" + appearance.HipOffset + ">\n");
writer.Write("<" + appearance.JacketAsset + ">\n");
writer.Write("<" + appearance.JacketItem + ">\n");
writer.Write("<" + appearance.Owner + ">\n");
writer.Write("<" + appearance.PantsAsset + ">\n");
writer.Write("<" + appearance.PantsItem + ">\n");
writer.Write("<" + appearance.Serial + ">\n");
writer.Write("<" + appearance.ShirtAsset + ">\n");
writer.Write("<" + appearance.ShirtItem + ">\n");
writer.Write("<" + appearance.ShoesAsset + ">\n");
writer.Write("<" + appearance.ShoesItem + ">\n");
writer.Write("<" + appearance.SkinAsset + ">\n");
writer.Write("<" + appearance.SkinItem + ">\n");
writer.Write("<" + appearance.SkirtAsset + ">\n");
writer.Write("<" + appearance.SkirtItem + ">\n");
writer.Write("<" + appearance.SocksAsset + ">\n");
writer.Write("<" + appearance.SocksItem + ">\n");
writer.Write("<" + appearance.UnderPantsAsset + ">\n");
writer.Write("<" + appearance.UnderPantsItem + ">\n");
writer.Write("<" + appearance.UnderShirtAsset + ">\n");
writer.Write("<" + appearance.UnderShirtItem + ">\n");
writer.Write("<VisualParams>\n");
foreach (Byte Byte in appearance.VisualParams)
{
writer.Write("</VP" + Convert.ToString(Byte) + ">\n");
}
writer.Write("</VisualParams>\n");
writer.Write("<wearables>\n");
foreach (AvatarWearable wear in appearance.Wearables)
{
writer.Write("<WA" + wear.AssetID + ">\n");
writer.Write("<WI" + wear.ItemID + ">\n");
}
writer.Write("</wearables>\n");
writer.Write("<TEXTURE" + appearance.Texture.ToString().Replace("\n", "") + "TEXTURE>\n");
writer.Write("</avatar>");
Hashtable attachments = appearance.GetAttachments();
writer.Write("<attachments>\n");
if (attachments != null)
{
foreach (DictionaryEntry element in attachments)
{
Hashtable attachInfo = (Hashtable)element.Value;
InventoryItemBase IB = new InventoryItemBase(UUID.Parse(attachInfo["item"].ToString()));
writer.Write("<AI" + attachInfo["item"] + ">\n");
writer.Write("<AA" + IB.AssetID + ">\n");
writer.Write("<AP" + (int)element.Key + ">\n");
}
}
writer.Write("</attachments>");
writer.Close();
writer.Dispose();
m_log.Debug("[AvatarArchive] Saved archive to " + cmdparams[5]);
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item)
{
return(m_InventoryService.UpdateItem(item));
}
private void FixItemIDs(UUID oldID, InventoryItemBase item, AvatarAppearance appearance)
{
//Fix the IDs
AvatarWearable[] wearables = new AvatarWearable[appearance.Wearables.Length];
appearance.Wearables.CopyTo(wearables, 0);
for (int a = 0; a < wearables.Length; a++)
{
for (int i = 0; i < wearables[a].Count; i++)
{
if (wearables[a][i].ItemID == oldID)
{
//Fix the ItemID
AvatarWearable w = new AvatarWearable();
w.Unpack((OSDArray)wearables[a].Pack());
UUID assetID = w.GetAsset(oldID);
w.RemoveItem(oldID);
w.Add(item.ID, assetID);
appearance.SetWearable(a, w);
return;
}
}
}
}
public static string Serialize(InventoryItemBase inventoryItem)
{
StringWriter sw = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(sw)
{
Formatting = Formatting.Indented
};
writer.WriteStartDocument();
writer.WriteStartElement("InventoryItem");
writer.WriteStartElement("Name");
writer.WriteString(inventoryItem.Name);
writer.WriteEndElement();
writer.WriteStartElement("ID");
writer.WriteString(inventoryItem.ID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("InvType");
writer.WriteString(inventoryItem.InvType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("CreatorUUID");
writer.WriteString(inventoryItem.CreatorId);
writer.WriteEndElement();
writer.WriteStartElement("CreatorData");
writer.WriteString(inventoryItem.CreatorData);
writer.WriteEndElement();
writer.WriteStartElement("CreationDate");
writer.WriteString(inventoryItem.CreationDate.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Owner");
writer.WriteString(inventoryItem.Owner.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Description");
writer.WriteString(inventoryItem.Description);
writer.WriteEndElement();
writer.WriteStartElement("AssetType");
writer.WriteString(inventoryItem.AssetType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("AssetID");
writer.WriteString(inventoryItem.AssetID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("SaleType");
writer.WriteString(inventoryItem.SaleType.ToString());
writer.WriteEndElement();
writer.WriteStartElement("SalePrice");
writer.WriteString(inventoryItem.SalePrice.ToString());
writer.WriteEndElement();
writer.WriteStartElement("BasePermissions");
writer.WriteString(inventoryItem.BasePermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("CurrentPermissions");
writer.WriteString(inventoryItem.CurrentPermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("EveryOnePermissions");
writer.WriteString(inventoryItem.EveryOnePermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("NextPermissions");
writer.WriteString(inventoryItem.NextPermissions.ToString());
writer.WriteEndElement();
writer.WriteStartElement("Flags");
writer.WriteString(inventoryItem.Flags.ToString());
writer.WriteEndElement();
writer.WriteStartElement("GroupID");
writer.WriteString(inventoryItem.GroupID.ToString());
writer.WriteEndElement();
writer.WriteStartElement("GroupOwned");
writer.WriteString(inventoryItem.GroupOwned.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.Close();
return(sw.ToString());
}
private InventoryItemBase[] ParseInventoryItems (Dictionary<string, List<string>> retVal)
{
List<InventoryItemBase> items = new List<InventoryItemBase> ();
if (retVal == null || retVal.Count == 0)
return items.ToArray ();
for (int i = 0; i < retVal.ElementAt (0).Value.Count; i++)
{
InventoryItemBase item = new InventoryItemBase ();
item.AssetID = UUID.Parse (retVal["assetID"][i]);
item.AssetType = int.Parse (retVal["assetType"][i]);
item.Name = retVal["inventoryName"][i];
item.Description = retVal["inventoryDescription"][i];
item.NextPermissions = uint.Parse (retVal["inventoryNextPermissions"][i]);
item.CurrentPermissions = uint.Parse (retVal["inventoryCurrentPermissions"][i]);
item.InvType = int.Parse (retVal["invType"][i]);
item.CreatorId = retVal["creatorID"][i];
item.BasePermissions = uint.Parse (retVal["inventoryBasePermissions"][i]);
item.EveryOnePermissions = uint.Parse (retVal["inventoryEveryOnePermissions"][i]);
item.SalePrice = int.Parse (retVal["salePrice"][i]);
item.SaleType = byte.Parse (retVal["saleType"][i]);
item.CreationDate = int.Parse (retVal["creationDate"][i]);
item.GroupID = UUID.Parse (retVal["groupID"][i]);
item.GroupOwned = int.Parse (retVal["groupOwned"][i]) == 1;
item.Flags = uint.Parse (retVal["flags"][i]);
item.ID = UUID.Parse (retVal["inventoryID"][i]);
item.Owner = UUID.Parse (retVal["avatarID"][i]);
item.Folder = UUID.Parse (retVal["parentFolderID"][i]);
item.GroupPermissions = uint.Parse (retVal["inventoryGroupPermissions"][i]);
items.Add (item);
}
return items.ToArray ();
}
protected void OnInstantMessage(IClientAPI client, GridInstantMessage im)
{
m_log.InfoFormat("[WATER WARS]: GameManagerTopLevelInteraction.OnInstantMessage received");
if (im.dialog == (byte)InstantMessageDialog.InventoryAccepted &&
client.AgentId == m_playerId)
{
m_log.InfoFormat("[WATER WARS]: Now we get to do something cool! IMSessionId [{0}]", im.imSessionID);
UUID itemId = new UUID(im.imSessionID);
Scene scene = client.Scene as Scene;
// This really need to be a 'has inventory item' method in Scene.Inventory.cs
InventoryItemBase item = new InventoryItemBase(itemId, m_playerId);
item = scene.InventoryService.GetItem(item);
if (item == null)
{
m_log.Error("[WATER WARS]: Failed to find item " + itemId);
return;
}
else if (item.Name != HUD_ITEM_NAME)
{
m_log.InfoFormat(
"[WATER WARS]: Ignoring hud item {0} since it's not a {1}", item.Name, HUD_ITEM_NAME);
return;
}
uint attachmentPoint = (uint)AttachmentPoint.HUDTop;
ScenePresence sp = scene.GetScenePresence(client.AgentId);
List <SceneObjectGroup> existingAttachments = sp.GetAttachments(attachmentPoint);
if (existingAttachments.Count == 0)
{
IAttachmentsModule module = client.Scene.RequestModuleInterface <IAttachmentsModule>();
SceneObjectGroup sog
= (SceneObjectGroup)module.RezSingleAttachmentFromInventory(
sp, new UUID(im.imSessionID), (uint)AttachmentPoint.HUDTop);
// A tempoary messy solution to an occasional race where the attached hud sometimes ends up positioned
// on the avatar itself and does not show up as attached within inventory.
Thread.Sleep(1000);
Vector3 newPos = new Vector3(0, 0, -0.1f);
m_log.InfoFormat("[WATER WARS]: Resetting HUD position to {0}", newPos);
module.UpdateAttachmentPosition(sog, newPos);
/*
* sog.UpdateGroupPosition(newPos);
* sog.HasGroupChanged = true;
* sog.ScheduleGroupForTerseUpdate();
*/
}
else
{
m_log.InfoFormat(
"[WATER WARS]: Not attaching given hud for {0} since something is already attached at {1}",
client.Name, attachmentPoint);
}
client.OnInstantMessage -= OnInstantMessage;
}
}
/// <summary>
/// Add an item to the user's inventory.
/// </summary>
/// If the item has no folder set (i.e. it is UUID.Zero), then it is placed in the most appropriate folder
/// for that type.
/// <param name="itemInfo"></param>
public void AddItem(InventoryItemBase item)
{
if (m_hasReceivedInventory)
{
if (item.Folder == UUID.Zero)
{
InventoryFolderImpl f = FindFolderForType(item.AssetType);
if (f != null)
item.Folder = f.ID;
else
item.Folder = RootFolder.ID;
}
ItemReceive(item, null);
m_InventoryService.AddItem(item);
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(AddItemDelegate), this, "AddItem"),
new object[] { item }));
}
}
/// <summary>
/// Adds a specified item to the database
/// </summary>
/// <param name="item">The inventory item</param>
public void addInventoryItem(InventoryItemBase item)
{
string sql =
"REPLACE INTO inventoryitems (inventoryID, assetID, assetType, parentFolderID, avatarID, inventoryName"
+ ", inventoryDescription, inventoryNextPermissions, inventoryCurrentPermissions, invType"
+ ", creatorID, inventoryBasePermissions, inventoryEveryOnePermissions, inventoryGroupPermissions, salePrice, saleType"
+ ", creationDate, groupID, groupOwned, flags) VALUES ";
sql +=
"(?inventoryID, ?assetID, ?assetType, ?parentFolderID, ?avatarID, ?inventoryName, ?inventoryDescription"
+ ", ?inventoryNextPermissions, ?inventoryCurrentPermissions, ?invType, ?creatorID"
+ ", ?inventoryBasePermissions, ?inventoryEveryOnePermissions, ?inventoryGroupPermissions, ?salePrice, ?saleType, ?creationDate"
+ ", ?groupID, ?groupOwned, ?flags)";
string itemName = item.Name;
if (item.Name.Length > 64)
{
itemName = item.Name.Substring(0, 64);
m_log.Warn("[INVENTORY DB]: Name field truncated from " + item.Name.Length + " to " + itemName.Length + " characters on add item");
}
string itemDesc = item.Description;
if (item.Description.Length > 128)
{
itemDesc = item.Description.Substring(0, 128);
m_log.Warn("[INVENTORY DB]: Description field truncated from " + item.Description.Length + " to " + itemDesc.Length + " characters on add item");
}
try
{
using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
{
dbcon.Open();
using (MySqlCommand result = new MySqlCommand(sql, dbcon))
{
result.Parameters.AddWithValue("?inventoryID", item.ID.ToString());
result.Parameters.AddWithValue("?assetID", item.AssetID.ToString());
result.Parameters.AddWithValue("?assetType", item.AssetType.ToString());
result.Parameters.AddWithValue("?parentFolderID", item.Folder.ToString());
result.Parameters.AddWithValue("?avatarID", item.Owner.ToString());
result.Parameters.AddWithValue("?inventoryName", itemName);
result.Parameters.AddWithValue("?inventoryDescription", itemDesc);
result.Parameters.AddWithValue("?inventoryNextPermissions", item.NextPermissions.ToString());
result.Parameters.AddWithValue("?inventoryCurrentPermissions",
item.CurrentPermissions.ToString());
result.Parameters.AddWithValue("?invType", item.InvType);
result.Parameters.AddWithValue("?creatorID", item.CreatorId);
result.Parameters.AddWithValue("?inventoryBasePermissions", item.BasePermissions);
result.Parameters.AddWithValue("?inventoryEveryOnePermissions", item.EveryOnePermissions);
result.Parameters.AddWithValue("?inventoryGroupPermissions", item.GroupPermissions);
result.Parameters.AddWithValue("?salePrice", item.SalePrice);
result.Parameters.AddWithValue("?saleType", unchecked ((sbyte)item.SaleType));
result.Parameters.AddWithValue("?creationDate", item.CreationDate);
result.Parameters.AddWithValue("?groupID", item.GroupID);
result.Parameters.AddWithValue("?groupOwned", item.GroupOwned);
result.Parameters.AddWithValue("?flags", item.Flags);
lock (m_dbLock)
result.ExecuteNonQuery();
result.Dispose();
}
using (MySqlCommand result = new MySqlCommand("update inventoryfolders set version=version+1 where folderID = ?folderID", dbcon))
{
result.Parameters.AddWithValue("?folderID", item.Folder.ToString());
lock (m_dbLock)
result.ExecuteNonQuery();
}
dbcon.Close();
}
}
catch (MySqlException e)
{
m_log.Error(e.ToString());
}
}
// Load additional items that other regions have put into the database
// The item will be added tot he local cache. Returns true if the item
// was found and can be sent to the client
//
public bool QueryItem(InventoryItemBase item)
{
if (m_hasReceivedInventory)
{
InventoryItemBase invItem = RootFolder.FindItem(item.ID);
if (invItem != null)
{
// Item is in local cache, just update client
//
return true;
}
InventoryItemBase itemInfo = null;
itemInfo = m_InventoryService.GetItem(item);
if (itemInfo != null)
{
InventoryFolderImpl folder = RootFolder.FindFolder(itemInfo.Folder);
ItemReceive(itemInfo, folder);
return true;
}
return false;
}
else
{
AddRequest(
new InventoryRequest(
Delegate.CreateDelegate(typeof(QueryItemDelegate), this, "QueryItem"),
new object[] { item.ID }));
return true;
}
}
/// <summary>
/// Updates the specified inventory item
/// </summary>
/// <param name="item">Inventory item to update</param>
public void updateInventoryItem(InventoryItemBase item)
{
addInventoryItem(item);
}
public override void Awake()
{
base.Awake();
item = this.Owner.GetComponent<InventoryItemBase>();
}
/// <summary>
/// Add an inventory item from a user's inventory to a prim in this scene object.
/// </summary>
/// <param name="remoteClient">The client adding the item.</param>
/// <param name="localID">The local ID of the part receiving the add.</param>
/// <param name="item">The user inventory item being added.</param>
/// <param name="copyItemID">The item UUID that should be used by the new item.</param>
/// <returns></returns>
public bool AddInventoryItem(IClientAPI remoteClient, uint localID,
InventoryItemBase item, UUID copyItemID)
{
// m_log.DebugFormat(
// "[PRIM INVENTORY]: Adding inventory item {0} from {1} to part with local ID {2}",
// item.Name, remoteClient.Name, localID);
UUID newItemId = (copyItemID != UUID.Zero) ? copyItemID : item.ID;
SceneObjectPart part = GetChildPart(localID);
if (part != null)
{
TaskInventoryItem taskItem = new TaskInventoryItem();
taskItem.ItemID = newItemId;
taskItem.AssetID = item.AssetID;
taskItem.Name = item.Name;
taskItem.Description = item.Description;
taskItem.OwnerID = part.OwnerID; // Transfer ownership
taskItem.CreatorID = item.CreatorIdAsUuid;
taskItem.Type = item.AssetType;
taskItem.InvType = item.InvType;
if (remoteClient != null &&
remoteClient.AgentId != part.OwnerID &&
m_scene.Permissions.PropagatePermissions())
{
taskItem.BasePermissions = item.BasePermissions &
item.NextPermissions;
taskItem.CurrentPermissions = item.CurrentPermissions &
item.NextPermissions;
taskItem.EveryonePermissions = item.EveryOnePermissions &
item.NextPermissions;
taskItem.GroupPermissions = item.GroupPermissions &
item.NextPermissions;
taskItem.NextPermissions = item.NextPermissions;
// We're adding this to a prim we don't own. Force
// owner change
taskItem.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
}
else
{
taskItem.BasePermissions = item.BasePermissions;
taskItem.CurrentPermissions = item.CurrentPermissions;
taskItem.EveryonePermissions = item.EveryOnePermissions;
taskItem.GroupPermissions = item.GroupPermissions;
taskItem.NextPermissions = item.NextPermissions;
}
taskItem.Flags = item.Flags;
// m_log.DebugFormat(
// "[PRIM INVENTORY]: Flags are 0x{0:X} for item {1} added to part {2} by {3}",
// taskItem.Flags, taskItem.Name, localID, remoteClient.Name);
// TODO: These are pending addition of those fields to TaskInventoryItem
// taskItem.SalePrice = item.SalePrice;
// taskItem.SaleType = item.SaleType;
taskItem.CreationDate = (uint)item.CreationDate;
bool addFromAllowedDrop = false;
if (remoteClient != null)
{
addFromAllowedDrop = remoteClient.AgentId != part.OwnerID;
}
part.Inventory.AddInventoryItem(taskItem, addFromAllowedDrop);
return(true);
}
else
{
m_log.ErrorFormat(
"[PRIM INVENTORY]: " +
"Couldn't find prim local ID {0} in group {1}, {2} to add inventory item ID {3}",
localID, Name, UUID, newItemId);
}
return(false);
}
