aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Framework
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--OpenSim/Framework/Communications/Cache/InventoryFolder.cs15
-rw-r--r--OpenSim/Framework/Communications/Cache/UserProfileCache.cs6
-rw-r--r--OpenSim/Framework/Data.SQLite/SQLiteInventoryStore.cs401
-rw-r--r--OpenSim/Framework/InventoryServiceBase/InventoryServiceBase.cs66
-rw-r--r--OpenSim/Framework/UserManager/LoginService.cs32
5 files changed, 499 insertions, 21 deletions
diff --git a/OpenSim/Framework/Communications/Cache/InventoryFolder.cs b/OpenSim/Framework/Communications/Cache/InventoryFolder.cs
index 300a6e3..6b0e2b4 100644
--- a/OpenSim/Framework/Communications/Cache/InventoryFolder.cs
+++ b/OpenSim/Framework/Communications/Cache/InventoryFolder.cs
@@ -44,6 +44,21 @@ namespace OpenSim.Framework.Communications.Caches
44 public Dictionary<LLUUID, InventoryItemBase> Items = new Dictionary<LLUUID, InventoryItemBase>(); 44 public Dictionary<LLUUID, InventoryItemBase> Items = new Dictionary<LLUUID, InventoryItemBase>();
45 public Dictionary<LLUUID, InventoryFolder> SubFolders = new Dictionary<LLUUID, InventoryFolder>(); 45 public Dictionary<LLUUID, InventoryFolder> SubFolders = new Dictionary<LLUUID, InventoryFolder>();
46 46
47 public InventoryFolder(InventoryFolderBase folderbase)
48 {
49 this.agentID = folderbase.agentID;
50 this.folderID = folderbase.folderID;
51 this.name = folderbase.name;
52 this.parentID = folderbase.parentID;
53 this.type = folderbase.type;
54 this.version = folderbase.version;
55 }
56
57 public InventoryFolder()
58 {
59
60 }
61
47 // Methods 62 // Methods
48 public InventoryFolder CreateNewSubFolder(LLUUID folderID, string folderName, ushort type) 63 public InventoryFolder CreateNewSubFolder(LLUUID folderID, string folderName, ushort type)
49 { 64 {
diff --git a/OpenSim/Framework/Communications/Cache/UserProfileCache.cs b/OpenSim/Framework/Communications/Cache/UserProfileCache.cs
index 2f3691c..2271550 100644
--- a/OpenSim/Framework/Communications/Cache/UserProfileCache.cs
+++ b/OpenSim/Framework/Communications/Cache/UserProfileCache.cs
@@ -168,18 +168,18 @@ namespace OpenSim.Framework.Communications.Caches
168 /// <param name="userID"></param> 168 /// <param name="userID"></param>
169 private void RequestInventoryForUser(LLUUID userID, CachedUserInfo userInfo) 169 private void RequestInventoryForUser(LLUUID userID, CachedUserInfo userInfo)
170 { 170 {
171 // this.m_parent.InventoryServer.RequestInventoryForUser(userID, userInfo.FolderReceive, userInfo.ItemReceive); 171 //this.m_parent.InventoryServer.RequestInventoryForUser(userID, userInfo.FolderReceive, userInfo.ItemReceive);
172 172
173 //for now we manually create the root folder, 173 //for now we manually create the root folder,
174 // but should be requesting all inventory from inventory server. 174 // but should be requesting all inventory from inventory server.
175 InventoryFolder folderInfo = new InventoryFolder(); 175 /* InventoryFolder folderInfo = new InventoryFolder();
176 folderInfo.agentID = userID; 176 folderInfo.agentID = userID;
177 folderInfo.folderID = userInfo.UserProfile.rootInventoryFolderID; 177 folderInfo.folderID = userInfo.UserProfile.rootInventoryFolderID;
178 folderInfo.name = "My Inventory"; 178 folderInfo.name = "My Inventory";
179 folderInfo.parentID = LLUUID.Zero; 179 folderInfo.parentID = LLUUID.Zero;
180 folderInfo.type = 8; 180 folderInfo.type = 8;
181 folderInfo.version = 1; 181 folderInfo.version = 1;
182 userInfo.FolderReceive(userID, folderInfo); 182 userInfo.FolderReceive(userID, folderInfo);*/
183 } 183 }
184 184
185 /// <summary> 185 /// <summary>
diff --git a/OpenSim/Framework/Data.SQLite/SQLiteInventoryStore.cs b/OpenSim/Framework/Data.SQLite/SQLiteInventoryStore.cs
new file mode 100644
index 0000000..811a355
--- /dev/null
+++ b/OpenSim/Framework/Data.SQLite/SQLiteInventoryStore.cs
@@ -0,0 +1,401 @@
1using System;
2using System.Collections.Generic;
3using System.Text;
4
5using OpenSim.Framework.Console;
6using OpenSim.Framework.Types;
7using OpenSim.Framework.Utilities;
8using libsecondlife;
9
10using System.Data;
11using System.Data.SqlTypes;
12
13using Mono.Data.SqliteClient;
14
15namespace OpenSim.Framework.Data.SQLite
16{
17
18 public class SQLiteInventoryStore : IInventoryData
19 {
20 private const string invItemsSelect = "select * from inventoryitems";
21 private const string invFoldersSelect = "select * from inventoryfolders";
22
23 private DataSet ds;
24 private SqliteDataAdapter invItemsDa;
25 private SqliteDataAdapter invFoldersDa;
26
27 /// <summary>
28 /// Initialises the interface
29 /// </summary>
30 public void Initialise()
31 {
32 Initialise("inventoryStore.db", "inventoryDatabase");
33 }
34
35 public void Initialise(string dbfile, string dbname)
36 {
37 string connectionString = "URI=file:" + dbfile + ",version=3";
38
39 MainLog.Instance.Verbose("Inventory", "Sqlite - connecting: " + dbfile);
40 SqliteConnection conn = new SqliteConnection(connectionString);
41
42 SqliteCommand itemsSelectCmd = new SqliteCommand(invItemsSelect, conn);
43 invItemsDa = new SqliteDataAdapter(itemsSelectCmd);
44 // SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa);
45
46 SqliteCommand foldersSelectCmd = new SqliteCommand(invFoldersSelect, conn);
47 invFoldersDa = new SqliteDataAdapter(foldersSelectCmd);
48
49 ds = new DataSet();
50
51 invItemsDa.Fill(ds, "inventoryitems");
52 invFoldersDa.Fill(ds, "inventoryfolders");
53 ds.AcceptChanges();
54
55 DataTable itemsTable = ds.Tables["inventoryitems"];
56 itemsTable.PrimaryKey = new DataColumn[] { itemsTable.Columns["UUID"] };
57 setupItemsCommands(invItemsDa, conn);
58
59 // shapeDa.FillSchema(ds, SchemaType.Source, "ShapeSchema");
60 DataTable folderTable = ds.Tables["inventoryfolders"];
61 folderTable.PrimaryKey = new DataColumn[] { folderTable.Columns["UUID"] };
62 setupFoldersCommands(invFoldersDa, conn);
63 return;
64 }
65
66 private SqliteParameter createSqliteParameter(string name, DbType type)
67 {
68 SqliteParameter param = new SqliteParameter();
69 param.ParameterName = ":" + name;
70 param.DbType = type;
71 param.SourceColumn = name;
72 param.SourceVersion = DataRowVersion.Current;
73 return param;
74 }
75
76 private Dictionary<string, DbType> createInventoryItemsDataDefs()
77 {
78 Dictionary<string, DbType> data = new Dictionary<string, DbType>();
79 data.Add("UUID", DbType.String); //inventoryID
80 data.Add("assetID", DbType.String);
81 data.Add("assetType", DbType.Int32);
82 data.Add("invType", DbType.Int32);
83 data.Add("parentFolderID", DbType.String);
84 data.Add("avatarID", DbType.String);
85 data.Add("creatorsID", DbType.String);
86
87 data.Add("inventoryName", DbType.String);
88 data.Add("inventoryDescription", DbType.String);
89 // permissions
90 data.Add("inventoryNextPermissions", DbType.Int32);
91 data.Add("inventoryCurrentPermissions", DbType.Int32);
92 data.Add("inventoryBasePermissions", DbType.Int32);
93 data.Add("inventoryEveryOnePermissions", DbType.Int32);
94
95 return data;
96 }
97
98 private Dictionary<string, DbType> createShapeDataDefs()
99 {
100 Dictionary<string, DbType> data = new Dictionary<string, DbType>();
101 data.Add("UUID", DbType.String); //folderID
102 // shape is an enum
103 data.Add("name", DbType.String);
104 // vectors
105 data.Add("agentID", DbType.String);
106 data.Add("parentID", DbType.String);
107 data.Add("type", DbType.Int32);
108 data.Add("version", DbType.Int32);
109 return data;
110 }
111
112 private SqliteCommand createInsertCommand(string table, Dictionary<string, DbType> defs)
113 {
114 /**
115 * This is subtle enough to deserve some commentary.
116 * Instead of doing *lots* and *lots of hardcoded strings
117 * for database definitions we'll use the fact that
118 * realistically all insert statements look like "insert
119 * into A(b, c) values(:b, :c) on the parameterized query
120 * front. If we just have a list of b, c, etc... we can
121 * generate these strings instead of typing them out.
122 */
123 string[] cols = new string[defs.Keys.Count];
124 defs.Keys.CopyTo(cols, 0);
125
126 string sql = "insert into " + table + "(";
127 sql += String.Join(", ", cols);
128 // important, the first ':' needs to be here, the rest get added in the join
129 sql += ") values (:";
130 sql += String.Join(", :", cols);
131 sql += ")";
132 SqliteCommand cmd = new SqliteCommand(sql);
133
134 // this provides the binding for all our parameters, so
135 // much less code than it used to be
136 foreach (KeyValuePair<string, DbType> kvp in defs)
137 {
138 cmd.Parameters.Add(createSqliteParameter(kvp.Key, kvp.Value));
139 }
140 return cmd;
141 }
142
143 private SqliteCommand createUpdateCommand(string table, string pk, Dictionary<string, DbType> defs)
144 {
145 string sql = "update " + table + " set ";
146 string subsql = "";
147 foreach (string key in defs.Keys)
148 {
149 if (subsql.Length > 0)
150 { // a map function would rock so much here
151 subsql += ", ";
152 }
153 subsql += key + "= :" + key;
154 }
155 sql += subsql;
156 sql += " where " + pk;
157 SqliteCommand cmd = new SqliteCommand(sql);
158
159 // this provides the binding for all our parameters, so
160 // much less code than it used to be
161 foreach (KeyValuePair<string, DbType> kvp in defs)
162 {
163 cmd.Parameters.Add(createSqliteParameter(kvp.Key, kvp.Value));
164 }
165 return cmd;
166 }
167
168 private void setupItemsCommands(SqliteDataAdapter da, SqliteConnection conn)
169 {
170 Dictionary<string, DbType> invDataDefs = createInventoryItemsDataDefs();
171
172 da.InsertCommand = createInsertCommand("inventoryitems", invDataDefs);
173 da.InsertCommand.Connection = conn;
174
175 da.UpdateCommand = createUpdateCommand("inventoryitems", "UUID=:UUID", invDataDefs);
176 da.UpdateCommand.Connection = conn;
177
178 SqliteCommand delete = new SqliteCommand("delete from inventoryitems where UUID = :UUID");
179 delete.Parameters.Add(createSqliteParameter("UUID", DbType.String));
180 delete.Connection = conn;
181 da.DeleteCommand = delete;
182 }
183
184 private void setupFoldersCommands(SqliteDataAdapter da, SqliteConnection conn)
185 {
186 Dictionary<string, DbType> shapeDataDefs = createShapeDataDefs();
187
188 da.InsertCommand = createInsertCommand("inventoryfolders", shapeDataDefs);
189 da.InsertCommand.Connection = conn;
190
191 da.UpdateCommand = createUpdateCommand("inventoryfolders", "UUID=:UUID", shapeDataDefs);
192 da.UpdateCommand.Connection = conn;
193
194 SqliteCommand delete = new SqliteCommand("delete from inventoryfolders where UUID = :UUID");
195 delete.Parameters.Add(createSqliteParameter("UUID", DbType.String));
196 delete.Connection = conn;
197 da.DeleteCommand = delete;
198 }
199
200 private InventoryFolderBase buildFolder(DataRow row)
201 {
202 InventoryFolderBase folder = new InventoryFolderBase();
203 folder.folderID = new LLUUID((string)row["UUID"]);
204 folder.name = (string)row["name"];
205 folder.agentID = new LLUUID((string)row["agentID"]);
206 folder.parentID = new LLUUID((string)row["parentID"]);
207 folder.type = Convert.ToInt16(row["type"]);
208 folder.version = Convert.ToUInt16(row["version"]);
209 return folder;
210 }
211
212 private void fillFolderRow(DataRow row, InventoryFolderBase folder)
213 {
214 row["UUID"] = folder.folderID;
215 row["name"] = folder.name;
216 row["agentID"] = folder.agentID;
217 row["parentID"] = folder.parentID;
218 row["type"] = folder.type;
219 row["version"] = folder.version;
220 }
221
222 private void addFolder(InventoryFolderBase folder)
223 {
224 DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
225
226 DataRow inventoryRow = inventoryFolderTable.Rows.Find(folder.folderID);
227 if (inventoryRow == null)
228 {
229 inventoryRow = inventoryFolderTable.NewRow();
230 fillFolderRow(inventoryRow, folder);
231 inventoryFolderTable.Rows.Add(inventoryRow);
232 }
233 else
234 {
235 fillFolderRow(inventoryRow, folder);
236 }
237
238 this.invFoldersDa.Update(ds, "inventoryfolders");
239 }
240
241 public void Shutdown()
242 {
243 // TODO: DataSet commit
244 }
245
246 /// <summary>
247 /// Closes the interface
248 /// </summary>
249 public void Close()
250 {
251 }
252
253 /// <summary>
254 /// The plugin being loaded
255 /// </summary>
256 /// <returns>A string containing the plugin name</returns>
257 public string getName()
258 {
259 return "SQLite Inventory Data Interface";
260 }
261
262 /// <summary>
263 /// The plugins version
264 /// </summary>
265 /// <returns>A string containing the plugin version</returns>
266 public string getVersion()
267 {
268 return "0.1";
269 }
270
271 /// <summary>
272 /// Returns a list of inventory items contained within the specified folder
273 /// </summary>
274 /// <param name="folderID">The UUID of the target folder</param>
275 /// <returns>A List of InventoryItemBase items</returns>
276 public List<InventoryItemBase> getInventoryInFolder(LLUUID folderID)
277 {
278 return null;
279 }
280
281 /// <summary>
282 /// Returns a list of the root folders within a users inventory
283 /// </summary>
284 /// <param name="user">The user whos inventory is to be searched</param>
285 /// <returns>A list of folder objects</returns>
286 public List<InventoryFolderBase> getUserRootFolders(LLUUID user)
287 {
288 return null;
289 }
290
291 /// <summary>
292 /// Returns the users inventory root folder.
293 /// </summary>
294 /// <param name="user">The UUID of the user who is having inventory being returned</param>
295 /// <returns>Root inventory folder</returns>
296 public InventoryFolderBase getUserRootFolder(LLUUID user)
297 {
298 List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
299 DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
300 string selectExp = "agentID = '"+ user.ToString()+"' AND parentID = '"+ LLUUID.Zero.ToString()+"'";
301 DataRow[] rows = inventoryFolderTable.Select(selectExp);
302 foreach (DataRow row in rows)
303 {
304 folders.Add(this.buildFolder(row));
305 }
306
307 if (folders.Count == 1)
308 {
309 //we found the root
310 //System.Console.WriteLine("found root inventory folder");
311 return folders[0];
312 }
313 else if (folders.Count > 1)
314 {
315 //err shouldn't be more than one root
316 //System.Console.WriteLine("found more than one root inventory folder");
317 }
318 else if (folders.Count == 0)
319 {
320 // no root?
321 //System.Console.WriteLine("couldn't find root inventory folder");
322 }
323
324 return null;
325 }
326
327 /// <summary>
328 /// Returns a list of inventory folders contained in the folder 'parentID'
329 /// </summary>
330 /// <param name="parentID">The folder to get subfolders for</param>
331 /// <returns>A list of inventory folders</returns>
332 public List<InventoryFolderBase> getInventoryFolders(LLUUID parentID)
333 {
334 List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
335 DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
336 string selectExp = "parentID = '" + parentID.ToString() + "'";
337 DataRow[] rows = inventoryFolderTable.Select(selectExp);
338 foreach (DataRow row in rows)
339 {
340 folders.Add(this.buildFolder(row));
341 }
342 // System.Console.WriteLine("found " + folders.Count + " inventory folders");
343 return folders;
344 }
345
346 /// <summary>
347 /// Returns an inventory item by its UUID
348 /// </summary>
349 /// <param name="item">The UUID of the item to be returned</param>
350 /// <returns>A class containing item information</returns>
351 public InventoryItemBase getInventoryItem(LLUUID item)
352 {
353 return null;
354 }
355
356 /// <summary>
357 /// Returns a specified inventory folder by its UUID
358 /// </summary>
359 /// <param name="folder">The UUID of the folder to be returned</param>
360 /// <returns>A class containing folder information</returns>
361 public InventoryFolderBase getInventoryFolder(LLUUID folder)
362 {
363 return null;
364 }
365
366 /// <summary>
367 /// Creates a new inventory item based on item
368 /// </summary>
369 /// <param name="item">The item to be created</param>
370 public void addInventoryItem(InventoryItemBase item)
371 {
372 }
373
374 /// <summary>
375 /// Updates an inventory item with item (updates based on ID)
376 /// </summary>
377 /// <param name="item">The updated item</param>
378 public void updateInventoryItem(InventoryItemBase item)
379 {
380 }
381
382 /// <summary>
383 /// Adds a new folder specified by folder
384 /// </summary>
385 /// <param name="folder">The inventory folder</param>
386 public void addInventoryFolder(InventoryFolderBase folder)
387 {
388 this.addFolder(folder);
389 }
390
391 /// <summary>
392 /// Updates a folder based on its ID with folder
393 /// </summary>
394 /// <param name="folder">The inventory folder</param>
395 public void updateInventoryFolder(InventoryFolderBase folder)
396 {
397 this.addFolder(folder);
398 }
399 }
400}
401
diff --git a/OpenSim/Framework/InventoryServiceBase/InventoryServiceBase.cs b/OpenSim/Framework/InventoryServiceBase/InventoryServiceBase.cs
index f2e6128..10da633 100644
--- a/OpenSim/Framework/InventoryServiceBase/InventoryServiceBase.cs
+++ b/OpenSim/Framework/InventoryServiceBase/InventoryServiceBase.cs
@@ -12,11 +12,11 @@ namespace OpenSim.Framework.InventoryServiceBase
12 public class InventoryServiceBase 12 public class InventoryServiceBase
13 { 13 {
14 protected Dictionary<string, IInventoryData> m_plugins = new Dictionary<string, IInventoryData>(); 14 protected Dictionary<string, IInventoryData> m_plugins = new Dictionary<string, IInventoryData>();
15 protected IAssetServer m_assetServer; 15 //protected IAssetServer m_assetServer;
16 16
17 public InventoryServiceBase(IAssetServer assetServer) 17 public InventoryServiceBase()
18 { 18 {
19 m_assetServer = assetServer; 19 //m_assetServer = assetServer;
20 } 20 }
21 21
22 /// <summary> 22 /// <summary>
@@ -25,7 +25,7 @@ namespace OpenSim.Framework.InventoryServiceBase
25 /// <param name="FileName">The filename to the user server plugin DLL</param> 25 /// <param name="FileName">The filename to the user server plugin DLL</param>
26 public void AddPlugin(string FileName) 26 public void AddPlugin(string FileName)
27 { 27 {
28 MainLog.Instance.Verbose("Inventorytorage: Attempting to load " + FileName); 28 MainLog.Instance.Verbose("Inventory", "Inventorystorage: Attempting to load " + FileName);
29 Assembly pluginAssembly = Assembly.LoadFrom(FileName); 29 Assembly pluginAssembly = Assembly.LoadFrom(FileName);
30 30
31 foreach (Type pluginType in pluginAssembly.GetTypes()) 31 foreach (Type pluginType in pluginAssembly.GetTypes())
@@ -108,13 +108,31 @@ namespace OpenSim.Framework.InventoryServiceBase
108 return itemsList; 108 return itemsList;
109 } 109 }
110 110
111 public void AddFolder(InventoryFolderBase folder)
112 {
113 foreach (KeyValuePair<string, IInventoryData> plugin in m_plugins)
114 {
115 plugin.Value.addInventoryFolder(folder);
116 }
117 }
118
111 /// <summary> 119 /// <summary>
112 /// 120 ///
113 /// </summary> 121 /// </summary>
114 /// <param name="inventory"></param> 122 /// <param name="inventory"></param>
115 public void AddNewInventorySet(UsersInventory inventory) 123 public void AddNewInventorySet(UsersInventory inventory)
116 { 124 {
125 foreach (InventoryFolderBase folder in inventory.Folders.Values)
126 {
127 this.AddFolder(folder);
128 }
129 }
117 130
131 public void CreateNewUserInventory(LLUUID user)
132 {
133 UsersInventory inven = new UsersInventory();
134 inven.CreateNewInventorySet(user);
135 this.AddNewInventorySet(inven);
118 } 136 }
119 137
120 public class UsersInventory 138 public class UsersInventory
@@ -127,9 +145,45 @@ namespace OpenSim.Framework.InventoryServiceBase
127 145
128 } 146 }
129 147
130 protected virtual void CreateNewInventorySet() 148 public virtual void CreateNewInventorySet(LLUUID user)
131 { 149 {
132 150 InventoryFolderBase folder = new InventoryFolderBase();
151 folder.parentID = LLUUID.Zero;
152 folder.agentID = user;
153 folder.folderID = LLUUID.Random();
154 folder.name = "My Inventory";
155 folder.type = 8;
156 folder.version = 1;
157 Folders.Add(folder.folderID, folder);
158
159 LLUUID rootFolder = folder.folderID;
160
161 folder = new InventoryFolderBase();
162 folder.parentID = rootFolder;
163 folder.agentID = user;
164 folder.folderID = LLUUID.Random();
165 folder.name = "Textures";
166 folder.type = 0;
167 folder.version = 1;
168 Folders.Add(folder.folderID, folder);
169
170 folder = new InventoryFolderBase();
171 folder.parentID = rootFolder;
172 folder.agentID = user;
173 folder.folderID = LLUUID.Random();
174 folder.name = "Objects";
175 folder.type = 6;
176 folder.version = 1;
177 Folders.Add(folder.folderID, folder);
178
179 folder = new InventoryFolderBase();
180 folder.parentID = rootFolder;
181 folder.agentID = user;
182 folder.folderID = LLUUID.Random();
183 folder.name = "Clothes";
184 folder.type = 5;
185 folder.version = 1;
186 Folders.Add(folder.folderID, folder);
133 } 187 }
134 } 188 }
135 } 189 }
diff --git a/OpenSim/Framework/UserManager/LoginService.cs b/OpenSim/Framework/UserManager/LoginService.cs
index a26a0c4..b75c4fb 100644
--- a/OpenSim/Framework/UserManager/LoginService.cs
+++ b/OpenSim/Framework/UserManager/LoginService.cs
@@ -89,14 +89,14 @@ namespace OpenSim.Framework.UserManagement
89 LLUUID agentID = userProfile.UUID; 89 LLUUID agentID = userProfile.UUID;
90 90
91 // Inventory Library Section 91 // Inventory Library Section
92 AgentInventory userInventory = this.GetUsersInventory(agentID); 92 InventoryData inventData = this.CreateInventoryData(agentID);
93 ArrayList AgentInventoryArray = this.CreateInventoryArray(userInventory); 93 ArrayList AgentInventoryArray = inventData.InventoryArray;
94 94
95 Hashtable InventoryRootHash = new Hashtable(); 95 Hashtable InventoryRootHash = new Hashtable();
96 InventoryRootHash["folder_id"] = userInventory.InventoryRoot.FolderID.ToStringHyphenated(); 96 InventoryRootHash["folder_id"] = inventData.RootFolderID.ToStringHyphenated();
97 ArrayList InventoryRoot = new ArrayList(); 97 ArrayList InventoryRoot = new ArrayList();
98 InventoryRoot.Add(InventoryRootHash); 98 InventoryRoot.Add(InventoryRootHash);
99 userProfile.rootInventoryFolderID = userInventory.InventoryRoot.FolderID; 99 userProfile.rootInventoryFolderID = inventData.RootFolderID;
100 100
101 // Circuit Code 101 // Circuit Code
102 uint circode = (uint)(Util.RandomClass.Next()); 102 uint circode = (uint)(Util.RandomClass.Next());
@@ -253,16 +253,11 @@ namespace OpenSim.Framework.UserManagement
253 return inventoryLibOwner; 253 return inventoryLibOwner;
254 } 254 }
255 255
256 protected virtual AgentInventory GetUsersInventory(LLUUID agentID) 256 protected virtual InventoryData CreateInventoryData(LLUUID userID)
257 { 257 {
258 AgentInventory userInventory = new AgentInventory(); 258 AgentInventory userInventory = new AgentInventory();
259 userInventory.CreateRootFolder(agentID, false); 259 userInventory.CreateRootFolder(userID, false);
260 260
261 return userInventory;
262 }
263
264 protected virtual ArrayList CreateInventoryArray(AgentInventory userInventory)
265 {
266 ArrayList AgentInventoryArray = new ArrayList(); 261 ArrayList AgentInventoryArray = new ArrayList();
267 Hashtable TempHash; 262 Hashtable TempHash;
268 foreach (InventoryFolder InvFolder in userInventory.InventoryFolders.Values) 263 foreach (InventoryFolder InvFolder in userInventory.InventoryFolders.Values)
@@ -275,7 +270,20 @@ namespace OpenSim.Framework.UserManagement
275 TempHash["folder_id"] = InvFolder.FolderID.ToStringHyphenated(); 270 TempHash["folder_id"] = InvFolder.FolderID.ToStringHyphenated();
276 AgentInventoryArray.Add(TempHash); 271 AgentInventoryArray.Add(TempHash);
277 } 272 }
278 return AgentInventoryArray; 273
274 return new InventoryData(AgentInventoryArray, userInventory.InventoryRoot.FolderID);
275 }
276
277 public class InventoryData
278 {
279 public ArrayList InventoryArray = null;
280 public LLUUID RootFolderID = LLUUID.Zero;
281
282 public InventoryData(ArrayList invList, LLUUID rootID)
283 {
284 InventoryArray = invList;
285 RootFolderID = rootID;
286 }
279 } 287 }
280 } 288 }
281} 289}
generated by cgit v1.1 at 2024-12-22 07:48:14 +0000