diff options
author | Justin Clark-Casey (justincc) | 2010-03-12 20:06:40 +0000 |
---|---|---|
committer | Justin Clark-Casey (justincc) | 2010-03-12 20:06:40 +0000 |
commit | 7d738156faf923f2b23aa9bd3ecb6e2cd4d9d54f (patch) | |
tree | 909a3bf1baeb83a34154b28aaa46fcfc855462bc /OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs | |
parent | Fix tests broken in 88771aeed3d45e60a18aa9a810eeb37b8e5def12 (diff) | |
parent | Fixed SimianGrid.ini to use GridCommon.ini(.example) (diff) | |
download | opensim-SC_OLD-7d738156faf923f2b23aa9bd3ecb6e2cd4d9d54f.zip opensim-SC_OLD-7d738156faf923f2b23aa9bd3ecb6e2cd4d9d54f.tar.gz opensim-SC_OLD-7d738156faf923f2b23aa9bd3ecb6e2cd4d9d54f.tar.bz2 opensim-SC_OLD-7d738156faf923f2b23aa9bd3ecb6e2cd4d9d54f.tar.xz |
Merge branch 'master' of ssh://justincc@opensimulator.org/var/git/opensim
Diffstat (limited to 'OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs')
-rw-r--r-- | OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs | 880 |
1 files changed, 880 insertions, 0 deletions
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs new file mode 100644 index 0000000..c812899 --- /dev/null +++ b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs | |||
@@ -0,0 +1,880 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Collections.Specialized; | ||
31 | using System.Reflection; | ||
32 | using log4net; | ||
33 | using Mono.Addins; | ||
34 | using Nini.Config; | ||
35 | using OpenMetaverse; | ||
36 | using OpenMetaverse.StructuredData; | ||
37 | using OpenSim.Framework; | ||
38 | using OpenSim.Region.Framework.Interfaces; | ||
39 | using OpenSim.Region.Framework.Scenes; | ||
40 | using OpenSim.Server.Base; | ||
41 | using OpenSim.Services.Interfaces; | ||
42 | |||
43 | namespace OpenSim.Services.Connectors.SimianGrid | ||
44 | { | ||
45 | /// <summary> | ||
46 | /// Permissions bitflags | ||
47 | /// </summary> | ||
48 | [Flags] | ||
49 | public enum PermissionMask : uint | ||
50 | { | ||
51 | None = 0, | ||
52 | Transfer = 1 << 13, | ||
53 | Modify = 1 << 14, | ||
54 | Copy = 1 << 15, | ||
55 | Move = 1 << 19, | ||
56 | Damage = 1 << 20, | ||
57 | All = 0x7FFFFFFF | ||
58 | } | ||
59 | |||
60 | /// <summary> | ||
61 | /// Connects avatar inventories to the SimianGrid backend | ||
62 | /// </summary> | ||
63 | [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")] | ||
64 | public class SimianInventoryServiceConnector : IInventoryService, ISharedRegionModule | ||
65 | { | ||
66 | private static readonly ILog m_log = | ||
67 | LogManager.GetLogger( | ||
68 | MethodBase.GetCurrentMethod().DeclaringType); | ||
69 | |||
70 | private string m_serverUrl = String.Empty; | ||
71 | private string m_userServerUrl = String.Empty; | ||
72 | private object m_gestureSyncRoot = new object(); | ||
73 | |||
74 | #region ISharedRegionModule | ||
75 | |||
76 | public Type ReplaceableInterface { get { return null; } } | ||
77 | public void RegionLoaded(Scene scene) { } | ||
78 | public void PostInitialise() { } | ||
79 | public void Close() { } | ||
80 | |||
81 | public SimianInventoryServiceConnector() { } | ||
82 | public string Name { get { return "SimianInventoryServiceConnector"; } } | ||
83 | public void AddRegion(Scene scene) { scene.RegisterModuleInterface<IInventoryService>(this); } | ||
84 | public void RemoveRegion(Scene scene) { scene.UnregisterModuleInterface<IInventoryService>(this); } | ||
85 | |||
86 | #endregion ISharedRegionModule | ||
87 | |||
88 | public SimianInventoryServiceConnector(IConfigSource source) | ||
89 | { | ||
90 | Initialise(source); | ||
91 | } | ||
92 | |||
93 | public void Initialise(IConfigSource source) | ||
94 | { | ||
95 | IConfig gridConfig = source.Configs["InventoryService"]; | ||
96 | if (gridConfig == null) | ||
97 | { | ||
98 | m_log.Error("[INVENTORY CONNECTOR]: InventoryService missing from OpenSim.ini"); | ||
99 | throw new Exception("Inventory connector init error"); | ||
100 | } | ||
101 | |||
102 | string serviceUrl = gridConfig.GetString("InventoryServerURI"); | ||
103 | if (String.IsNullOrEmpty(serviceUrl)) | ||
104 | { | ||
105 | m_log.Error("[INVENTORY CONNECTOR]: No Server URI named in section InventoryService"); | ||
106 | throw new Exception("Inventory connector init error"); | ||
107 | } | ||
108 | |||
109 | // FIXME: Get the user server URL too | ||
110 | |||
111 | m_serverUrl = serviceUrl; | ||
112 | } | ||
113 | |||
114 | /// <summary> | ||
115 | /// Create the entire inventory for a given user | ||
116 | /// </summary> | ||
117 | /// <param name="user"></param> | ||
118 | /// <returns></returns> | ||
119 | public bool CreateUserInventory(UUID userID) | ||
120 | { | ||
121 | NameValueCollection requestArgs = new NameValueCollection | ||
122 | { | ||
123 | { "RequestMethod", "AddInventory" }, | ||
124 | { "OwnerID", userID.ToString() } | ||
125 | }; | ||
126 | |||
127 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
128 | bool success = response["Success"].AsBoolean(); | ||
129 | |||
130 | if (!success) | ||
131 | m_log.Warn("[INVENTORY CONNECTOR]: Inventory creation for " + userID + " failed: " + response["Message"].AsString()); | ||
132 | |||
133 | return success; | ||
134 | } | ||
135 | |||
136 | /// <summary> | ||
137 | /// Gets the skeleton of the inventory -- folders only | ||
138 | /// </summary> | ||
139 | /// <param name="userID"></param> | ||
140 | /// <returns></returns> | ||
141 | public List<InventoryFolderBase> GetInventorySkeleton(UUID userID) | ||
142 | { | ||
143 | NameValueCollection requestArgs = new NameValueCollection | ||
144 | { | ||
145 | { "RequestMethod", "GetInventoryNode" }, | ||
146 | { "ItemID", userID.ToString() }, | ||
147 | { "OwnerID", userID.ToString() }, | ||
148 | { "IncludeFolders", "1" }, | ||
149 | { "IncludeItems", "0" }, | ||
150 | { "ChildrenOnly", "0" } | ||
151 | }; | ||
152 | |||
153 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
154 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
155 | { | ||
156 | OSDArray items = (OSDArray)response["Items"]; | ||
157 | return GetFoldersFromResponse(items, userID, true); | ||
158 | } | ||
159 | else | ||
160 | { | ||
161 | m_log.Warn("[INVENTORY CONNECTOR]: Failed to retrieve inventory skeleton for " + userID + ": " + | ||
162 | response["Message"].AsString()); | ||
163 | return new List<InventoryFolderBase>(0); | ||
164 | } | ||
165 | } | ||
166 | |||
167 | /// <summary> | ||
168 | /// Synchronous inventory fetch. | ||
169 | /// </summary> | ||
170 | /// <param name="userID"></param> | ||
171 | /// <returns></returns> | ||
172 | [Obsolete] | ||
173 | public InventoryCollection GetUserInventory(UUID userID) | ||
174 | { | ||
175 | m_log.Error("[INVENTORY CONNECTOR]: Obsolete GetUserInventory called for " + userID); | ||
176 | |||
177 | InventoryCollection inventory = new InventoryCollection(); | ||
178 | inventory.UserID = userID; | ||
179 | inventory.Folders = new List<InventoryFolderBase>(); | ||
180 | inventory.Items = new List<InventoryItemBase>(); | ||
181 | |||
182 | return inventory; | ||
183 | } | ||
184 | |||
185 | /// <summary> | ||
186 | /// Request the inventory for a user. This is an asynchronous operation that will call the callback when the | ||
187 | /// inventory has been received | ||
188 | /// </summary> | ||
189 | /// <param name="userID"></param> | ||
190 | /// <param name="callback"></param> | ||
191 | [Obsolete] | ||
192 | public void GetUserInventory(UUID userID, InventoryReceiptCallback callback) | ||
193 | { | ||
194 | m_log.Error("[INVENTORY CONNECTOR]: Obsolete GetUserInventory called for " + userID); | ||
195 | callback(new List<InventoryFolderImpl>(0), new List<InventoryItemBase>(0)); | ||
196 | } | ||
197 | |||
198 | /// <summary> | ||
199 | /// Retrieve the root inventory folder for the given user. | ||
200 | /// </summary> | ||
201 | /// <param name="userID"></param> | ||
202 | /// <returns>null if no root folder was found</returns> | ||
203 | public InventoryFolderBase GetRootFolder(UUID userID) | ||
204 | { | ||
205 | NameValueCollection requestArgs = new NameValueCollection | ||
206 | { | ||
207 | { "RequestMethod", "GetInventoryNode" }, | ||
208 | { "ItemID", userID.ToString() }, | ||
209 | { "OwnerID", userID.ToString() }, | ||
210 | { "IncludeFolders", "1" }, | ||
211 | { "IncludeItems", "0" }, | ||
212 | { "ChildrenOnly", "1" } | ||
213 | }; | ||
214 | |||
215 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
216 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
217 | { | ||
218 | OSDArray items = (OSDArray)response["Items"]; | ||
219 | List<InventoryFolderBase> folders = GetFoldersFromResponse(items, userID, true); | ||
220 | |||
221 | if (folders.Count > 0) | ||
222 | return folders[0]; | ||
223 | } | ||
224 | |||
225 | return null; | ||
226 | } | ||
227 | |||
228 | /// <summary> | ||
229 | /// Gets the user folder for the given folder-type | ||
230 | /// </summary> | ||
231 | /// <param name="userID"></param> | ||
232 | /// <param name="type"></param> | ||
233 | /// <returns></returns> | ||
234 | public InventoryFolderBase GetFolderForType(UUID userID, AssetType type) | ||
235 | { | ||
236 | string contentType = SLUtil.SLAssetTypeToContentType((int)type); | ||
237 | |||
238 | NameValueCollection requestArgs = new NameValueCollection | ||
239 | { | ||
240 | { "RequestMethod", "GetFolderForType" }, | ||
241 | { "ContentType", contentType }, | ||
242 | { "OwnerID", userID.ToString() } | ||
243 | }; | ||
244 | |||
245 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
246 | if (response["Success"].AsBoolean() && response["Folder"] is OSDMap) | ||
247 | { | ||
248 | OSDMap folder = (OSDMap)response["Folder"]; | ||
249 | |||
250 | return new InventoryFolderBase( | ||
251 | folder["ID"].AsUUID(), | ||
252 | folder["Name"].AsString(), | ||
253 | folder["OwnerID"].AsUUID(), | ||
254 | (short)SLUtil.ContentTypeToSLAssetType(folder["ContentType"].AsString()), | ||
255 | folder["ParentID"].AsUUID(), | ||
256 | (ushort)folder["Version"].AsInteger() | ||
257 | ); | ||
258 | } | ||
259 | else | ||
260 | { | ||
261 | m_log.Warn("[INVENTORY CONNECTOR]: Default folder not found for content type " + contentType); | ||
262 | return GetRootFolder(userID); | ||
263 | } | ||
264 | } | ||
265 | |||
266 | /// <summary> | ||
267 | /// Get an item, given by its UUID | ||
268 | /// </summary> | ||
269 | /// <param name="item"></param> | ||
270 | /// <returns></returns> | ||
271 | public InventoryItemBase GetItem(InventoryItemBase item) | ||
272 | { | ||
273 | NameValueCollection requestArgs = new NameValueCollection | ||
274 | { | ||
275 | { "RequestMethod", "GetInventoryNode" }, | ||
276 | { "ItemID", item.ID.ToString() }, | ||
277 | { "OwnerID", item.Owner.ToString() }, | ||
278 | { "IncludeFolders", "1" }, | ||
279 | { "IncludeItems", "1" }, | ||
280 | { "ChildrenOnly", "1" } | ||
281 | }; | ||
282 | |||
283 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
284 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
285 | { | ||
286 | List<InventoryItemBase> items = GetItemsFromResponse((OSDArray)response["Items"]); | ||
287 | if (items.Count > 0) | ||
288 | { | ||
289 | // The requested item should be the first in this list, but loop through | ||
290 | // and sanity check just in case | ||
291 | for (int i = 0; i < items.Count; i++) | ||
292 | { | ||
293 | if (items[i].ID == item.ID) | ||
294 | return items[i]; | ||
295 | } | ||
296 | } | ||
297 | } | ||
298 | |||
299 | m_log.Warn("[INVENTORY CONNECTOR]: Item " + item.ID + " owned by " + item.Owner + " not found"); | ||
300 | return null; | ||
301 | } | ||
302 | |||
303 | /// <summary> | ||
304 | /// Get a folder, given by its UUID | ||
305 | /// </summary> | ||
306 | /// <param name="folder"></param> | ||
307 | /// <returns></returns> | ||
308 | public InventoryFolderBase GetFolder(InventoryFolderBase folder) | ||
309 | { | ||
310 | NameValueCollection requestArgs = new NameValueCollection | ||
311 | { | ||
312 | { "RequestMethod", "GetInventoryNode" }, | ||
313 | { "ItemID", folder.ID.ToString() }, | ||
314 | { "OwnerID", folder.Owner.ToString() }, | ||
315 | { "IncludeFolders", "1" }, | ||
316 | { "IncludeItems", "0" }, | ||
317 | { "ChildrenOnly", "1" } | ||
318 | }; | ||
319 | |||
320 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
321 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
322 | { | ||
323 | OSDArray items = (OSDArray)response["Items"]; | ||
324 | List<InventoryFolderBase> folders = GetFoldersFromResponse(items, folder.ID, true); | ||
325 | |||
326 | if (folders.Count > 0) | ||
327 | return folders[0]; | ||
328 | } | ||
329 | |||
330 | return null; | ||
331 | } | ||
332 | |||
333 | /// <summary> | ||
334 | /// Gets everything (folders and items) inside a folder | ||
335 | /// </summary> | ||
336 | /// <param name="userID"></param> | ||
337 | /// <param name="folderID"></param> | ||
338 | /// <returns></returns> | ||
339 | public InventoryCollection GetFolderContent(UUID userID, UUID folderID) | ||
340 | { | ||
341 | InventoryCollection inventory = new InventoryCollection(); | ||
342 | inventory.UserID = userID; | ||
343 | |||
344 | NameValueCollection requestArgs = new NameValueCollection | ||
345 | { | ||
346 | { "RequestMethod", "GetInventoryNode" }, | ||
347 | { "ItemID", folderID.ToString() }, | ||
348 | { "OwnerID", userID.ToString() }, | ||
349 | { "IncludeFolders", "1" }, | ||
350 | { "IncludeItems", "1" }, | ||
351 | { "ChildrenOnly", "1" } | ||
352 | }; | ||
353 | |||
354 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
355 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
356 | { | ||
357 | OSDArray items = (OSDArray)response["Items"]; | ||
358 | |||
359 | inventory.Folders = GetFoldersFromResponse(items, folderID, false); | ||
360 | inventory.Items = GetItemsFromResponse(items); | ||
361 | } | ||
362 | else | ||
363 | { | ||
364 | m_log.Warn("[INVENTORY CONNECTOR]: Error fetching folder " + folderID + " content for " + userID + ": " + | ||
365 | response["Message"].AsString()); | ||
366 | inventory.Folders = new List<InventoryFolderBase>(0); | ||
367 | inventory.Items = new List<InventoryItemBase>(0); | ||
368 | } | ||
369 | |||
370 | return inventory; | ||
371 | } | ||
372 | |||
373 | /// <summary> | ||
374 | /// Gets the items inside a folder | ||
375 | /// </summary> | ||
376 | /// <param name="userID"></param> | ||
377 | /// <param name="folderID"></param> | ||
378 | /// <returns></returns> | ||
379 | public List<InventoryItemBase> GetFolderItems(UUID userID, UUID folderID) | ||
380 | { | ||
381 | InventoryCollection inventory = new InventoryCollection(); | ||
382 | inventory.UserID = userID; | ||
383 | |||
384 | NameValueCollection requestArgs = new NameValueCollection | ||
385 | { | ||
386 | { "RequestMethod", "GetInventoryNode" }, | ||
387 | { "ItemID", folderID.ToString() }, | ||
388 | { "OwnerID", userID.ToString() }, | ||
389 | { "IncludeFolders", "0" }, | ||
390 | { "IncludeItems", "1" }, | ||
391 | { "ChildrenOnly", "1" } | ||
392 | }; | ||
393 | |||
394 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
395 | if (response["Success"].AsBoolean() && response["Items"] is OSDArray) | ||
396 | { | ||
397 | OSDArray items = (OSDArray)response["Items"]; | ||
398 | return GetItemsFromResponse(items); | ||
399 | } | ||
400 | else | ||
401 | { | ||
402 | m_log.Warn("[INVENTORY CONNECTOR]: Error fetching folder " + folderID + " for " + userID + ": " + | ||
403 | response["Message"].AsString()); | ||
404 | return new List<InventoryItemBase>(0); | ||
405 | } | ||
406 | } | ||
407 | |||
408 | /// <summary> | ||
409 | /// Add a new folder to the user's inventory | ||
410 | /// </summary> | ||
411 | /// <param name="folder"></param> | ||
412 | /// <returns>true if the folder was successfully added</returns> | ||
413 | public bool AddFolder(InventoryFolderBase folder) | ||
414 | { | ||
415 | NameValueCollection requestArgs = new NameValueCollection | ||
416 | { | ||
417 | { "RequestMethod", "AddInventoryFolder" }, | ||
418 | { "FolderID", folder.ID.ToString() }, | ||
419 | { "ParentID", folder.ParentID.ToString() }, | ||
420 | { "OwnerID", folder.Owner.ToString() }, | ||
421 | { "Name", folder.Name }, | ||
422 | { "ContentType", SLUtil.SLAssetTypeToContentType(folder.Type) } | ||
423 | }; | ||
424 | |||
425 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
426 | bool success = response["Success"].AsBoolean(); | ||
427 | |||
428 | if (!success) | ||
429 | { | ||
430 | m_log.Warn("[INVENTORY CONNECTOR]: Error creating folder " + folder.Name + " for " + folder.Owner + ": " + | ||
431 | response["Message"].AsString()); | ||
432 | } | ||
433 | |||
434 | return success; | ||
435 | } | ||
436 | |||
437 | /// <summary> | ||
438 | /// Update a folder in the user's inventory | ||
439 | /// </summary> | ||
440 | /// <param name="folder"></param> | ||
441 | /// <returns>true if the folder was successfully updated</returns> | ||
442 | public bool UpdateFolder(InventoryFolderBase folder) | ||
443 | { | ||
444 | return AddFolder(folder); | ||
445 | } | ||
446 | |||
447 | /// <summary> | ||
448 | /// Move an inventory folder to a new location | ||
449 | /// </summary> | ||
450 | /// <param name="folder">A folder containing the details of the new location</param> | ||
451 | /// <returns>true if the folder was successfully moved</returns> | ||
452 | public bool MoveFolder(InventoryFolderBase folder) | ||
453 | { | ||
454 | return AddFolder(folder); | ||
455 | } | ||
456 | |||
457 | /// <summary> | ||
458 | /// Delete an item from the user's inventory | ||
459 | /// </summary> | ||
460 | /// <param name="item"></param> | ||
461 | /// <returns>true if the item was successfully deleted</returns> | ||
462 | //bool DeleteItem(InventoryItemBase item); | ||
463 | public bool DeleteFolders(UUID userID, List<UUID> folderIDs) | ||
464 | { | ||
465 | return DeleteItems(userID, folderIDs); | ||
466 | } | ||
467 | |||
468 | /// <summary> | ||
469 | /// Delete an item from the user's inventory | ||
470 | /// </summary> | ||
471 | /// <param name="item"></param> | ||
472 | /// <returns>true if the item was successfully deleted</returns> | ||
473 | public bool DeleteItems(UUID userID, List<UUID> itemIDs) | ||
474 | { | ||
475 | // TODO: RemoveInventoryNode should be replaced with RemoveInventoryNodes | ||
476 | bool allSuccess = true; | ||
477 | |||
478 | for (int i = 0; i < itemIDs.Count; i++) | ||
479 | { | ||
480 | UUID itemID = itemIDs[i]; | ||
481 | |||
482 | NameValueCollection requestArgs = new NameValueCollection | ||
483 | { | ||
484 | { "RequestMethod", "RemoveInventoryNode" }, | ||
485 | { "OwnerID", userID.ToString() }, | ||
486 | { "ItemID", itemID.ToString() } | ||
487 | }; | ||
488 | |||
489 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
490 | bool success = response["Success"].AsBoolean(); | ||
491 | |||
492 | if (!success) | ||
493 | { | ||
494 | m_log.Warn("[INVENTORY CONNECTOR]: Error removing item " + itemID + " for " + userID + ": " + | ||
495 | response["Message"].AsString()); | ||
496 | allSuccess = false; | ||
497 | } | ||
498 | } | ||
499 | |||
500 | return allSuccess; | ||
501 | } | ||
502 | |||
503 | /// <summary> | ||
504 | /// Purge an inventory folder of all its items and subfolders. | ||
505 | /// </summary> | ||
506 | /// <param name="folder"></param> | ||
507 | /// <returns>true if the folder was successfully purged</returns> | ||
508 | public bool PurgeFolder(InventoryFolderBase folder) | ||
509 | { | ||
510 | NameValueCollection requestArgs = new NameValueCollection | ||
511 | { | ||
512 | { "RequestMethod", "PurgeInventoryFolder" }, | ||
513 | { "OwnerID", folder.Owner.ToString() }, | ||
514 | { "FolderID", folder.ID.ToString() } | ||
515 | }; | ||
516 | |||
517 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
518 | bool success = response["Success"].AsBoolean(); | ||
519 | |||
520 | if (!success) | ||
521 | { | ||
522 | m_log.Warn("[INVENTORY CONNECTOR]: Error purging folder " + folder.ID + " for " + folder.Owner + ": " + | ||
523 | response["Message"].AsString()); | ||
524 | } | ||
525 | |||
526 | return success; | ||
527 | } | ||
528 | |||
529 | /// <summary> | ||
530 | /// Add a new item to the user's inventory | ||
531 | /// </summary> | ||
532 | /// <param name="item"></param> | ||
533 | /// <returns>true if the item was successfully added</returns> | ||
534 | public bool AddItem(InventoryItemBase item) | ||
535 | { | ||
536 | // A folder of UUID.Zero means we need to find the most appropriate home for this item | ||
537 | if (item.Folder == UUID.Zero) | ||
538 | { | ||
539 | InventoryFolderBase folder = GetFolderForType(item.Owner, (AssetType)item.AssetType); | ||
540 | if (folder != null && folder.ID != UUID.Zero) | ||
541 | item.Folder = folder.ID; | ||
542 | else | ||
543 | item.Folder = item.Owner; // Root folder | ||
544 | } | ||
545 | |||
546 | if ((AssetType)item.AssetType == AssetType.Gesture) | ||
547 | UpdateGesture(item.Owner, item.ID, item.Flags == 1); | ||
548 | |||
549 | if (item.BasePermissions == 0) | ||
550 | m_log.WarnFormat("[INVENTORY CONNECTOR]: Adding inventory item {0} ({1}) with no base permissions", item.Name, item.ID); | ||
551 | |||
552 | OSDMap permissions = new OSDMap | ||
553 | { | ||
554 | { "BaseMask", OSD.FromInteger(item.BasePermissions) }, | ||
555 | { "EveryoneMask", OSD.FromInteger(item.EveryOnePermissions) }, | ||
556 | { "GroupMask", OSD.FromInteger(item.GroupPermissions) }, | ||
557 | { "NextOwnerMask", OSD.FromInteger(item.NextPermissions) }, | ||
558 | { "OwnerMask", OSD.FromInteger(item.CurrentPermissions) } | ||
559 | }; | ||
560 | |||
561 | OSDMap extraData = new OSDMap() | ||
562 | { | ||
563 | { "Flags", OSD.FromInteger(item.Flags) }, | ||
564 | { "GroupID", OSD.FromUUID(item.GroupID) }, | ||
565 | { "GroupOwned", OSD.FromBoolean(item.GroupOwned) }, | ||
566 | { "SalePrice", OSD.FromInteger(item.SalePrice) }, | ||
567 | { "SaleType", OSD.FromInteger(item.SaleType) }, | ||
568 | { "Permissions", permissions } | ||
569 | }; | ||
570 | |||
571 | NameValueCollection requestArgs = new NameValueCollection | ||
572 | { | ||
573 | { "RequestMethod", "AddInventoryItem" }, | ||
574 | { "ItemID", item.ID.ToString() }, | ||
575 | { "AssetID", item.AssetID.ToString() }, | ||
576 | { "ParentID", item.Folder.ToString() }, | ||
577 | { "OwnerID", item.Owner.ToString() }, | ||
578 | { "Name", item.Name }, | ||
579 | { "Description", item.Description }, | ||
580 | { "CreatorID", item.CreatorId }, | ||
581 | { "ExtraData", OSDParser.SerializeJsonString(extraData) } | ||
582 | }; | ||
583 | |||
584 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
585 | bool success = response["Success"].AsBoolean(); | ||
586 | |||
587 | if (!success) | ||
588 | { | ||
589 | m_log.Warn("[INVENTORY CONNECTOR]: Error creating item " + item.Name + " for " + item.Owner + ": " + | ||
590 | response["Message"].AsString()); | ||
591 | } | ||
592 | |||
593 | return success; | ||
594 | } | ||
595 | |||
596 | /// <summary> | ||
597 | /// Update an item in the user's inventory | ||
598 | /// </summary> | ||
599 | /// <param name="item"></param> | ||
600 | /// <returns>true if the item was successfully updated</returns> | ||
601 | public bool UpdateItem(InventoryItemBase item) | ||
602 | { | ||
603 | if (item.AssetID != UUID.Zero) | ||
604 | { | ||
605 | return AddItem(item); | ||
606 | } | ||
607 | else | ||
608 | { | ||
609 | // This is actually a folder update | ||
610 | InventoryFolderBase folder = new InventoryFolderBase(item.ID, item.Name, item.Owner, (short)item.AssetType, item.Folder, 0); | ||
611 | return UpdateFolder(folder); | ||
612 | } | ||
613 | } | ||
614 | |||
615 | public bool MoveItems(UUID ownerID, List<InventoryItemBase> items) | ||
616 | { | ||
617 | bool success = true; | ||
618 | |||
619 | while (items.Count > 0) | ||
620 | { | ||
621 | List<InventoryItemBase> currentItems = new List<InventoryItemBase>(); | ||
622 | UUID destFolderID = items[0].Folder; | ||
623 | |||
624 | // Find all of the items being moved to the current destination folder | ||
625 | for (int i = 0; i < items.Count; i++) | ||
626 | { | ||
627 | InventoryItemBase item = items[i]; | ||
628 | if (item.Folder == destFolderID) | ||
629 | currentItems.Add(item); | ||
630 | } | ||
631 | |||
632 | // Do the inventory move for the current items | ||
633 | success &= MoveItems(ownerID, items, destFolderID); | ||
634 | |||
635 | // Remove the processed items from the list | ||
636 | for (int i = 0; i < currentItems.Count; i++) | ||
637 | items.Remove(currentItems[i]); | ||
638 | } | ||
639 | |||
640 | return success; | ||
641 | } | ||
642 | |||
643 | /// <summary> | ||
644 | /// Does the given user have an inventory structure? | ||
645 | /// </summary> | ||
646 | /// <param name="userID"></param> | ||
647 | /// <returns></returns> | ||
648 | public bool HasInventoryForUser(UUID userID) | ||
649 | { | ||
650 | return GetRootFolder(userID) != null; | ||
651 | } | ||
652 | |||
653 | /// <summary> | ||
654 | /// Get the active gestures of the agent. | ||
655 | /// </summary> | ||
656 | /// <param name="userID"></param> | ||
657 | /// <returns></returns> | ||
658 | public List<InventoryItemBase> GetActiveGestures(UUID userID) | ||
659 | { | ||
660 | OSDArray items = FetchGestures(userID); | ||
661 | |||
662 | string[] itemIDs = new string[items.Count]; | ||
663 | for (int i = 0; i < items.Count; i++) | ||
664 | itemIDs[i] = items[i].AsUUID().ToString(); | ||
665 | |||
666 | NameValueCollection requestArgs = new NameValueCollection | ||
667 | { | ||
668 | { "RequestMethod", "GetInventoryNodes" }, | ||
669 | { "OwnerID", userID.ToString() }, | ||
670 | { "Items", String.Join(",", itemIDs) } | ||
671 | }; | ||
672 | |||
673 | // FIXME: Implement this in SimianGrid | ||
674 | return new List<InventoryItemBase>(0); | ||
675 | } | ||
676 | |||
677 | /// <summary> | ||
678 | /// Get the union of permissions of all inventory items | ||
679 | /// that hold the given assetID. | ||
680 | /// </summary> | ||
681 | /// <param name="userID"></param> | ||
682 | /// <param name="assetID"></param> | ||
683 | /// <returns>The permissions or 0 if no such asset is found in | ||
684 | /// the user's inventory</returns> | ||
685 | public int GetAssetPermissions(UUID userID, UUID assetID) | ||
686 | { | ||
687 | NameValueCollection requestArgs = new NameValueCollection | ||
688 | { | ||
689 | { "RequestMethod", "GetInventoryNodes" }, | ||
690 | { "OwnerID", userID.ToString() }, | ||
691 | { "AssetID", assetID.ToString() } | ||
692 | }; | ||
693 | |||
694 | // FIXME: Implement this in SimianGrid | ||
695 | return (int)PermissionMask.All; | ||
696 | } | ||
697 | |||
698 | private List<InventoryFolderBase> GetFoldersFromResponse(OSDArray items, UUID baseFolder, bool includeBaseFolder) | ||
699 | { | ||
700 | List<InventoryFolderBase> invFolders = new List<InventoryFolderBase>(items.Count); | ||
701 | |||
702 | for (int i = 0; i < items.Count; i++) | ||
703 | { | ||
704 | OSDMap item = items[i] as OSDMap; | ||
705 | |||
706 | if (item != null && item["Type"].AsString() == "Folder") | ||
707 | { | ||
708 | UUID folderID = item["ID"].AsUUID(); | ||
709 | |||
710 | if (folderID == baseFolder && !includeBaseFolder) | ||
711 | continue; | ||
712 | |||
713 | invFolders.Add(new InventoryFolderBase( | ||
714 | folderID, | ||
715 | item["Name"].AsString(), | ||
716 | item["OwnerID"].AsUUID(), | ||
717 | (short)SLUtil.ContentTypeToSLAssetType(item["ContentType"].AsString()), | ||
718 | item["ParentID"].AsUUID(), | ||
719 | (ushort)item["Version"].AsInteger() | ||
720 | )); | ||
721 | } | ||
722 | } | ||
723 | |||
724 | return invFolders; | ||
725 | } | ||
726 | |||
727 | private List<InventoryItemBase> GetItemsFromResponse(OSDArray items) | ||
728 | { | ||
729 | List<InventoryItemBase> invItems = new List<InventoryItemBase>(items.Count); | ||
730 | |||
731 | for (int i = 0; i < items.Count; i++) | ||
732 | { | ||
733 | OSDMap item = items[i] as OSDMap; | ||
734 | |||
735 | if (item != null && item["Type"].AsString() == "Item") | ||
736 | { | ||
737 | InventoryItemBase invItem = new InventoryItemBase(); | ||
738 | |||
739 | invItem.AssetID = item["AssetID"].AsUUID(); | ||
740 | invItem.AssetType = SLUtil.ContentTypeToSLAssetType(item["ContentType"].AsString()); | ||
741 | invItem.CreationDate = item["CreationDate"].AsInteger(); | ||
742 | invItem.CreatorId = item["CreatorID"].AsString(); | ||
743 | invItem.CreatorIdAsUuid = item["CreatorID"].AsUUID(); | ||
744 | invItem.Description = item["Description"].AsString(); | ||
745 | invItem.Folder = item["ParentID"].AsUUID(); | ||
746 | invItem.ID = item["ID"].AsUUID(); | ||
747 | invItem.InvType = SLUtil.ContentTypeToSLInvType(item["ContentType"].AsString()); | ||
748 | invItem.Name = item["Name"].AsString(); | ||
749 | invItem.Owner = item["OwnerID"].AsUUID(); | ||
750 | |||
751 | OSDMap extraData = item["ExtraData"] as OSDMap; | ||
752 | if (extraData != null && extraData.Count > 0) | ||
753 | { | ||
754 | invItem.Flags = extraData["Flags"].AsUInteger(); | ||
755 | invItem.GroupID = extraData["GroupID"].AsUUID(); | ||
756 | invItem.GroupOwned = extraData["GroupOwned"].AsBoolean(); | ||
757 | invItem.SalePrice = extraData["SalePrice"].AsInteger(); | ||
758 | invItem.SaleType = (byte)extraData["SaleType"].AsInteger(); | ||
759 | |||
760 | OSDMap perms = extraData["Permissions"] as OSDMap; | ||
761 | if (perms != null) | ||
762 | { | ||
763 | invItem.BasePermissions = perms["BaseMask"].AsUInteger(); | ||
764 | invItem.CurrentPermissions = perms["OwnerMask"].AsUInteger(); | ||
765 | invItem.EveryOnePermissions = perms["EveryoneMask"].AsUInteger(); | ||
766 | invItem.GroupPermissions = perms["GroupMask"].AsUInteger(); | ||
767 | invItem.NextPermissions = perms["NextOwnerMask"].AsUInteger(); | ||
768 | } | ||
769 | } | ||
770 | |||
771 | if (invItem.BasePermissions == 0) | ||
772 | { | ||
773 | m_log.InfoFormat("[INVENTORY CONNECTOR]: Forcing item permissions to full for item {0} ({1})", | ||
774 | invItem.Name, invItem.ID); | ||
775 | invItem.BasePermissions = (uint)PermissionMask.All; | ||
776 | invItem.CurrentPermissions = (uint)PermissionMask.All; | ||
777 | invItem.EveryOnePermissions = (uint)PermissionMask.All; | ||
778 | invItem.GroupPermissions = (uint)PermissionMask.All; | ||
779 | invItem.NextPermissions = (uint)PermissionMask.All; | ||
780 | } | ||
781 | |||
782 | invItems.Add(invItem); | ||
783 | } | ||
784 | } | ||
785 | |||
786 | return invItems; | ||
787 | } | ||
788 | |||
789 | private bool MoveItems(UUID ownerID, List<InventoryItemBase> items, UUID destFolderID) | ||
790 | { | ||
791 | string[] itemIDs = new string[items.Count]; | ||
792 | for (int i = 0; i < items.Count; i++) | ||
793 | itemIDs[i] = items[i].ID.ToString(); | ||
794 | |||
795 | NameValueCollection requestArgs = new NameValueCollection | ||
796 | { | ||
797 | { "RequestMethod", "MoveInventoryNodes" }, | ||
798 | { "OwnerID", ownerID.ToString() }, | ||
799 | { "FolderID", destFolderID.ToString() }, | ||
800 | { "Items", String.Join(",", itemIDs) } | ||
801 | }; | ||
802 | |||
803 | OSDMap response = WebUtil.PostToService(m_serverUrl, requestArgs); | ||
804 | bool success = response["Success"].AsBoolean(); | ||
805 | |||
806 | if (!success) | ||
807 | { | ||
808 | m_log.Warn("[INVENTORY CONNECTOR]: Failed to move " + items.Count + " items to " + | ||
809 | destFolderID + ": " + response["Message"].AsString()); | ||
810 | } | ||
811 | |||
812 | return success; | ||
813 | } | ||
814 | |||
815 | private void UpdateGesture(UUID userID, UUID itemID, bool enabled) | ||
816 | { | ||
817 | OSDArray gestures = FetchGestures(userID); | ||
818 | OSDArray newGestures = new OSDArray(); | ||
819 | |||
820 | for (int i = 0; i < gestures.Count; i++) | ||
821 | { | ||
822 | UUID gesture = gestures[i].AsUUID(); | ||
823 | if (gesture != itemID) | ||
824 | newGestures.Add(OSD.FromUUID(gesture)); | ||
825 | } | ||
826 | |||
827 | if (enabled) | ||
828 | newGestures.Add(OSD.FromUUID(itemID)); | ||
829 | |||
830 | SaveGestures(userID, newGestures); | ||
831 | } | ||
832 | |||
833 | private OSDArray FetchGestures(UUID userID) | ||
834 | { | ||
835 | NameValueCollection requestArgs = new NameValueCollection | ||
836 | { | ||
837 | { "RequestMethod", "GetUser" }, | ||
838 | { "UserID", userID.ToString() } | ||
839 | }; | ||
840 | |||
841 | OSDMap response = WebUtil.PostToService(m_userServerUrl, requestArgs); | ||
842 | if (response["Success"].AsBoolean()) | ||
843 | { | ||
844 | OSDMap user = response["User"] as OSDMap; | ||
845 | if (user != null && response.ContainsKey("Gestures")) | ||
846 | { | ||
847 | OSD gestures = OSDParser.DeserializeJson(response["Gestures"].AsString()); | ||
848 | if (gestures != null && gestures is OSDArray) | ||
849 | return (OSDArray)gestures; | ||
850 | else | ||
851 | m_log.Error("[INVENTORY CONNECTOR]: Unrecognized active gestures data for " + userID); | ||
852 | } | ||
853 | } | ||
854 | else | ||
855 | { | ||
856 | m_log.Warn("[INVENTORY CONNECTOR]: Failed to fetch active gestures for " + userID + ": " + | ||
857 | response["Message"].AsString()); | ||
858 | } | ||
859 | |||
860 | return new OSDArray(); | ||
861 | } | ||
862 | |||
863 | private void SaveGestures(UUID userID, OSDArray gestures) | ||
864 | { | ||
865 | NameValueCollection requestArgs = new NameValueCollection | ||
866 | { | ||
867 | { "RequestMethod", "AddUserData" }, | ||
868 | { "UserID", userID.ToString() }, | ||
869 | { "Gestures", OSDParser.SerializeJsonString(gestures) } | ||
870 | }; | ||
871 | |||
872 | OSDMap response = WebUtil.PostToService(m_userServerUrl, requestArgs); | ||
873 | if (!response["Success"].AsBoolean()) | ||
874 | { | ||
875 | m_log.Warn("[INVENTORY CONNECTOR]: Failed to save active gestures for " + userID + ": " + | ||
876 | response["Message"].AsString()); | ||
877 | } | ||
878 | } | ||
879 | } | ||
880 | } | ||