/// <summary>
/// Load an item from the archive
/// </summary>
/// <param name="filePath">The archive path for the item</param>
/// <param name="data">The raw item data</param>
/// <param name="rootDestinationFolder">The root destination folder for loaded items</param>
/// <param name="nodesLoaded">All the inventory nodes (items and folders) loaded so far</param>
protected InventoryItemBase LoadItem(byte[] data, InventoryFolderBase loadFolder)
{
InventoryItemBase item = UserInventoryItemSerializer.Deserialize(data);
UUID oldID = item.ID;
// Don't use the item ID that's in the file
item.ID = UUID.Random();
m_itemIDs[oldID] = item.ID;
UUID ospResolvedId = OspResolver.ResolveOspa(item.CreatorId, m_UserAccountService);
if (UUID.Zero != ospResolvedId) // The user exists in this grid
{
// m_log.DebugFormat("[INVENTORY ARCHIVER]: Found creator {0} via OSPA resolution", ospResolvedId);
// item.CreatorIdAsUuid = ospResolvedId;
// Don't preserve the OSPA in the creator id (which actually gets persisted to the
// database). Instead, replace with the UUID that we found.
item.CreatorId = ospResolvedId.ToString();
item.CreatorData = string.Empty;
}
else if (string.IsNullOrEmpty(item.CreatorData))
{
item.CreatorId = m_userInfo.PrincipalID.ToString();
}
item.Owner = m_userInfo.PrincipalID;
// Reset folder ID to the one in which we want to load it
item.Folder = loadFolder.ID;
// Record the creator id for the item's asset so that we can use it later, if necessary, when the asset
// is loaded.
// FIXME: This relies on the items coming before the assets in the TAR file. Need to create stronger
// checks for this, and maybe even an external tool for creating OARs which enforces this, rather than
// relying on native tar tools.
if (item.AssetType == (int)AssetType.Link)
{
m_invLinks.Add(item);
if (!m_loadedNodes.ContainsKey(item.Folder) && !m_invLinksFolders.ContainsKey(item.Folder))
{
m_invLinksFolders[item.Folder] = loadFolder;
}
return(null);
}
else
{
m_creatorIdForAssetId[item.AssetID] = item.CreatorIdAsUuid;
if (!m_InventoryService.AddItem(item))
{
m_log.WarnFormat("[INVENTORY ARCHIVER]: Unable to save item {0} in folder {1}", item.Name, item.Folder);
}
}
return(item);
}
/// <summary>
///
/// </summary>
/// <param name="assetID"></param>
/// <param name="inventoryItem"></param>
/// <param name="data"></param>
public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
string assetType)
{
sbyte assType = 0;
sbyte inType = 0;
if (inventoryType == "sound")
{
inType = 1;
assType = 1;
}
else if (inventoryType == "animation")
{
inType = 19;
assType = 20;
}
else if (inventoryType == "snapshot")
{
inType = 15;
assType = 0;
}
else if (inventoryType == "wearable")
{
inType = 18;
switch (assetType)
{
case "bodypart":
assType = 13;
break;
case "clothing":
assType = 5;
break;
}
}
AssetBase asset = new AssetBase(assetID, assetName, assType, m_service.AgentID.ToString());
asset.Data = data;
m_assetService.Store(asset);
InventoryItemBase item = new InventoryItemBase();
item.Owner = m_service.AgentID;
item.CreatorId = m_service.AgentID.ToString();
item.ID = inventoryItem;
item.AssetID = asset.FullID;
item.Description = assetDescription;
item.Name = assetName;
item.AssetType = assType;
item.InvType = inType;
item.Folder = parentFolder;
item.CurrentPermissions = (uint)PermissionMask.All;
item.BasePermissions = (uint)PermissionMask.All;
item.EveryOnePermissions = 0;
item.NextPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
item.CreationDate = Util.UnixTimeSinceEpoch();
m_inventoryService.AddItem(item);
}
public bool AddItem(InventoryItemBase item)
{
m_log.DebugFormat(
"[LOCAL INVENTORY SERVICES CONNECTOR]: Adding inventory item {0} to user {1} folder {2}",
item.Name, item.Owner, item.Folder);
if (UUID.Zero == item.Folder)
{
InventoryFolderBase f = m_InventoryService.GetFolderForType(item.Owner, (AssetType)item.AssetType);
if (f != null)
{
item.Folder = f.ID;
}
else
{
f = m_InventoryService.GetRootFolder(item.Owner);
if (f != null)
{
item.Folder = f.ID;
}
else
{
return(false);
}
}
}
return(m_InventoryService.AddItem(item));
}
public ActionResult New([Bind(Include = "ItemNo,CategoryId,Description,ReorderLevel,ReorderQuantity,MeasurementId,Quantity,HoldQuantity,SupplierId1,Price1,SupplierId2,Price2,SupplierId3,Price3,BinNo")] Inventory inventory)
{
if (ModelState.IsValid)
{
if ((inventory.SupplierId1 != inventory.SupplierId2) && (inventory.SupplierId1 != inventory.SupplierId3) && (inventory.SupplierId2 != inventory.SupplierId3))
{
inventory.ItemNo = inventorySvc.GetItemCode(inventory.Description);
inventorySvc.AddItem(inventory);
return RedirectToAction("Inventory");
}
else
{
ViewBag.Error = "Please ensure that all three suppliers are different.";
}
}
else
{
ViewBag.Error = "Please ensure that all three suppliers are different.";
}
ViewBag.CategoryId = new SelectList(inventorySvc.GetAllCategories(), "CategoryId", "CategoryName", inventory.CategoryId);
ViewBag.MeasurementId = new SelectList(inventorySvc.GetAllMeasurements(), "MeasurementId", "UnitOfMeasurement", inventory.MeasurementId);
ViewBag.SupplierId1 = new SelectList(inventorySvc.GetAllSuppliers(), "SupplierId", "SupplierCode", inventory.SupplierId1);
ViewBag.SupplierId2 = new SelectList(inventorySvc.GetAllSuppliers(), "SupplierId", "SupplierCode", inventory.SupplierId2);
ViewBag.SupplierId3 = new SelectList(inventorySvc.GetAllSuppliers(), "SupplierId", "SupplierCode", inventory.SupplierId3);
return View("NewStockCard");
}
/// <summary>
/// Read a library inventory item metadata from a loaded configuration
/// </summary>
/// <param name="source"></param>
private void ReadItemFromConfig(IConfig config, string path)
{
InventoryItemBase item = new InventoryItemBase();
item.Owner = m_service.LibraryOwner;
item.CreatorId = m_service.LibraryOwner.ToString();
item.ID = new UUID(config.GetString("inventoryID", m_service.LibraryRootFolder.ID.ToString()));
item.AssetID = new UUID(config.GetString("assetID", item.ID.ToString()));
item.Folder = new UUID(config.GetString("folderID", m_service.LibraryRootFolder.ID.ToString()));
item.Name = config.GetString("name", String.Empty);
item.Description = config.GetString("description", item.Name);
item.InvType = config.GetInt("inventoryType", 0);
item.AssetType = config.GetInt("assetType", item.InvType);
item.CurrentPermissions = (uint)config.GetLong("currentPermissions", 0x7FFFFFFF);
item.NextPermissions = (uint)config.GetLong("nextPermissions", 0x7FFFFFFF);
item.EveryOnePermissions = (uint)config.GetLong("everyonePermissions", 0x7FFFFFFF);
item.BasePermissions = (uint)config.GetLong("basePermissions", 0x7FFFFFFF);
item.Flags = (uint)config.GetInt("flags", 0);
m_inventoryService.AddItem(item);
if (item.Folder == m_service.LibraryRootFolder.ID)
{
m_folder.Items.Add(item.ID, item);
}
else
{
m_folder.FindFolder(item.Folder).Items.Add(item.ID, item);
}
}
/// <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 }));
}
}
private void DoCreateItem(uint callbackID)
{
m_userTransactions.Manager.MyScene.AssetService.Store(m_asset);
IInventoryService invService = m_userTransactions.Manager.MyScene.InventoryService;
InventoryItemBase item = new InventoryItemBase();
item.Owner = ourClient.AgentId;
item.CreatorId = ourClient.AgentId.ToString();
item.ID = UUID.Random();
item.AssetID = m_asset.FullID;
item.Description = m_description;
item.Name = m_name;
item.AssetType = type;
item.InvType = invType;
item.Folder = InventFolder;
item.BasePermissions = 0x7fffffff;
item.CurrentPermissions = 0x7fffffff;
item.GroupPermissions = 0;
item.EveryOnePermissions = 0;
item.NextPermissions = nextPerm;
item.Flags = (uint)wearableType;
item.CreationDate = Util.UnixTimeSinceEpoch();
if (invService.AddItem(item))
{
ourClient.SendInventoryItemCreateUpdate(item, callbackID);
}
else
{
ourClient.SendAlertMessage("Unable to create inventory item");
}
}
private InventoryItemBase GiveInventoryItem(UUID senderId, UUID recipient, InventoryItemBase item,
InventoryFolderBase parentFolder)
{
InventoryItemBase itemCopy = new InventoryItemBase
{
Owner = recipient,
CreatorId = item.CreatorId,
CreatorData = item.CreatorData,
ID = UUID.Random(),
AssetID = item.AssetID,
Description = item.Description,
Name = item.Name,
AssetType = item.AssetType,
InvType = item.InvType,
Folder = UUID.Zero,
NextPermissions = (uint)PermissionMask.All,
GroupPermissions = (uint)PermissionMask.All,
EveryOnePermissions = (uint)PermissionMask.All,
CurrentPermissions = (uint)PermissionMask.All
};
//Give full permissions for them
if (parentFolder == null)
{
InventoryFolderBase folder = InventoryService.GetFolderForType(recipient, InventoryType.Unknown,
(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 bool AddItem(InventoryItemBase item)
{
// m_log.DebugFormat(
// "[LOCAL INVENTORY SERVICES CONNECTOR]: Adding inventory item {0} to user {1} folder {2}",
// item.Name, item.Owner, item.Folder);
return(m_InventoryService.AddItem(item));
}
public IActionResult AddItem([FromBody] ItemModel item)
{
if (item != null)
{
_itemService.AddItem(item);
_service.AddItem(item);
}
return(Ok());
}
public bool AddInventoryItem(InventoryItemBase item)
{
if (UUID.Zero == item.Folder)
{
InventoryFolderBase f = m_inventoryService.GetFolderForType(
item.Owner,
(InventoryType)item.InvType,
(AssetType)item.AssetType);
if (f != null)
{
// MainConsole.Instance.DebugFormat(
// "[LOCAL INVENTORY SERVICES CONNECTOR]: Found folder {0} type {1} for item {2}",
// f.Name, (AssetType)f.Type, item.Name);
item.Folder = f.ID;
}
else
{
f = m_inventoryService.GetRootFolder(item.Owner);
if (f != null)
{
item.Folder = f.ID;
}
else
{
MainConsole.Instance.WarnFormat(
"[AGENT INVENTORY]: Could not find root folder for {0} when trying to add item {1} with no parent folder specified",
item.Owner, item.Name);
return(false);
}
}
}
// check if the folder item exists
if (!m_inventoryService.FolderItemExists(item.Folder, item.ID))
{
if (m_inventoryService.ItemExists(item.ID))
{
// Don't use this item ID as it probably belongs to another local user's folder
item.ID = UUID.Random();
}
if (!m_inventoryService.AddItem(item))
{
MainConsole.Instance.WarnFormat(
"[AGENT INVENTORY]: Agent {0} could not add item {1} {2}",
item.Owner, item.Name, item.ID);
return(false);
}
}
return(true);
}
byte[] HandleAddItem(Dictionary <string, object> request)
{
InventoryItemBase item = BuildItem(request);
if (m_InventoryService.AddItem(item))
{
return(SuccessResult());
}
else
{
return(FailureResult());
}
}
public void ProcessBuyRequest(Message message)
{
var inputMessage = GetData <InputBuyMessage>(message);
//TODO: Check if store has item
//TODO: Get store price and deduct user
var item = _itemRepository.GetItem(inputMessage.Item);
if (item != null)
{
_inventoryService.AddItem(message.Player.Id, inputMessage.Item, inputMessage.Amount);
}
}
public void ProcessGiveRequest(Message message)
{
var inputMessage = GetData <CommandRequest>(message);
if (inputMessage != null)
{
if (!int.TryParse(inputMessage.Arguments[0], out var itemId))
{
return;
}
_inventoryService.AddItem(message.Player.Id, itemId, 1);
}
}
public bool AddItem(InventoryItemBase item)
{
if (item == null)
return false;
//m_log.Debug("[HG INVENTORY CONNECTOR]: AddItem " + item.ID);
string invURL = GetInventoryServiceURL(item.Owner);
if (invURL == null) // not there, forward to local inventory connector to resolve
return m_LocalGridInventoryService.AddItem(item);
IInventoryService connector = GetConnector(invURL);
return connector.AddItem(item);
}
public bool AddItem(InventoryItemBase item)
{
if (item == null)
{
return(false);
}
if (IsLocalGridUser(item.Owner))
{
return(m_GridService.AddItem(item));
}
else
{
UUID sessionID = GetSessionID(item.Owner);
string uri = GetUserInventoryURI(item.Owner) + "/" + item.Owner.ToString();
return(m_HGService.AddItem(uri, item, sessionID));
}
}
public IActionResult SaveItem([FromBody] Item itemDto)
{
bool isNew = itemDto.Id == 0;
Core.Domain.Items.Item item = null;
if (isNew)
{
item = new Core.Domain.Items.Item();
}
else
{
item = _inventoryService.GetItemById(itemDto.Id);
}
item.No = itemDto.No;
item.Code = itemDto.Code;
item.Description = itemDto.Description;
item.SellDescription = itemDto.SellDescription;
item.PurchaseDescription = itemDto.PurchaseDescription;
item.Cost = itemDto.Cost;
item.Price = itemDto.Price;
item.SmallestMeasurementId = itemDto.SmallestMeasurementId;
item.SellMeasurementId = itemDto.SellMeasurementId;
item.PurchaseMeasurementId = itemDto.PurchaseMeasurementId;
item.ItemCategoryId = itemDto.ItemCategoryId;
item.ItemTaxGroupId = itemDto.ItemTaxGroupId;
item.SalesAccountId = itemDto.SalesAccountId;
item.InventoryAccountId = itemDto.InventoryAccountId;
item.InventoryAdjustmentAccountId = itemDto.InventoryAdjustmentAccountId;
item.CostOfGoodsSoldAccountId = itemDto.CostOfGoodsSoldAccountId;
if (isNew)
{
_inventoryService.AddItem(item);
}
else
{
_inventoryService.UpdateItem(item);
}
return(Ok());
}
/// -----------------------------------------------------------------
/// <summary>
/// </summary>
// -----------------------------------------------------------------
private void AddWearablesToCurrentOutfitFolder(ScenePresence sp)
{
IInventoryService iservice = m_scene.InventoryService;
InventoryFolderBase folder = iservice.GetFolderForType(sp.UUID, FolderType.CurrentOutfit);
if (folder == null)
{
m_log.WarnFormat("[AvatarHandlers] Unable to find current outfit folder for {0}", sp.UUID);
return;
}
List <InventoryItemBase> items = new List <InventoryItemBase>();
for (int i = 0; i < AvatarWearable.LEGACY_VERSION_MAX_WEARABLES; i++)
{
for (int j = 0; j < sp.Appearance.Wearables[i].Count; j++)
{
// trying to create links.. this could go horribly wrong
InventoryItemBase item = new InventoryItemBase(sp.Appearance.Wearables[i][j].ItemID, sp.UUID);
// Fill in the rest of the details from the current item
item = iservice.GetItem(item);
// And morph it into a link, it appears that the asset is really a reference to another
// inventory item
item.AssetID = item.ID;
item.ID = UUID.Random();
item.Folder = folder.ID;
items.Add(item);
iservice.AddItem(item);
}
}
// Add the items from the Current Outfit inventory folder
IClientCore core = (IClientCore)sp.ControllingClient;
IClientInventory inv;
if (core.TryGet <IClientInventory>(out inv))
{
inv.SendBulkUpdateInventory(new InventoryFolderBase[] { folder }, items.ToArray());
}
}
public ActionResult AddItem(Models.ViewModels.Items.Items.AddItem model)
{
try
{
_inventoryService.AddItem(new Core.Domain.Items.Item()
{
Code = model.Code,
Description = model.Description,
CreatedBy = User.Identity.Name,
CreatedOn = DateTime.Now,
ModifiedBy = User.Identity.Name,
ModifiedOn = DateTime.Now
});
return(RedirectToAction("Items"));
}
catch
{
return(View());
}
}
public void TestAddItem()
{
TestHelpers.InMethod();
string creatorId = TestHelpers.ParseTail(0x1).ToString();
UUID ownerId = TestHelpers.ParseTail(0x2);
UUID itemId = TestHelpers.ParseTail(0x10);
UUID assetId = TestHelpers.ParseTail(0x20);
UUID folderId = TestHelpers.ParseTail(0x30);
int invType = (int)InventoryType.Animation;
int assetType = (int)AssetType.Animation;
string itemName = "item1";
IInventoryService xis = CreateXInventoryService();
InventoryItemBase itemToStore
= new InventoryItemBase(itemId, ownerId)
{
CreatorIdentification = creatorId.ToString(),
AssetID = assetId,
Name = itemName,
Folder = folderId,
InvType = invType,
AssetType = assetType
};
Assert.That(xis.AddItem(itemToStore), Is.True);
InventoryItemBase itemRetrieved = new InventoryItemBase(itemId);
itemRetrieved = xis.GetItem(itemRetrieved);
Assert.That(itemRetrieved, Is.Not.Null);
Assert.That(itemRetrieved.CreatorId, Is.EqualTo(creatorId));
Assert.That(itemRetrieved.Owner, Is.EqualTo(ownerId));
Assert.That(itemRetrieved.AssetID, Is.EqualTo(assetId));
Assert.That(itemRetrieved.Folder, Is.EqualTo(folderId));
Assert.That(itemRetrieved.InvType, Is.EqualTo(invType));
Assert.That(itemRetrieved.AssetType, Is.EqualTo(assetType));
Assert.That(itemRetrieved.Name, Is.EqualTo(itemName));
}
public ActionResult AddItem(Models.ViewModels.Items.Items.AddItem model)
{
try
{
if (string.IsNullOrEmpty(model.Description))
{
throw new Exception("Description cannot be empty.");
}
_inventoryService.AddItem(new Core.Domain.Items.Item()
{
Code = model.Code,
Description = model.Description,
});
return(RedirectToAction("Items"));
}
catch
{
return(View(model));
}
}
private void TryAndRepairBrokenWearable(WearableType type, IInventoryService invService, UUID userID,AvatarAppearance appearance)
{
UUID defaultwearable = GetDefaultItem(type);
if (defaultwearable != UUID.Zero)
{
UUID newInvItem = UUID.Random();
InventoryItemBase itembase = new InventoryItemBase(newInvItem, userID)
{
AssetID = defaultwearable,
AssetType = (int)FolderType.BodyPart,
CreatorId = userID.ToString(),
//InvType = (int)InventoryType.Wearable,
Description = "Failed Wearable Replacement",
Folder = invService.GetFolderForType(userID, FolderType.BodyPart).ID,
Flags = (uint) type, Name = Enum.GetName(typeof (WearableType), type),
BasePermissions = (uint) PermissionMask.Copy,
CurrentPermissions = (uint) PermissionMask.Copy,
EveryOnePermissions = (uint) PermissionMask.Copy,
GroupPermissions = (uint) PermissionMask.Copy,
NextPermissions = (uint) PermissionMask.Copy
};
invService.AddItem(itembase);
UUID LinkInvItem = UUID.Random();
itembase = new InventoryItemBase(LinkInvItem, userID)
{
AssetID = newInvItem,
AssetType = (int)AssetType.Link,
CreatorId = userID.ToString(),
InvType = (int) InventoryType.Wearable,
Description = "Failed Wearable Replacement",
Folder = invService.GetFolderForType(userID, FolderType.CurrentOutfit).ID,
Flags = (uint) type,
Name = Enum.GetName(typeof (WearableType), type),
BasePermissions = (uint) PermissionMask.Copy,
CurrentPermissions = (uint) PermissionMask.Copy,
EveryOnePermissions = (uint) PermissionMask.Copy,
GroupPermissions = (uint) PermissionMask.Copy,
NextPermissions = (uint) PermissionMask.Copy
};
invService.AddItem(itembase);
appearance.Wearables[(int)type] = new AvatarWearable(newInvItem, GetDefaultItem(type));
ScenePresence presence = null;
if (m_scene.TryGetScenePresence(userID, out presence))
{
m_scene.SendInventoryUpdate(presence.ControllingClient,
invService.GetFolderForType(userID, FolderType.CurrentOutfit), false, true);
}
}
}
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);
}
protected 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);
}
}
/// <summary>
/// Add a new item to the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully added</returns>
public bool AddItem(InventoryItemBase item)
{
return(m_InventoryService.AddItem(item));
}
public void TestUpdateItem()
{
TestHelpers.InMethod();
// TestHelpers.EnableLogging();
string creatorId = TestHelpers.ParseTail(0x1).ToString();
UUID ownerId = TestHelpers.ParseTail(0x2);
UUID itemId = TestHelpers.ParseTail(0x10);
UUID assetId = TestHelpers.ParseTail(0x20);
UUID folderId = TestHelpers.ParseTail(0x30);
int invType = (int)InventoryType.Animation;
int assetType = (int)AssetType.Animation;
string itemName = "item1";
string itemName2 = "item2";
IInventoryService xis = CreateXInventoryService();
InventoryItemBase itemToStore
= new InventoryItemBase(itemId, ownerId)
{
CreatorIdentification = creatorId.ToString(),
AssetID = assetId,
Name = itemName,
Folder = folderId,
InvType = invType,
AssetType = assetType
};
Assert.That(xis.AddItem(itemToStore), Is.True);
// Normal update
itemToStore.Name = itemName2;
Assert.That(xis.UpdateItem(itemToStore), Is.True);
InventoryItemBase itemRetrieved = xis.GetItem(UUID.Zero, itemId);
Assert.That(itemRetrieved, Is.Not.Null);
Assert.That(itemRetrieved.Name, Is.EqualTo(itemName2));
// Attempt to update properties that should never change
string creatorId2 = TestHelpers.ParseTail(0x7).ToString();
UUID ownerId2 = TestHelpers.ParseTail(0x8);
UUID folderId2 = TestHelpers.ParseTail(0x70);
int invType2 = (int)InventoryType.CallingCard;
int assetType2 = (int)AssetType.CallingCard;
string itemName3 = "item3";
itemToStore.CreatorIdentification = creatorId2.ToString();
itemToStore.Owner = ownerId2;
itemToStore.Folder = folderId2;
itemToStore.InvType = invType2;
itemToStore.AssetType = assetType2;
itemToStore.Name = itemName3;
Assert.That(xis.UpdateItem(itemToStore), Is.True);
itemRetrieved = xis.GetItem(itemRetrieved.Owner, itemRetrieved.ID);
Assert.That(itemRetrieved, Is.Not.Null);
Assert.That(itemRetrieved.CreatorId, Is.EqualTo(creatorId));
Assert.That(itemRetrieved.Owner, Is.EqualTo(ownerId));
Assert.That(itemRetrieved.AssetID, Is.EqualTo(assetId));
Assert.That(itemRetrieved.Folder, Is.EqualTo(folderId));
Assert.That(itemRetrieved.InvType, Is.EqualTo(invType));
Assert.That(itemRetrieved.AssetType, Is.EqualTo(assetType));
Assert.That(itemRetrieved.Name, Is.EqualTo(itemName3));
}
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);
}
