PageRenderTime 58ms CodeModel.GetById 33ms RepoModel.GetById 0ms app.codeStats 0ms

/OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/LocalInventoryServiceConnector.cs

https://github.com/UbitUmarov/Ubit-opensim
C# | 329 lines | 202 code | 54 blank | 73 comment | 19 complexity | a8e47b57ae58e16632b4f8dc2302f877 MD5 | raw file
  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. using log4net;
  28. using Nini.Config;
  29. using System;
  30. using System.Collections.Generic;
  31. using System.Reflection;
  32. using OpenSim.Framework;
  33. using OpenSim.Data;
  34. using OpenSim.Server.Base;
  35. using OpenSim.Region.Framework.Interfaces;
  36. using OpenSim.Region.Framework.Scenes;
  37. using OpenSim.Services.Interfaces;
  38. using OpenMetaverse;
  39. namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
  40. {
  41. public class LocalInventoryServicesConnector : ISharedRegionModule, IInventoryService
  42. {
  43. private static readonly ILog m_log =
  44. LogManager.GetLogger(
  45. MethodBase.GetCurrentMethod().DeclaringType);
  46. /// <summary>
  47. /// Scene used by this module. This currently needs to be publicly settable for HGInventoryBroker.
  48. /// </summary>
  49. public Scene Scene { get; set; }
  50. private IInventoryService m_InventoryService;
  51. private IUserManagement m_UserManager;
  52. private IUserManagement UserManager
  53. {
  54. get
  55. {
  56. if (m_UserManager == null)
  57. {
  58. m_UserManager = Scene.RequestModuleInterface<IUserManagement>();
  59. }
  60. return m_UserManager;
  61. }
  62. }
  63. private bool m_Enabled = false;
  64. public Type ReplaceableInterface
  65. {
  66. get { return null; }
  67. }
  68. public string Name
  69. {
  70. get { return "LocalInventoryServicesConnector"; }
  71. }
  72. public void Initialise(IConfigSource source)
  73. {
  74. IConfig moduleConfig = source.Configs["Modules"];
  75. if (moduleConfig != null)
  76. {
  77. string name = moduleConfig.GetString("InventoryServices", "");
  78. if (name == Name)
  79. {
  80. IConfig inventoryConfig = source.Configs["InventoryService"];
  81. if (inventoryConfig == null)
  82. {
  83. m_log.Error("[LOCAL INVENTORY SERVICES CONNECTOR]: InventoryService missing from OpenSim.ini");
  84. return;
  85. }
  86. string serviceDll = inventoryConfig.GetString("LocalServiceModule", String.Empty);
  87. if (serviceDll == String.Empty)
  88. {
  89. m_log.Error("[LOCAL INVENTORY SERVICES CONNECTOR]: No LocalServiceModule named in section InventoryService");
  90. return;
  91. }
  92. Object[] args = new Object[] { source };
  93. m_log.DebugFormat("[LOCAL INVENTORY SERVICES CONNECTOR]: Service dll = {0}", serviceDll);
  94. m_InventoryService = ServerUtils.LoadPlugin<IInventoryService>(serviceDll, args);
  95. if (m_InventoryService == null)
  96. {
  97. m_log.Error("[LOCAL INVENTORY SERVICES CONNECTOR]: Can't load inventory service");
  98. throw new Exception("Unable to proceed. Please make sure your ini files in config-include are updated according to .example's");
  99. }
  100. m_Enabled = true;
  101. m_log.Info("[LOCAL INVENTORY SERVICES CONNECTOR]: Local inventory connector enabled");
  102. }
  103. }
  104. }
  105. public void PostInitialise()
  106. {
  107. }
  108. public void Close()
  109. {
  110. }
  111. public void AddRegion(Scene scene)
  112. {
  113. if (!m_Enabled)
  114. return;
  115. scene.RegisterModuleInterface<IInventoryService>(this);
  116. if (Scene == null)
  117. Scene = scene;
  118. }
  119. public void RemoveRegion(Scene scene)
  120. {
  121. if (!m_Enabled)
  122. return;
  123. }
  124. public void RegionLoaded(Scene scene)
  125. {
  126. if (!m_Enabled)
  127. return;
  128. }
  129. #region IInventoryService
  130. public bool CreateUserInventory(UUID user)
  131. {
  132. return m_InventoryService.CreateUserInventory(user);
  133. }
  134. public List<InventoryFolderBase> GetInventorySkeleton(UUID userId)
  135. {
  136. return m_InventoryService.GetInventorySkeleton(userId);
  137. }
  138. public InventoryCollection GetUserInventory(UUID id)
  139. {
  140. return m_InventoryService.GetUserInventory(id);
  141. }
  142. public void GetUserInventory(UUID userID, InventoryReceiptCallback callback)
  143. {
  144. m_InventoryService.GetUserInventory(userID, callback);
  145. }
  146. public InventoryFolderBase GetRootFolder(UUID userID)
  147. {
  148. return m_InventoryService.GetRootFolder(userID);
  149. }
  150. public InventoryFolderBase GetFolderForType(UUID userID, AssetType type)
  151. {
  152. return m_InventoryService.GetFolderForType(userID, type);
  153. }
  154. public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
  155. {
  156. InventoryCollection invCol = m_InventoryService.GetFolderContent(userID, folderID);
  157. if (UserManager != null)
  158. {
  159. // Protect ourselves against the caller subsequently modifying the items list
  160. List<InventoryItemBase> items = new List<InventoryItemBase>(invCol.Items);
  161. Util.FireAndForget(delegate
  162. {
  163. foreach (InventoryItemBase item in items)
  164. UserManager.AddUser(item.CreatorIdAsUuid, item.CreatorData);
  165. });
  166. }
  167. return invCol;
  168. }
  169. public List<InventoryItemBase> GetFolderItems(UUID userID, UUID folderID)
  170. {
  171. return m_InventoryService.GetFolderItems(userID, folderID);
  172. }
  173. /// <summary>
  174. /// Add a new folder to the user's inventory
  175. /// </summary>
  176. /// <param name="folder"></param>
  177. /// <returns>true if the folder was successfully added</returns>
  178. public bool AddFolder(InventoryFolderBase folder)
  179. {
  180. return m_InventoryService.AddFolder(folder);
  181. }
  182. /// <summary>
  183. /// Update a folder in the user's inventory
  184. /// </summary>
  185. /// <param name="folder"></param>
  186. /// <returns>true if the folder was successfully updated</returns>
  187. public bool UpdateFolder(InventoryFolderBase folder)
  188. {
  189. return m_InventoryService.UpdateFolder(folder);
  190. }
  191. /// <summary>
  192. /// Move an inventory folder to a new location
  193. /// </summary>
  194. /// <param name="folder">A folder containing the details of the new location</param>
  195. /// <returns>true if the folder was successfully moved</returns>
  196. public bool MoveFolder(InventoryFolderBase folder)
  197. {
  198. return m_InventoryService.MoveFolder(folder);
  199. }
  200. public bool DeleteFolders(UUID ownerID, List<UUID> folderIDs)
  201. {
  202. return m_InventoryService.DeleteFolders(ownerID, folderIDs);
  203. }
  204. /// <summary>
  205. /// Purge an inventory folder of all its items and subfolders.
  206. /// </summary>
  207. /// <param name="folder"></param>
  208. /// <returns>true if the folder was successfully purged</returns>
  209. public bool PurgeFolder(InventoryFolderBase folder)
  210. {
  211. return m_InventoryService.PurgeFolder(folder);
  212. }
  213. public bool AddItem(InventoryItemBase item)
  214. {
  215. // m_log.DebugFormat(
  216. // "[LOCAL INVENTORY SERVICES CONNECTOR]: Adding inventory item {0} to user {1} folder {2}",
  217. // item.Name, item.Owner, item.Folder);
  218. return m_InventoryService.AddItem(item);
  219. }
  220. /// <summary>
  221. /// Update an item in the user's inventory
  222. /// </summary>
  223. /// <param name="item"></param>
  224. /// <returns>true if the item was successfully updated</returns>
  225. public bool UpdateItem(InventoryItemBase item)
  226. {
  227. return m_InventoryService.UpdateItem(item);
  228. }
  229. public bool MoveItems(UUID ownerID, List<InventoryItemBase> items)
  230. {
  231. return m_InventoryService.MoveItems(ownerID, items);
  232. }
  233. /// <summary>
  234. /// Delete an item from the user's inventory
  235. /// </summary>
  236. /// <param name="item"></param>
  237. /// <returns>true if the item was successfully deleted</returns>
  238. public bool DeleteItems(UUID ownerID, List<UUID> itemIDs)
  239. {
  240. return m_InventoryService.DeleteItems(ownerID, itemIDs);
  241. }
  242. public InventoryItemBase GetItem(InventoryItemBase item)
  243. {
  244. // m_log.DebugFormat("[LOCAL INVENTORY SERVICES CONNECTOR]: Requesting inventory item {0}", item.ID);
  245. // UUID requestedItemId = item.ID;
  246. item = m_InventoryService.GetItem(item);
  247. // if (null == item)
  248. // m_log.ErrorFormat(
  249. // "[LOCAL INVENTORY SERVICES CONNECTOR]: Could not find item with id {0}", requestedItemId);
  250. return item;
  251. }
  252. public InventoryFolderBase GetFolder(InventoryFolderBase folder)
  253. {
  254. return m_InventoryService.GetFolder(folder);
  255. }
  256. /// <summary>
  257. /// Does the given user have an inventory structure?
  258. /// </summary>
  259. /// <param name="userID"></param>
  260. /// <returns></returns>
  261. public bool HasInventoryForUser(UUID userID)
  262. {
  263. return m_InventoryService.HasInventoryForUser(userID);
  264. }
  265. public List<InventoryItemBase> GetActiveGestures(UUID userId)
  266. {
  267. return m_InventoryService.GetActiveGestures(userId);
  268. }
  269. public int GetAssetPermissions(UUID userID, UUID assetID)
  270. {
  271. return m_InventoryService.GetAssetPermissions(userID, assetID);
  272. }
  273. #endregion IInventoryService
  274. }
  275. }