1014 lines
42 KiB
Python
1014 lines
42 KiB
Python
# standard python libs
|
|
from logging import getLogger, CRITICAL, ERROR, WARNING, INFO, DEBUG
|
|
import re
|
|
|
|
# related
|
|
import uuid
|
|
import struct
|
|
from indra.base import llsd
|
|
|
|
# pyogp
|
|
from pyogp.lib.base.settings import Settings
|
|
from pyogp.lib.base.message.packets import *
|
|
from pyogp.lib.base.datatypes import *
|
|
from pyogp.lib.base.exc import *
|
|
|
|
# pyogp utilities
|
|
from pyogp.lib.base.utilities.enums import ImprovedIMDialogue
|
|
|
|
# initialize logging
|
|
logger = getLogger('pyogp.lib.base.inventory')
|
|
log = logger.log
|
|
|
|
# ToDo: handle library inventory properly. right now, it's treated as regular inv. store it in self.library_folders
|
|
|
|
class Inventory(object):
|
|
""" is an inventory container
|
|
|
|
Initialize the event queue client class
|
|
>>> inventory = Inventory()
|
|
|
|
Sample implementations: agent.py
|
|
Tests: tests/test_inventory.py
|
|
"""
|
|
|
|
def __init__(self, agent = None, settings = None):
|
|
""" set up the inventory manager """
|
|
|
|
# allow the settings to be passed in
|
|
# otherwise, grab the defaults
|
|
if settings != None:
|
|
self.settings = settings
|
|
else:
|
|
from pyogp.lib.base.settings import Settings
|
|
self.settings = Settings()
|
|
|
|
self.agent = agent
|
|
|
|
# For now, store the inventory contents in a list
|
|
# of folders with it's contents list containing it's inventory items
|
|
# Ditto the library
|
|
|
|
self.folders = []
|
|
self.library_folders = []
|
|
|
|
# the root inventory and library root folder are special cases
|
|
self.inventory_root = None
|
|
self.library_root = None
|
|
|
|
if self.settings.LOG_VERBOSE: log(INFO, "Initializing inventory storage")
|
|
|
|
def enable_callbacks(self):
|
|
""" enable monitors for certain inventory related packet events """
|
|
|
|
onInventoryDescendents_received = self.agent.region.packet_handler._register('InventoryDescendents')
|
|
onInventoryDescendents_received.subscribe(self.onInventoryDescendents)
|
|
|
|
onFetchInventoryReply_received = self.agent.region.packet_handler._register('FetchInventoryReply')
|
|
onFetchInventoryReply_received.subscribe(self.onFetchInventoryReply)
|
|
|
|
onBulkUpdateInventory_received = self.agent.region.packet_handler._register('BulkUpdateInventory')
|
|
onBulkUpdateInventory_received.subscribe(self.onBulkUpdateInventory)
|
|
|
|
def onInventoryDescendents(self, packet):
|
|
|
|
raise NotImplemented("onInventoryDescendents")
|
|
|
|
def onFetchInventoryReply(self, packet):
|
|
|
|
raise NotImplemented("onFetchInventoryReply")
|
|
|
|
def onBulkUpdateInventory(self, packet):
|
|
""" handle the inventory data being delivered in the BullkUpdateInventory packet """
|
|
|
|
for FolderData_block in packet.message_data.blocks['FolderData']:
|
|
|
|
_FolderID = FolderData_block.get_variable('FolderID').data
|
|
_ParentID = FolderData_block.get_variable('ParentID').data
|
|
_Type = FolderData_block.get_variable('Type').data
|
|
_Name = FolderData_block.get_variable('Name').data
|
|
|
|
folder = InventoryFolder( _Name, _FolderID, _ParentID, None, _Type)
|
|
|
|
self._store_inventory_folder(folder)
|
|
|
|
for ItemData_block in packet.message_data.blocks['ItemData']:
|
|
|
|
# what is CallbackID??? not doing anything with it.
|
|
|
|
_ItemID = ItemData_block.get_variable('ItemID').data
|
|
_FolderID = ItemData_block.get_variable('FolderID').data
|
|
_CreatorID = ItemData_block.get_variable('CreatorID').data
|
|
_OwnerID = ItemData_block.get_variable('OwnerID').data
|
|
_GroupID = ItemData_block.get_variable('GroupID').data
|
|
_BaseMask = ItemData_block.get_variable('BaseMask').data
|
|
_OwnerMask = ItemData_block.get_variable('OwnerMask').data
|
|
_GroupMask = ItemData_block.get_variable('GroupMask').data
|
|
_EveryoneMask = ItemData_block.get_variable('EveryoneMask').data
|
|
_NextOwnerMask = ItemData_block.get_variable('NextOwnerMask').data
|
|
_GroupOwned = ItemData_block.get_variable('GroupOwned').data
|
|
_AssetID = ItemData_block.get_variable('AssetID').data
|
|
_Type = ItemData_block.get_variable('Type').data
|
|
_InvType = ItemData_block.get_variable('InvType').data
|
|
_Flags = ItemData_block.get_variable('Flags').data
|
|
_SaleType = ItemData_block.get_variable('SaleType').data
|
|
_SalePrice = ItemData_block.get_variable('SalePrice').data
|
|
_Name = ItemData_block.get_variable('Name').data
|
|
_Description = ItemData_block.get_variable('Description').data
|
|
_CreationDate = ItemData_block.get_variable('CreationDate').data
|
|
_CRC = ItemData_block.get_variable('CRC').data
|
|
|
|
inventory_item = InventoryItem(_ItemID, _FolderID, _CreatorID, _OwnerID, _GroupID, _BaseMask, _OwnerMask, _GroupMask, _EveryoneMask, _NextOwnerMask, _GroupOwned, _AssetID, _Type, _InvType, _Flags, _SaleType, _SalePrice, _Name, _Description, _CreationDate, _CRC)
|
|
|
|
self._store_inventory_item(inventory_item)
|
|
|
|
def _parse_folders_from_login_response(self):
|
|
""" the login response may contain inventory information, append data to our folders list """
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, 'Parsing the login response for inventory folders')
|
|
|
|
if self.agent.login_response.has_key('inventory-skeleton'):
|
|
[self._store_inventory_folder(folder, 'inventory') for folder in self.agent.login_response['inventory-skeleton']]
|
|
|
|
if self.agent.login_response.has_key('inventory-skel-lib'):
|
|
[self._store_inventory_folder(folder, 'library') for folder in self.agent.login_response['inventory-skel-lib']]
|
|
|
|
def _store_inventory_item(self, inventory_item, destination = 'inventory'):
|
|
""" inventory items comes from packets, or from caps """
|
|
|
|
if destination == 'inventory':
|
|
|
|
container = self.folders
|
|
|
|
elif destination == 'library':
|
|
|
|
container = self.library_folders
|
|
|
|
else:
|
|
|
|
log(WARNING, 'Not storing folder data, as it\'s not bound for a valid destination.')
|
|
return
|
|
|
|
# replace an existing list member, else, append
|
|
# for now, we are assuming the parent folder exists.
|
|
# if it doesn't we'll know via traceback
|
|
|
|
index = [container.index(folder) for folder in container if str(folder.FolderID) == str(inventory_item.FolderID)]
|
|
|
|
# did not find a folder for this item
|
|
# this is probably a case we are not handling correctly
|
|
if len(index) == 0:
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, 'Did not find parent folder %s for Inventory Item %s: %s' % (inventory_item.ItemID, inventory_item.FolderID, inventory_item.Name))
|
|
return
|
|
|
|
try:
|
|
|
|
inventory_index = [container[index].index(item) for item in container[index].inventory]
|
|
|
|
container[index[0]].inventory[inventory_index[0]] = inventory_item
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, 'Replacing a stored inventory item: %s for agent \'%s\'' % (inventory_item.ItemID, self.agent.agent_id))
|
|
|
|
except:
|
|
|
|
container[index[0]].inventory.append(inventory_item)
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, 'Storing a new inventory item: %s in agent \'%s\'' % (inventory_item.ItemID, self.agent.agent_id))
|
|
|
|
def search_inventory(self, folder_list = [], item_id = None, name = None, match_list = []):
|
|
""" search through all inventory folders for an id(uuid) or Name, and
|
|
return a list of matching InventoryItems or InventoryFolders
|
|
|
|
recursive search, based on folder_id. if no folder id is specified
|
|
look through everything in self.folders
|
|
|
|
This does not request inventory from the grid. It could, were we to go about enabling this...
|
|
"""
|
|
|
|
# search our inventory storage if we aren't told what to look in
|
|
if folder_list == []:
|
|
search_folders = self.folders
|
|
else:
|
|
search_folders = folder_list
|
|
|
|
if item_id != None:
|
|
|
|
item_id = UUID(str(item_id))
|
|
|
|
for item in search_folders:
|
|
|
|
if isinstance(item, InventoryItem):
|
|
if str(item.ItemID) == str(item_id):
|
|
match_list.append(item)
|
|
|
|
elif isinstance(item, InventoryFolder):
|
|
matches = self.search_inventory_folder(item.FolderID, _id = item_id)
|
|
match_list.extend(matches)
|
|
|
|
return match_list
|
|
|
|
elif name != None:
|
|
|
|
for item in search_folders:
|
|
|
|
pattern = re.compile(name)
|
|
|
|
if isinstance(item, InventoryItem):
|
|
if pattern.match(item.Name):
|
|
match_list.append(item)
|
|
|
|
elif isinstance(item, InventoryFolder):
|
|
matches = self.search_inventory_folder(item.FolderID, name = name.strip())
|
|
match_list.extend(matches)
|
|
|
|
return match_list
|
|
|
|
else:
|
|
|
|
# return an empty list
|
|
return []
|
|
|
|
def search_inventory_folder(self, folder_id, _id = None, name = None):
|
|
""" search an inventory folder for _id or name
|
|
|
|
return a list of matches
|
|
"""
|
|
|
|
match_list = []
|
|
|
|
search_folder = [folder for folder in self.folders if str(folder.FolderID) == str(folder_id)][0]
|
|
|
|
for item in search_folder.inventory:
|
|
|
|
if _id != None:
|
|
|
|
if isinstance(item, InventoryItem):
|
|
if str(item.ItemID) == str(_id):
|
|
match_list.append(item)
|
|
|
|
elif isinstance(item, InventoryFolder):
|
|
if item.FolderID== _id:
|
|
match_list.append(item)
|
|
|
|
elif name != None:
|
|
|
|
pattern = re.compile(name)
|
|
|
|
if pattern.match(item.Name):
|
|
match_list.append(item)
|
|
|
|
return match_list
|
|
|
|
def _store_inventory_folder(self, folder_data, destination = 'inventory'):
|
|
""" inventory folder data comes from either packets or login, or from caps. destination is either 'inventory' or 'library' """
|
|
|
|
if destination == 'inventory':
|
|
|
|
container = self.folders
|
|
|
|
elif destination == 'library':
|
|
|
|
container = self.library_folders
|
|
|
|
else:
|
|
|
|
log(WARNING, 'Not storing folder data, as it\'s not bound for a valid destination.')
|
|
return
|
|
|
|
# if it's a dict, we are parsing login response data or a caps response
|
|
# transform to an InventoryFolder() instance and store it if we havne't already stored it, otherwise, update the params
|
|
if type(folder_data) == dict:
|
|
|
|
if folder_data.has_key('category_id'):
|
|
|
|
# this is from caps
|
|
|
|
folder = InventoryFolder(folder_data['name'], folder_data['category_id'], folder_data['parent_id'], folder_data['version'], folder_data['type_default'], folder_data['agent_id'])
|
|
|
|
else:
|
|
|
|
# this is from login inv skeleton
|
|
|
|
folder = InventoryFolder(folder_data['name'], folder_data['folder_id'], folder_data['parent_id'], folder_data['version'], folder_data['type_default'])
|
|
|
|
elif isinstance(folder_data, InventoryFolder):
|
|
|
|
folder = folder_data
|
|
|
|
# see if we have already stored this folder
|
|
index = [container.index(target_folder) for target_folder in container if str(folder.FolderID) == str(target_folder.FolderID)]
|
|
|
|
# skip storing folders we already know about
|
|
if len(index) == 1:
|
|
|
|
# we may be receiving an update to the folder attributes, if so, save off the contents, swap in the new representation, then append the contents
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, 'Replacing a stored inventory folder: %s for agent \'%s\'' % (folder.FolderID, self.agent.agent_id))
|
|
|
|
contents = container[index[0]].inventory
|
|
|
|
container[index[0]] = folder
|
|
|
|
container[index[0]].inventory = contents
|
|
|
|
else:
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, "Storing inventory folder %s" % (folder.Name))
|
|
|
|
if folder_data['parent_id'] == '00000000-0000-0000-0000-000000000000' and folder_data['name'] == 'My Inventory':
|
|
|
|
self.inventory_root = folder
|
|
|
|
elif folder_data['parent_id'] == '00000000-0000-0000-0000-000000000000' and folder_data['name'] == 'Library':
|
|
|
|
self.library_root = folder
|
|
|
|
container.append(folder)
|
|
|
|
def display_folder_contents(self, folder_id = None):
|
|
""" returns a list of the local representation of a folder's contents """
|
|
|
|
if folder_id != None:
|
|
|
|
return [member for member in self.folders if str(member.ParentID) == str(folder_id)]
|
|
|
|
# the name case is not handled at this time
|
|
'''
|
|
elif name != None:
|
|
|
|
folder_ids = [member.folder_id for member in self.contents if member.name == name]
|
|
|
|
return [member for member in self.contents if member.name == name]
|
|
'''
|
|
|
|
def request_known_folder_contents(self, folder_id = None):
|
|
""" send requests to the server for contents of all known folders """
|
|
|
|
[self.inventory._request_folder_contents(folder.FolderID) for folder in self.inventory.folders if str(folder.ParentID) == str(self.inventory.inventory_root.FolderID)]
|
|
|
|
def _request_folder_contents(self, folder_id = None, source = 'inventory'):
|
|
""" send a request to the server for folder contents, wraps sendFetchInventoryDescendentsPacket """
|
|
|
|
if source == 'inventory':
|
|
|
|
self.sendFetchInventoryDescendentsRequest(folder_id = folder_id)
|
|
|
|
elif source == 'library':
|
|
|
|
self.sendFetchLibDescendentsRequest(folder_id = folder_id)
|
|
|
|
def request_inventory_by_id(self, id_list = None):
|
|
""" ask for inventory data by id via a list """
|
|
|
|
if id_list != None:
|
|
|
|
packet = FetchInventoryPacket()
|
|
|
|
# AgentData block
|
|
packet.AgentData['AgentID'] = self.agent.agent_id # MVT_LLUUID
|
|
packet.AgentData['SessionID'] = self.agent.session_id # MVT_LLUUID
|
|
|
|
for inventory_id in id_list:
|
|
|
|
InventoryData = {}
|
|
InventoryData['OwnerID'] = self.agent.agent_id # MVT_LLUUID
|
|
InventoryData['ItemID'] = inventory_id # MVT_LLUUID
|
|
|
|
packet.InventoryDataBlocks.append(InventoryData)
|
|
|
|
# enqueue the message
|
|
self.region.enqueue_message(packet())
|
|
|
|
def give_inventory(self, ItemID = None, agent_id = None):
|
|
""" offers another agent the specified inventory item
|
|
|
|
searches the local inventory for the specified ItemID
|
|
given a match, sends an ImprovedInventoryMessage packet to the specified AgentID
|
|
"""
|
|
|
|
if not (ItemID or agent_id):
|
|
log(WARNING, "ItemID and agent_id are required in Inventory().give_inventory()")
|
|
return
|
|
|
|
item_id = self.search_inventory(item_id = ItemID)
|
|
|
|
if item_id == []:
|
|
log(WARNING, "ItemID %s not found in inventory of %s" % (ItemID, self.agent.Name()))
|
|
return
|
|
elif len(item_id) > 1:
|
|
log(WARNING, "Multiple matches in inventory for ItemID %s, using the first one in Inventory().give_inventory()" % (ItemID))
|
|
|
|
inv_item = item_id[0]
|
|
|
|
inv_item.give(self.agent, agent_id)
|
|
|
|
def handle_inventory_offer(self, packet):
|
|
""" parses and handles an incoming inventory offer """
|
|
|
|
FromAgentID = packet.message_data.blocks['AgentData'][0].get_variable('AgentID').data
|
|
FromAgentName = packet.message_data.blocks['MessageBlock'][0].get_variable('FromAgentName').data
|
|
InventoryName = packet.message_data.blocks['MessageBlock'][0].get_variable('Message').data
|
|
ID = packet.message_data.blocks['MessageBlock'][0].get_variable('ID').data
|
|
Message = packet.message_data.blocks['MessageBlock'][0].get_variable('Message').data
|
|
ToAgentID = packet.message_data.blocks['MessageBlock'][0].get_variable('ToAgentID').data
|
|
|
|
BinaryBucket = packet.message_data.blocks['MessageBlock'][0].get_variable('BinaryBucket').data
|
|
|
|
# parse the binary bucket
|
|
AssetType = struct.unpack(">b", BinaryBucket[0:1])[0]
|
|
ItemID = UUID(BinaryBucket[1:17])
|
|
|
|
if str(FromAgentID) == str(self.agent.agent_id):
|
|
|
|
log(INFO, "%s offered inventory to %s" % (self.agent.Name(), ToAgentID))
|
|
|
|
else:
|
|
|
|
log(INFO, "%s received an inventory offer from %s for %s." % (self.agent.Name(), FromAgentName, InventoryName))
|
|
|
|
if self.settings.LOG_VERBOSE: log(DEBUG, "Inventory offer data. \n\tFromAgentID: %s \n\tFromAgentName: %s \n\tInventoryName: %s \n\tID: %s \n\tAssetType: %s \n\tItemID: %s \n\tMessage: %s" % (FromAgentID, FromAgentName, InventoryName, ID, AssetType, ItemID, Message))
|
|
|
|
if self.agent.settings.ACCEPT_INVENTORY_OFFERS:
|
|
|
|
accept = True
|
|
|
|
else:
|
|
|
|
accept = False
|
|
|
|
self.confirm_inventory_offer(FromAgentID, FromAgentName, InventoryName, ID, AssetType, ItemID, accept)
|
|
|
|
def confirm_inventory_offer(self, FromAgentID, FromAgentName, InventoryName, ID, AssetType, ItemID, accept):
|
|
""" sends an ImprovedInstantMessage packet accepting or declining an inventory offer """
|
|
|
|
if accept:
|
|
accept_key = ImprovedIMDialogue.InventoryAccepted
|
|
log(INFO, "Sending an inventory accepted message to %s for item %s(%s)" % (FromAgentName, InventoryName, ID))
|
|
else:
|
|
accept_key = ImprovedIMDialogue.InventoryDeclined
|
|
log(INFO, "Sending an inventory declined message to %s for item %s(%s)" % (FromAgentName, InventoryName, ID))
|
|
|
|
self.agent.send_ImprovedInstantMessage(self.agent.agent_id, self.agent.session_id, 0, FromAgentID, 0, UUID(), self.agent.Position, 0, accept_key, ID, 0, self.agent.Name(), '', '')
|
|
|
|
def sendFetchInventoryDescendentsRequest(self, folder_id = None):
|
|
""" send a request to the grid for folder contents """
|
|
|
|
raise NotImplemented("sendFetchInventoryDescendentsRequest")
|
|
|
|
def sendFetchInventoryRequest(self, folder_id = None):
|
|
""" send a request to the grid for inventory items in folder """
|
|
|
|
raise NotImplemented("sendFetchInventoryRequest")
|
|
|
|
def sendFetchLibRequest(self, item_id = None):
|
|
""" send a request to the grid for library items """
|
|
|
|
raise NotImplemented("sendFetchLibRequest")
|
|
|
|
def sendFetchLibDescendentsRequest(self, item_id = None):
|
|
""" send a request to the grid for library folder contents """
|
|
|
|
raise NotImplemented("sendFetchDescendentsRequest")
|
|
|
|
class AIS(Inventory):
|
|
""" AIS specific inventory manager """
|
|
|
|
def __init__(self, agent, capabilities, settings = None):
|
|
|
|
super(AIS, self).__init__(agent, settings)
|
|
|
|
self.capabilities = capabilities
|
|
|
|
def sendFetchInventoryRequest(self, item_ids = []):
|
|
""" send a request to the grid for inventory item attributes """
|
|
|
|
if len(item_ids) == 0:
|
|
log(WARNING, "sendFetchInventoryRequest requires > 0 item_ids, 0 passed in")
|
|
return
|
|
elif type(item_ids) != list:
|
|
log(WARNING, "sendFetchInventoryRequest requires a list of item_ids, %s passed in" % (type(item_ids)))
|
|
return
|
|
|
|
cap = self.capabilities['FetchInventory']
|
|
|
|
post_body = {'items': [{'item_id': str(item_id)} for item_id in item_ids]}
|
|
|
|
custom_headers={'Accept' : 'application/llsd+xml'}
|
|
|
|
try:
|
|
result = cap.POST(post_body, custom_headers)
|
|
except ResourceError, error:
|
|
log(ERROR, error)
|
|
return
|
|
except ResourceNotFound, error:
|
|
log(ERROR, "404 calling: %s" % (error))
|
|
return
|
|
|
|
for item in response['folders']:
|
|
|
|
self._store_caps_items(item, folder_id)
|
|
|
|
def sendFetchLibRequest(self, folder_id, item_ids = []):
|
|
""" send a request to the grid for library item attributes """
|
|
|
|
if len(item_ids) == 0:
|
|
log(WARNING, "sendFetchLibRequest requires > 0 item_ids, 0 passed in")
|
|
return
|
|
elif type(item_ids) != list:
|
|
log(WARNING, "sendFetchLibRequest a list of item_ids, %s passed in" % (type(item_ids)))
|
|
return
|
|
|
|
cap = self.capabilities['FetchLib']
|
|
|
|
post_body = {'items': [{'item_id': str(item_id)} for item_id in item_ids]}
|
|
|
|
custom_headers={'Accept' : 'application/llsd+xml'}
|
|
|
|
try:
|
|
result = cap.POST(post_body, custom_headers)
|
|
except ResourceError, error:
|
|
log(ERROR, error)
|
|
return
|
|
except ResourceNotFound, error:
|
|
log(ERROR, "404 calling: %s" % (error))
|
|
return
|
|
|
|
for item in response['folders']:
|
|
|
|
self._store_caps_items(item, folder_id, 'library')
|
|
|
|
def sendFetchInventoryDescendentsRequest(self, folder_id):
|
|
""" send a request to the server for inventory folder contents """
|
|
|
|
cap = self.capabilities['WebFetchInventoryDescendents']
|
|
|
|
post_body = {'folders': [{'folder_id': str(folder_id), 'owner_id': str(self.agent.agent_id)}]}
|
|
|
|
custom_headers={'Accept' : 'application/llsd+xml'}
|
|
|
|
try:
|
|
response = cap.POST(post_body, custom_headers)
|
|
except ResourceError, error:
|
|
log(ERROR, error)
|
|
return
|
|
except ResourceNotFound, error:
|
|
log(ERROR, "404 calling: %s" % (error))
|
|
return
|
|
|
|
'''
|
|
Response shape
|
|
|
|
{'folders':[ {'category': CATEGORY_SHAPE,
|
|
'categories': [CATEGORY_SHAPE,],
|
|
'items': [ITEM_SHAPE,] }]}
|
|
'''
|
|
|
|
for member in response['folders']:
|
|
|
|
if member.has_key('category'):
|
|
self._store_inventory_folder(member['category'])
|
|
|
|
if member.has_key('categories'):
|
|
[self._store_inventory_folder(folder_info) for folder_info in member['categories']]
|
|
|
|
# pass a tuple of (item_info, category_id)
|
|
if member.has_key('items'):
|
|
self._store_caps_items(member['items'], member['category']['category_id'])
|
|
|
|
def _store_caps_items(self, items, folder_id, destination = 'inventory'):
|
|
""" transform an AIS caps response's inventory items and folder_id to InventoryItems and store it """
|
|
|
|
for item in items:
|
|
inventory_item = InventoryItem(item['item_id'], folder_id, item['permissions']['creator_id'], item['permissions']['owner_id'], item['permissions']['group_id'], item['permissions']['base_mask'], item['permissions']['owner_mask'], item['permissions']['group_mask'], item['permissions']['everyone_mask'], item['permissions']['next_owner_mask'], None, item['asset_id'], item['type'], item['inv_type'], item['flags'], item['sale_info']['sale_type'], item['sale_info']['sale_price'], item['name'], item['desc'], item['created_at'], None, item['permissions']['last_owner_id'])
|
|
|
|
self._store_inventory_item(inventory_item, destination)
|
|
|
|
def sendFetchLibDescendentsRequest(self, folder_id):
|
|
""" send a request to the server for folder contents """
|
|
|
|
cap = self.capabilities['FetchLibDescendents']
|
|
|
|
post_body = {'folders': [{'folder_id': str(folder_id), 'owner_id': self.settings.ALEXANDRIA_LINDEN}]}
|
|
|
|
custom_headers={'Accept' : 'application/llsd+xml'}
|
|
|
|
try:
|
|
response = cap.POST(post_body, custom_headers)
|
|
except ResourceError, error:
|
|
log(ERROR, error)
|
|
return
|
|
except ResourceNotFound, error:
|
|
log(ERROR, "404 calling: %s" % (error))
|
|
return
|
|
|
|
'''
|
|
Response shape
|
|
|
|
{'folders':[ {'category': CATEGORY_SHAPE,
|
|
'categories': [CATEGORY_SHAPE,],
|
|
'items': [ITEM_SHAPE,] }]}
|
|
'''
|
|
|
|
for member in response['folders']:
|
|
|
|
if member.has_key('category'):
|
|
self._store_inventory_folder(member['category'], 'library')
|
|
|
|
if member.has_key('categories'):
|
|
[self._store_inventory_folder(folder_info, 'library') for folder_info in member['categories']]
|
|
|
|
if member.has_key('items'):
|
|
self._store_caps_items(member['items'], member['category']['category_id'], 'library')
|
|
|
|
|
|
class UDP_Inventory(Inventory):
|
|
|
|
def __init__(self, agent, settings = None):
|
|
|
|
super(UDP_Inventory, self).__init__(agent, settings)
|
|
|
|
def sendFetchInventoryRequest(self, folder_id = None):
|
|
""" send a request to the grid for folder attributes """
|
|
|
|
raise NotImplemented("sendFetchInventoryRequest")
|
|
|
|
def sendFetchLibRequest(self, item_id = None):
|
|
""" send a request to the grid for library items """
|
|
|
|
raise NotImplemented("sendFetchInventoryRequest")
|
|
|
|
def sendFetchInventoryDescendentsRequest(self, folder_id = None):
|
|
""" send a request to the grid for folder contents """
|
|
|
|
# the name case is not handled at this time
|
|
packet = FetchInventoryDescendentsPacket()
|
|
|
|
# AgentData block
|
|
packet.AgentData['AgentID'] = self.agent.agent_id # MVT_LLUUID
|
|
packet.AgentData['SessionID'] = self.agent.session_id # MVT_LLUUID
|
|
|
|
# InventoryData block
|
|
packet.InventoryData['FolderID'] = UUID(str(folder_id)) # MVT_LLUUID
|
|
packet.InventoryData['OwnerID'] = self.agent.agent_id # MVT_LLUUID
|
|
packet.InventoryData['SortOrder'] = 0 # MVT_S32, 0 = name, 1 = time
|
|
packet.InventoryData['FetchFolders'] = True # MVT_BOOL
|
|
packet.InventoryData['FetchItems'] = True # MVT_BOOL
|
|
|
|
self.agent.region.enqueue_message(packet())
|
|
|
|
def sendFetchLibDescendentsRequest(self, folder_id = None):
|
|
""" send a request to the grid for library items """
|
|
|
|
raise NotImplemented("sendFetchInventoryRequest")
|
|
|
|
def onFetchInventoryReply(self, packet):
|
|
|
|
_agent_id = packet.message_data.blocks['AgentData'][0].get_variable('AgentID')
|
|
|
|
for InventoryData_block in packet.message_data.blocks['InventoryData']:
|
|
|
|
_ItemID = InventoryData_block.get_variable('ItemID').data
|
|
_FolderID = InventoryData_block.get_variable('FolderID').data
|
|
_CreatorID = InventoryData_block.get_variable('CreatorID').data
|
|
_OwnerID = InventoryData_block.get_variable('OwnerID').data
|
|
_GroupID = InventoryData_block.get_variable('GroupID').data
|
|
_BaseMask = InventoryData_block.get_variable('BaseMask').data
|
|
_OwnerMask = InventoryData_block.get_variable('OwnerMask').data
|
|
_GroupMask = InventoryData_block.get_variable('GroupMask').data
|
|
_EveryoneMask = InventoryData_block.get_variable('EveryoneMask').data
|
|
_NextOwnerMask = InventoryData_block.get_variable('NextOwnerMask').data
|
|
_GroupOwned = InventoryData_block.get_variable('GroupOwned').data
|
|
_AssetID = InventoryData_block.get_variable('AssetID').data
|
|
_Type = InventoryData_block.get_variable('Type').data
|
|
_InvType = InventoryData_block.get_variable('InvType').data
|
|
_Flags = InventoryData_block.get_variable('Flags').data
|
|
_SaleType = InventoryData_block.get_variable('SaleType').data
|
|
_SalePrice = InventoryData_block.get_variable('SalePrice').data
|
|
_Name = InventoryData_block.get_variable('Name').data
|
|
_Description = InventoryData_block.get_variable('Description').data
|
|
_CreationDate = InventoryData_block.get_variable('CreationDate').data
|
|
_CRC = InventoryData_block.get_variable('CRC').data
|
|
|
|
inventory_item = InventoryItem(_ItemID, _FolderID, _CreatorID, _OwnerID, _GroupID, _BaseMask, _OwnerMask, _GroupMask, _EveryoneMask, _NextOwnerMask, _GroupOwned, _AssetID, _Type, _InvType, _Flags, _SaleType, _SalePrice, _Name, _Description, _CreationDate, _CRC)
|
|
|
|
self._store_inventory_item(inventory_item)
|
|
|
|
def onInventoryDescendents(self, packet):
|
|
|
|
if packet.message_data.blocks['AgentData'][0].get_variable('Descendents') > 0:
|
|
|
|
_agent_id = packet.message_data.blocks['AgentData'][0].get_variable('AgentID')
|
|
_folder_id = packet.message_data.blocks['AgentData'][0].get_variable('FolderID')
|
|
_owner_id = packet.message_data.blocks['AgentData'][0].get_variable('OwnerID')
|
|
_version = packet.message_data.blocks['AgentData'][0].get_variable('Version')
|
|
_descendents = packet.message_data.blocks['AgentData'][0].get_variable('Descendents')
|
|
# _descendents is not dealt with in any way here
|
|
|
|
|
|
if str(packet.message_data.blocks['ItemData'][0].get_variable('ItemID').data) != str(UUID()):
|
|
|
|
for ItemData_block in packet.message_data.blocks['ItemData']:
|
|
|
|
_ItemID = ItemData_block.get_variable('ItemID').data
|
|
_FolderID = ItemData_block.get_variable('FolderID').data
|
|
_CreatorID = ItemData_block.get_variable('CreatorID').data
|
|
_OwnerID = ItemData_block.get_variable('OwnerID').data
|
|
_GroupID = ItemData_block.get_variable('GroupID').data
|
|
_BaseMask = ItemData_block.get_variable('BaseMask').data
|
|
_OwnerMask = ItemData_block.get_variable('OwnerMask').data
|
|
_GroupMask = ItemData_block.get_variable('GroupMask').data
|
|
_EveryoneMask = ItemData_block.get_variable('EveryoneMask').data
|
|
_NextOwnerMask = ItemData_block.get_variable('NextOwnerMask').data
|
|
_GroupOwned = ItemData_block.get_variable('GroupOwned').data
|
|
_AssetID = ItemData_block.get_variable('AssetID').data
|
|
_Type = ItemData_block.get_variable('Type').data
|
|
_InvType = ItemData_block.get_variable('InvType').data
|
|
_Flags = ItemData_block.get_variable('Flags').data
|
|
_SaleType = ItemData_block.get_variable('SaleType').data
|
|
_SalePrice = ItemData_block.get_variable('SalePrice').data
|
|
_Name = ItemData_block.get_variable('Name').data
|
|
_Description = ItemData_block.get_variable('Description').data
|
|
_CreationDate = ItemData_block.get_variable('CreationDate').data
|
|
_CRC = ItemData_block.get_variable('CRC').data
|
|
|
|
inventory_item = InventoryItem(_ItemID, _FolderID, _CreatorID, _OwnerID, _GroupID, _BaseMask, _OwnerMask, _GroupMask, _EveryoneMask, _NextOwnerMask, _GroupOwned, _AssetID, _Type, _InvType, _Flags, _SaleType, _SalePrice, _Name, _Description, _CreationDate, _CRC)
|
|
|
|
self._store_inventory_item(inventory_item)
|
|
|
|
if str(packet.message_data.blocks['FolderData'][0].get_variable('FolderID').data) != str(UUID()):
|
|
|
|
for FolderData_block in packet.message_data.blocks['FolderData']:
|
|
|
|
_FolderID = FolderData_block.get_variable('FolderID').data
|
|
_ParentID = FolderData_block.get_variable('ParentID').data
|
|
_Type = FolderData_block.get_variable('Type').data
|
|
_Name = FolderData_block.get_variable('Name').data
|
|
|
|
folder = InventoryFolder( _Name, _FolderID, _ParentID, None, _Type, _agent_id)
|
|
|
|
self._store_inventory_folder(folder)
|
|
|
|
class InventoryFolder(object):
|
|
""" represents an Inventory folder
|
|
|
|
Initialize the event queue client class
|
|
>>> inventoryfolder = InventoryFolder()
|
|
|
|
Sample implementations: inventory.py
|
|
Tests: tests/test_inventory.py
|
|
"""
|
|
|
|
def __init__(self, Name = None, FolderID = None, ParentID = None, Version = None, Type = None, AgentID = UUID(), Descendents = 0):
|
|
""" initialize the inventory folder """
|
|
|
|
self.type = 'InventoryFolder'
|
|
|
|
self.Name = Name
|
|
self.FolderID = UUID(str(FolderID))
|
|
self.ParentID = UUID(str(ParentID))
|
|
self.Version = Version
|
|
self.Type = Type
|
|
self.Descendents = Descendents
|
|
self.AgentID = UUID(str(AgentID))
|
|
|
|
self.inventory = []
|
|
|
|
def purge_descendents(self, agent):
|
|
""" removes inventory from this folder, by unlinking the inventory from this parent folder """
|
|
|
|
packet = PurgeInventoryDescendentsPacket()
|
|
|
|
packet.AgentData['AgentID'] = agent.agent_id
|
|
packet.AgentData['SessionID'] = agent.session_id
|
|
|
|
packet.InventoryData['FolderID'] = self.FolderID
|
|
|
|
agent.region.enqueue_message(packet)
|
|
|
|
def move(self, agent, parent_id, restamp = False):
|
|
""" reparents this inventory folder """
|
|
|
|
packet = MoveInventoryFolderPacket()
|
|
|
|
packet.AgentData['AgentID'] = agent.agent_id
|
|
packet.AgentData['SessionID'] = agent.session_id
|
|
packet.AgentData['Stamp'] = restamp
|
|
|
|
# this packet allows for variable instances of the InventoryData block
|
|
# populate a dict and append to the list
|
|
packet.InventoryData['FolderID'] = self.FolderID
|
|
packet.InventoryData['ParentID'] = UUID(str(parent_id))
|
|
|
|
packet.InventoryDataBlocks.append(packet.InventoryData)
|
|
|
|
agent.region.enqueue_message(packet)
|
|
|
|
def remove(self, agent):
|
|
""" removes this inventory folder """
|
|
|
|
packet = RemoveInventoryFolderPacket()
|
|
|
|
packet.AgentData['AgentID'] = agent.agent_id
|
|
packet.AgentData['SessionID'] = agent.session_id
|
|
packet.AgentData['Stamp'] = restamp
|
|
|
|
# this packet allows for variable instances of the InventoryData block
|
|
# populate a dict and append to the list
|
|
packet.InventoryData['FolderID'] = self.FolderID
|
|
|
|
packet.InventoryDataBlocks.append(packet.InventoryData)
|
|
|
|
agent.region.enqueue_message(packet)
|
|
|
|
class InventoryItem(object):
|
|
""" represents an Inventory item
|
|
|
|
Initialize the InventoryItem class
|
|
>>> inventoryitem = InventoryItem()
|
|
|
|
Sample implementations: inventory.py
|
|
Tests: tests/test_inventory.py
|
|
"""
|
|
|
|
def __init__(self, ItemID = None, FolderID = None, CreatorID = None, OwnerID = None, GroupID = None, BaseMask = None, OwnerMask = None, GroupMask = None, EveryoneMask = None, NextOwnerMask = 0, GroupOwned = None, AssetID = None, Type = None, InvType = None, Flags = None, SaleType = None, SalePrice = None, Name = None, Description = None, CreationDate = None, CRC = None, LastOwnerID = UUID()):
|
|
""" initialize the inventory item """
|
|
|
|
self.type = 'InventoryItem'
|
|
|
|
self.ItemID = UUID(str(ItemID)) # LLUUID
|
|
self.FolderID = UUID(str(FolderID)) # LLUUID
|
|
self.CreatorID = UUID(str(CreatorID)) # LLUUID
|
|
self.OwnerID = UUID(str(OwnerID)) # LLUUID
|
|
self.GroupID = UUID(str(GroupID)) # LLUUID
|
|
self.BaseMask = BaseMask # U32
|
|
self.OwnerMask = OwnerMask # U32
|
|
self.GroupMask = GroupMask # U32
|
|
self.EveryoneMask = EveryoneMask # U32
|
|
self.NextOwnerMask = NextOwnerMask
|
|
self.GroupOwned = GroupOwned # Bool
|
|
self.AssetID = UUID(str(AssetID)) # LLUUID
|
|
self.Type = Type # S8
|
|
self.InvType = InvType # S8
|
|
self.Flags = Flags # U32
|
|
self.SaleType = SaleType # U8
|
|
self.SalePrice = SalePrice # S32
|
|
self.Name = Name # Variable 1
|
|
self.Description = Description # Variable 1
|
|
self.CreationDate = CreationDate # S32
|
|
self.CRC = CRC # U32
|
|
self.LastOwnerID = UUID(str(LastOwnerID))
|
|
|
|
def rez_object(self, agent, relative_position = (1, 0, 0)):
|
|
|
|
# self.agent.Position holds where we are. we need to add this Vector3 to the incoming tuple (vector to a vector)
|
|
location_to_rez_x = agent.Position.X + relative_position[0]
|
|
location_to_rez_y = agent.Position.Y + relative_position[1]
|
|
location_to_rez_z = agent.Position.Z + relative_position[2]
|
|
|
|
location_to_rez = (location_to_rez_x, location_to_rez_y, location_to_rez_z)
|
|
|
|
sendRezObject(agent, self, location_to_rez, location_to_rez)
|
|
|
|
def update(agent, name = None, value = None):
|
|
""" allow arbitraty update to any data in the inventory item
|
|
|
|
accepts a dictionary of key:value pairs which will update the stored inventory items
|
|
and then send an UpdateInventoryItem packet
|
|
"""
|
|
|
|
if self.__dict__.has_key(name):
|
|
self.setattr(self, name, value)
|
|
sendUpdateInventoryItem(agent, [self])
|
|
else:
|
|
raise DataParsingError('Inventory item attribute update failes, no field named \'%s\'' % (name))
|
|
|
|
def give(self, agent, to_agent_id):
|
|
""" sends the target agent an inventory offer of this """
|
|
|
|
# prep variables and send the message
|
|
_AgentID = agent.agent_id
|
|
_SessionID = agent.session_id
|
|
_FromGroup = False
|
|
_ToAgentID = to_agent_id
|
|
_ParentEstateID = 0
|
|
_RegionID = agent.region.RegionID
|
|
_Position = agent.Position
|
|
_Offline = 0
|
|
_Dialog = ImprovedIMDialogue.InventoryOffered
|
|
_ID = uuid.uuid4()
|
|
_Timestamp = 0
|
|
_FromAgentName = agent.Name()
|
|
_Message = self.Name
|
|
_BinaryBucket = struct.pack(">b", self.Type) + self.ItemID.get_bytes() # binary of asset type and id
|
|
|
|
log(INFO, "Sending inventory offer of %s from %s to %s" % (self.Name, agent.agent_id, to_agent_id))
|
|
|
|
agent.send_ImprovedInstantMessage(_AgentID, _SessionID, _FromGroup, _ToAgentID, _ParentEstateID, _RegionID, _Position, _Offline, _Dialog, _ID, _Timestamp, _FromAgentName, _Message, _BinaryBucket)
|
|
|
|
# ~~~~~~~~~~~~~~~
|
|
# Packet Wrappers
|
|
# ~~~~~~~~~~~~~~~
|
|
|
|
def sendUpdateInventoryItem(agent, inventory_items = [], ):
|
|
""" sends an UpdateInventoryItem packet to a region
|
|
|
|
this function expects an already transformed InventoryItem instance
|
|
"""
|
|
|
|
packet - UpdateInventoryItemPacket()
|
|
|
|
packet.AgentData["AgentID"] = agent.agent_id
|
|
packet.AgentData["SessionID"] = agent.session_id
|
|
packet.AgentData["TransactionID"] = UUID()
|
|
|
|
for item in inventory_items:
|
|
|
|
packet.InventoryData['ItemID'] = item.ItemID
|
|
packet.InventoryData['FolderID'] = item.FolderID
|
|
packet.InventoryData['CallbackID'] = UUID()
|
|
packet.InventoryData['CreatorID'] = item.CreatorID
|
|
packet.InventoryData['OwnerID'] = item.OwnerID
|
|
packet.InventoryData['GroupID'] = item.GroupID
|
|
packet.InventoryData['BaseMask'] = item.BaseMask
|
|
packet.InventoryData['OwnerMask'] = item.OwnerMask
|
|
packet.InventoryData['GroupMask'] = item.GroupMask
|
|
packet.InventoryData['EveryoneMask'] = item.EveryoneMask
|
|
packet.InventoryData['NextOwnerMask'] = item.NextOwnerMask
|
|
packet.InventoryData['GroupOwned'] = item.GroupOwned
|
|
packet.InventoryData['TransactionID'] = UUID()
|
|
packet.InventoryData['Type'] = item.Type
|
|
packet.InventoryData['InvType'] = item.InvType
|
|
packet.InventoryData['Flags'] = item.Flags
|
|
packet.InventoryData['SaleType'] = item.SaleType
|
|
packet.InventoryData['SalePrice'] = item.SalePrice
|
|
packet.InventoryData['Name'] = item.Name
|
|
packet.InventoryData['Description'] = item.Description
|
|
packet.InventoryData['CreationDate'] = item.CreationDate
|
|
packet.InventoryData['CRC'] = item.CRC
|
|
|
|
agent.region.enqueue_message(packet())
|
|
|
|
def sendRezObject(agent, inventory_item, RayStart, RayEnd, FromTaskID = UUID(), BypassRaycast = 1, RayTargetID = UUID(), RayEndIsIntersection = False, RezSelected = False, RemoveItem = False, ItemFlags = 0, GroupMask = 0, EveryoneMask = 0, NextOwnerMask = 0):
|
|
""" sends a RezObject packet to a region """
|
|
|
|
packet = RezObjectPacket()
|
|
|
|
packet.AgentData['AgentID'] = agent.agent_id
|
|
packet.AgentData['SessionID'] = agent.session_id
|
|
packet.AgentData['GroupID'] = agent.ActiveGroupID
|
|
|
|
packet.RezData['FromTaskID'] = UUID(str(FromTaskID))
|
|
packet.RezData['BypassRaycast'] = BypassRaycast # ???
|
|
packet.RezData['RayStart'] = RayStart
|
|
packet.RezData['RayEnd'] = RayEnd
|
|
packet.RezData['RayTargetID'] = UUID(str(RayTargetID))
|
|
packet.RezData['RayEndIsIntersection'] = RayEndIsIntersection
|
|
packet.RezData['RezSelected'] = RezSelected
|
|
packet.RezData['RemoveItem'] = RemoveItem
|
|
packet.RezData['ItemFlags'] = ItemFlags
|
|
packet.RezData['GroupMask'] = GroupMask
|
|
packet.RezData['EveryoneMask'] = EveryoneMask
|
|
packet.RezData['NextOwnerMask'] = inventory_item.NextOwnerMask
|
|
|
|
packet.InventoryData['ItemID'] = inventory_item.ItemID
|
|
packet.InventoryData['FolderID'] = inventory_item.FolderID
|
|
packet.InventoryData['CreatorID'] = inventory_item.CreatorID
|
|
packet.InventoryData['OwnerID'] = inventory_item.OwnerID
|
|
packet.InventoryData['GroupID'] = inventory_item.GroupID
|
|
packet.InventoryData['BaseMask'] = inventory_item.BaseMask
|
|
packet.InventoryData['OwnerMask'] = inventory_item.OwnerMask
|
|
packet.InventoryData['GroupMask'] = inventory_item.GroupMask
|
|
packet.InventoryData['EveryoneMask'] = inventory_item.EveryoneMask
|
|
packet.InventoryData['GroupOwned'] = inventory_item.GroupOwned
|
|
packet.InventoryData['TransactionID'] = UUID()
|
|
packet.InventoryData['Type'] = inventory_item.Type
|
|
packet.InventoryData['InvType'] = inventory_item.InvType
|
|
packet.InventoryData['Flags'] = inventory_item.Flags
|
|
packet.InventoryData['SaleType'] = inventory_item.SaleType
|
|
packet.InventoryData['SalePrice'] = inventory_item.SalePrice
|
|
packet.InventoryData['Name'] = inventory_item.Name
|
|
packet.InventoryData['Description'] = inventory_item.Description
|
|
packet.InventoryData['CreationDate'] = inventory_item.CreationDate
|
|
packet.InventoryData['CRC'] = inventory_item.CRC
|
|
packet.InventoryData['NextOwnerMask'] = inventory_item.NextOwnerMask
|
|
|
|
agent.region.enqueue_message(packet())
|
|
|
|
"""
|
|
Contributors can be viewed at:
|
|
http://svn.secondlife.com/svn/linden/projects/2008/pyogp/CONTRIBUTORS.txt
|
|
|
|
$LicenseInfo:firstyear=2008&license=apachev2$
|
|
|
|
Copyright 2009, Linden Research, Inc.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License").
|
|
You may obtain a copy of the License at:
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
or in
|
|
http://svn.secondlife.com/svn/linden/projects/2008/pyogp/LICENSE.txt
|
|
|
|
$/LicenseInfo$
|
|
"""
|
|
|