public InventoryTransferWorkItem(
UUID transactionID,
UGUI dstAgent,
UserAgentServiceInterface dstUserAgentService,
InventoryServiceInterface dstInventoryService,
AssetServiceInterface dstAssetService,
UGUIWithName srcAgent,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
List <UUID> assetids,
TransferInventoryFolder inventoryTree,
IMServiceInterface imService,
Action <UUID> inventoryCreate)
: base(dstAssetService, srcAssetService, assetids, ReferenceSource.Source)
{
m_TransactionID = transactionID;
m_DstUserAgentService = dstUserAgentService;
m_DstInventoryService = dstInventoryService;
m_SrcInventoryService = srcInventoryService;
m_DestinationAgent = dstAgent;
m_InventoryTree = inventoryTree;
m_SrcAgent = srcAgent;
m_IMService = imService;
m_InventoryCreate = inventoryCreate;
}
private static TransferInventoryFolder GetTree(InventoryServiceInterface inventoryService, InventoryFolder baseFolder, List <UUID> assetids)
{
TransferInventoryFolder catBase = new TransferInventoryFolder(baseFolder);
List <TransferInventoryFolder> collect = new List <TransferInventoryFolder>
{
catBase
};
while (collect.Count != 0)
{
InventoryFolderContent content;
TransferInventoryFolder cat = collect[0];
if (inventoryService.Folder.Content.TryGetValue(cat.Owner.ID, cat.ID, out content))
{
foreach (InventoryItem item in content.Items)
{
if (item.AssetType != AssetType.Link && item.AssetType != AssetType.LinkFolder)
{
if (!item.CheckPermissions(cat.Owner, UGI.Unknown, InventoryPermissionsMask.Transfer))
{
return(null);
}
assetids.Add(item.AssetID);
cat.Items.Add(item);
}
}
foreach (InventoryFolder folder in content.Folders)
{
var childFolder = new TransferInventoryFolder(folder);
collect.Add(childFolder);
cat.Folders.Add(childFolder);
}
}
cat.ID = UUID.Random;
collect.RemoveAt(0);
}
return(catBase);
}
public override void AssetTransferComplete()
{
#if DEBUG
m_Log.DebugFormat("Finished transfer {0} to {1}", m_SrcAgent, m_DestinationAgent);
#endif
AssetType assetType = AssetType.Folder;
UUID givenID;
string givenName;
if (m_InventoryTree != null)
{
InventoryFolder folder;
if (!m_DstInventoryService.Folder.TryGetValue(m_DestinationAgent.ID, AssetType.RootFolder, out folder))
{
return;
}
var folderCreator = new List <TransferInventoryFolder>
{
m_InventoryTree
};
m_InventoryTree.ParentFolderID = folder.ID;
m_InventoryTree.Owner = m_DestinationAgent;
m_InventoryTree.Version = 1;
givenID = m_InventoryTree.ID;
givenName = m_InventoryTree.Name;
List <UUID> noCopyItems = new List <UUID>();
while (folderCreator.Count != 0)
{
TransferInventoryFolder transferFolder = folderCreator[0];
m_DstInventoryService.Folder.Add(transferFolder);
foreach (InventoryItem item in transferFolder.Items)
{
if (!item.CheckPermissions(m_SrcAgent, UGI.Unknown, InventoryPermissionsMask.Copy))
{
noCopyItems.Add(item.ID);
}
item.SetNewID(UUID.Random);
item.LastOwner = item.Owner;
item.Owner = m_DestinationAgent;
item.AdjustToNextOwner();
m_DstInventoryService.Item.Add(item);
}
foreach (TransferInventoryFolder childfolder in transferFolder.Folders)
{
childfolder.Owner = m_DestinationAgent;
childfolder.ParentFolderID = transferFolder.ID;
childfolder.Version = 1;
folderCreator.Add(childfolder);
}
}
if (noCopyItems.Count != 0)
{
m_SrcInventoryService.Item.Delete(m_SrcAgent.ID, noCopyItems);
}
}
else
{
InventoryFolder folder;
if (!m_DstInventoryService.Folder.TryGetDefaultFolderOrFallback(m_DestinationAgent.ID, m_Item.AssetType, out folder))
{
#if DEBUG
m_Log.DebugFormat("Folder not found for {0} of {1}", m_Item.AssetType, m_DestinationAgent);
#endif
return;
}
UUID oldItemID = m_Item.ID;
bool noCopyItem = !m_Item.CheckPermissions(m_SrcAgent, UGI.Unknown, InventoryPermissionsMask.Copy);
m_Item.SetNewID(UUID.Random);
assetType = m_Item.AssetType;
m_Item.AdjustToNextOwner();
m_Item.LastOwner = m_Item.Owner;
m_Item.Owner = m_DestinationAgent;
m_Item.ParentFolderID = folder.ID;
givenName = m_Item.Name;
m_DstInventoryService.Item.Add(m_Item);
givenID = m_Item.ID;
if (noCopyItem)
{
m_SrcInventoryService.Item.Delete(m_SrcAgent.ID, oldItemID);
}
}
var binbuck = new byte[17];
binbuck[0] = (byte)assetType;
givenID.ToBytes(binbuck, 1);
m_InventoryCreate?.Invoke(givenID);
var im = new GridInstantMessage
{
ToAgent = m_DestinationAgent,
FromAgent = m_SrcAgent,
Message = givenName,
IMSessionID = m_DstUserAgentService.RequiresInventoryIDAsIMSessionID ? givenID : m_TransactionID,
Dialog = GridInstantMessageDialog.InventoryOffered,
BinaryBucket = binbuck,
};
m_IMService.Send(im);
}
public static void StartTransfer(
UUID transactionID,
UGUI dstAgent,
UserAgentServiceInterface dstUserAgentService,
InventoryServiceInterface dstInventoryService,
AssetServiceInterface dstAssetService,
UGUIWithName srcAgent,
UserAgentServiceInterface srcUserAgentService,
InventoryServiceInterface srcInventoryService,
AssetServiceInterface srcAssetService,
AssetType givenAssetType,
UUID givenInventoryID,
IMServiceInterface imService,
Action <UUID> inventoryCreate = null)
{
if (dstUserAgentService == null)
{
throw new ArgumentNullException(nameof(dstUserAgentService));
}
if (dstInventoryService == null)
{
throw new ArgumentNullException(nameof(dstInventoryService));
}
if (dstAssetService == null)
{
throw new ArgumentNullException(nameof(dstAssetService));
}
if (srcInventoryService == null)
{
throw new ArgumentNullException(nameof(srcInventoryService));
}
if (srcAssetService == null)
{
throw new ArgumentNullException(nameof(srcAssetService));
}
if (imService == null)
{
throw new ArgumentNullException(nameof(imService));
}
if (srcUserAgentService != null && srcUserAgentService.SupportsInventoryTransfer)
{
srcUserAgentService.InitiateInventoryTransfer(dstAgent, srcAgent, givenAssetType, givenInventoryID, transactionID);
return;
}
if (givenAssetType == AssetType.Folder)
{
InventoryFolder folder;
#if DEBUG
m_Log.DebugFormat("Sending folder {0} from {1} to {2}", givenInventoryID, srcAgent, dstAgent);
#endif
if (srcInventoryService.Folder.TryGetValue(srcAgent.ID, givenInventoryID, out folder))
{
/* this has a whole bunch of such entries, but later only the first 17 bytes are kept and adjusted */
var assetids = new List <UUID>();
TransferInventoryFolder transferFolder = GetTree(srcInventoryService, folder, assetids);
if (transferFolder != null)
{
new InventoryTransferWorkItem(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
srcInventoryService,
srcAssetService,
assetids,
transferFolder,
imService,
inventoryCreate).QueueWorkItem();
}
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending folder {0} from {1} to {2}: Not found", givenInventoryID, srcAgent, dstAgent);
#endif
}
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending item {0} from {1} to {2}", givenInventoryID, srcAgent, dstAgent);
#endif
/* just some item */
InventoryItem item;
if (srcInventoryService.Item.TryGetValue(srcAgent.ID, givenInventoryID, out item) &&
item.AssetType != AssetType.Link && item.AssetType != AssetType.LinkFolder &&
item.CheckPermissions(srcAgent, UGI.Unknown, InventoryPermissionsMask.Transfer))
{
new InventoryTransferWorkItem(
transactionID,
dstAgent,
dstUserAgentService,
dstInventoryService,
dstAssetService,
srcAgent,
srcInventoryService,
dstAssetService,
item.AssetID,
item,
imService,
inventoryCreate).QueueWorkItem();
}
else
{
#if DEBUG
m_Log.DebugFormat("Sending item {0} from {1} to {2}: Not found", givenInventoryID, srcAgent, dstAgent);
#endif
}
}
}
