mirror of
https://github.com/opensim/opensim.git
synced 2026-05-30 05:57:13 +08:00
749c3fef8a
This is to deal with the hundred lines of command splurge when one previously typed "help" Modelled somewhat on the mysql console One can still type help <command> to get per command help at any point. Categories capitalized to avoid conflict with the all-lowercase commands (except for commander system, as of yet). Does not affect command parsing or any other aspects of the console apart from the help system. Backwards compatible with existing modules.
668 lines
29 KiB
C#
668 lines
29 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using log4net;
|
|
using Nini.Config;
|
|
using OpenMetaverse;
|
|
using OpenSim.Data;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Services.Interfaces;
|
|
using OpenSim.Framework.Console;
|
|
using GridRegion = OpenSim.Services.Interfaces.GridRegion;
|
|
|
|
namespace OpenSim.Services.UserAccountService
|
|
{
|
|
public class UserAccountService : UserAccountServiceBase, IUserAccountService
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
private static UserAccountService m_RootInstance;
|
|
|
|
/// <summary>
|
|
/// Should we create default entries (minimum body parts/clothing, avatar wearable entries) for a new avatar?
|
|
/// </summary>
|
|
private bool m_CreateDefaultAvatarEntries;
|
|
|
|
protected IGridService m_GridService;
|
|
protected IAuthenticationService m_AuthenticationService;
|
|
protected IGridUserService m_GridUserService;
|
|
protected IInventoryService m_InventoryService;
|
|
protected IAvatarService m_AvatarService;
|
|
|
|
public UserAccountService(IConfigSource config)
|
|
: base(config)
|
|
{
|
|
IConfig userConfig = config.Configs["UserAccountService"];
|
|
if (userConfig == null)
|
|
throw new Exception("No UserAccountService configuration");
|
|
|
|
string gridServiceDll = userConfig.GetString("GridService", string.Empty);
|
|
if (gridServiceDll != string.Empty)
|
|
m_GridService = LoadPlugin<IGridService>(gridServiceDll, new Object[] { config });
|
|
|
|
string authServiceDll = userConfig.GetString("AuthenticationService", string.Empty);
|
|
if (authServiceDll != string.Empty)
|
|
m_AuthenticationService = LoadPlugin<IAuthenticationService>(authServiceDll, new Object[] { config });
|
|
|
|
string presenceServiceDll = userConfig.GetString("GridUserService", string.Empty);
|
|
if (presenceServiceDll != string.Empty)
|
|
m_GridUserService = LoadPlugin<IGridUserService>(presenceServiceDll, new Object[] { config });
|
|
|
|
string invServiceDll = userConfig.GetString("InventoryService", string.Empty);
|
|
if (invServiceDll != string.Empty)
|
|
m_InventoryService = LoadPlugin<IInventoryService>(invServiceDll, new Object[] { config });
|
|
|
|
string avatarServiceDll = userConfig.GetString("AvatarService", string.Empty);
|
|
if (avatarServiceDll != string.Empty)
|
|
m_AvatarService = LoadPlugin<IAvatarService>(avatarServiceDll, new Object[] { config });
|
|
|
|
m_CreateDefaultAvatarEntries = userConfig.GetBoolean("CreateDefaultAvatarEntries", false);
|
|
|
|
// In case there are several instances of this class in the same process,
|
|
// the console commands are only registered for the root instance
|
|
if (m_RootInstance == null && MainConsole.Instance != null)
|
|
{
|
|
m_RootInstance = this;
|
|
MainConsole.Instance.Commands.AddCommand("Users", false,
|
|
"create user",
|
|
"create user [<first> [<last> [<pass> [<email> [<user id>]]]]]",
|
|
"Create a new user", HandleCreateUser);
|
|
|
|
MainConsole.Instance.Commands.AddCommand("Users", false,
|
|
"reset user password",
|
|
"reset user password [<first> [<last> [<password>]]]",
|
|
"Reset a user password", HandleResetUserPassword);
|
|
|
|
MainConsole.Instance.Commands.AddCommand("Users", false,
|
|
"set user level",
|
|
"set user level [<first> [<last> [<level>]]]",
|
|
"Set user level. If >= 200 and 'allow_grid_gods = true' in OpenSim.ini, "
|
|
+ "this account will be treated as god-moded. "
|
|
+ "It will also affect the 'login level' command. ",
|
|
HandleSetUserLevel);
|
|
|
|
MainConsole.Instance.Commands.AddCommand("Users", false,
|
|
"show account",
|
|
"show account <first> <last>",
|
|
"Show account details for the given user", HandleShowAccount);
|
|
}
|
|
}
|
|
|
|
#region IUserAccountService
|
|
|
|
public UserAccount GetUserAccount(UUID scopeID, string firstName,
|
|
string lastName)
|
|
{
|
|
// m_log.DebugFormat(
|
|
// "[USER ACCOUNT SERVICE]: Retrieving account by username for {0} {1}, scope {2}",
|
|
// firstName, lastName, scopeID);
|
|
|
|
UserAccountData[] d;
|
|
|
|
if (scopeID != UUID.Zero)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "FirstName", "LastName" },
|
|
new string[] { scopeID.ToString(), firstName, lastName });
|
|
if (d.Length < 1)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "FirstName", "LastName" },
|
|
new string[] { UUID.Zero.ToString(), firstName, lastName });
|
|
}
|
|
}
|
|
else
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "FirstName", "LastName" },
|
|
new string[] { firstName, lastName });
|
|
}
|
|
|
|
if (d.Length < 1)
|
|
return null;
|
|
|
|
return MakeUserAccount(d[0]);
|
|
}
|
|
|
|
private UserAccount MakeUserAccount(UserAccountData d)
|
|
{
|
|
UserAccount u = new UserAccount();
|
|
u.FirstName = d.FirstName;
|
|
u.LastName = d.LastName;
|
|
u.PrincipalID = d.PrincipalID;
|
|
u.ScopeID = d.ScopeID;
|
|
if (d.Data.ContainsKey("Email") && d.Data["Email"] != null)
|
|
u.Email = d.Data["Email"].ToString();
|
|
else
|
|
u.Email = string.Empty;
|
|
u.Created = Convert.ToInt32(d.Data["Created"].ToString());
|
|
if (d.Data.ContainsKey("UserTitle") && d.Data["UserTitle"] != null)
|
|
u.UserTitle = d.Data["UserTitle"].ToString();
|
|
else
|
|
u.UserTitle = string.Empty;
|
|
if (d.Data.ContainsKey("UserLevel") && d.Data["UserLevel"] != null)
|
|
Int32.TryParse(d.Data["UserLevel"], out u.UserLevel);
|
|
if (d.Data.ContainsKey("UserFlags") && d.Data["UserFlags"] != null)
|
|
Int32.TryParse(d.Data["UserFlags"], out u.UserFlags);
|
|
|
|
if (d.Data.ContainsKey("ServiceURLs") && d.Data["ServiceURLs"] != null)
|
|
{
|
|
string[] URLs = d.Data["ServiceURLs"].ToString().Split(new char[] { ' ' });
|
|
u.ServiceURLs = new Dictionary<string, object>();
|
|
|
|
foreach (string url in URLs)
|
|
{
|
|
string[] parts = url.Split(new char[] { '=' });
|
|
|
|
if (parts.Length != 2)
|
|
continue;
|
|
|
|
string name = System.Web.HttpUtility.UrlDecode(parts[0]);
|
|
string val = System.Web.HttpUtility.UrlDecode(parts[1]);
|
|
|
|
u.ServiceURLs[name] = val;
|
|
}
|
|
}
|
|
else
|
|
u.ServiceURLs = new Dictionary<string, object>();
|
|
|
|
return u;
|
|
}
|
|
|
|
public UserAccount GetUserAccount(UUID scopeID, string email)
|
|
{
|
|
UserAccountData[] d;
|
|
|
|
if (scopeID != UUID.Zero)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "Email" },
|
|
new string[] { scopeID.ToString(), email });
|
|
if (d.Length < 1)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "Email" },
|
|
new string[] { UUID.Zero.ToString(), email });
|
|
}
|
|
}
|
|
else
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "Email" },
|
|
new string[] { email });
|
|
}
|
|
|
|
if (d.Length < 1)
|
|
return null;
|
|
|
|
return MakeUserAccount(d[0]);
|
|
}
|
|
|
|
public UserAccount GetUserAccount(UUID scopeID, UUID principalID)
|
|
{
|
|
UserAccountData[] d;
|
|
|
|
if (scopeID != UUID.Zero)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "PrincipalID" },
|
|
new string[] { scopeID.ToString(), principalID.ToString() });
|
|
if (d.Length < 1)
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "ScopeID", "PrincipalID" },
|
|
new string[] { UUID.Zero.ToString(), principalID.ToString() });
|
|
}
|
|
}
|
|
else
|
|
{
|
|
d = m_Database.Get(
|
|
new string[] { "PrincipalID" },
|
|
new string[] { principalID.ToString() });
|
|
}
|
|
|
|
if (d.Length < 1)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return MakeUserAccount(d[0]);
|
|
}
|
|
|
|
public bool StoreUserAccount(UserAccount data)
|
|
{
|
|
// m_log.DebugFormat(
|
|
// "[USER ACCOUNT SERVICE]: Storing user account for {0} {1} {2}, scope {3}",
|
|
// data.FirstName, data.LastName, data.PrincipalID, data.ScopeID);
|
|
|
|
UserAccountData d = new UserAccountData();
|
|
|
|
d.FirstName = data.FirstName;
|
|
d.LastName = data.LastName;
|
|
d.PrincipalID = data.PrincipalID;
|
|
d.ScopeID = data.ScopeID;
|
|
d.Data = new Dictionary<string, string>();
|
|
d.Data["Email"] = data.Email;
|
|
d.Data["Created"] = data.Created.ToString();
|
|
d.Data["UserLevel"] = data.UserLevel.ToString();
|
|
d.Data["UserFlags"] = data.UserFlags.ToString();
|
|
if (data.UserTitle != null)
|
|
d.Data["UserTitle"] = data.UserTitle.ToString();
|
|
|
|
List<string> parts = new List<string>();
|
|
|
|
foreach (KeyValuePair<string, object> kvp in data.ServiceURLs)
|
|
{
|
|
string key = System.Web.HttpUtility.UrlEncode(kvp.Key);
|
|
string val = System.Web.HttpUtility.UrlEncode(kvp.Value.ToString());
|
|
parts.Add(key + "=" + val);
|
|
}
|
|
|
|
d.Data["ServiceURLs"] = string.Join(" ", parts.ToArray());
|
|
|
|
return m_Database.Store(d);
|
|
}
|
|
|
|
public List<UserAccount> GetUserAccounts(UUID scopeID, string query)
|
|
{
|
|
UserAccountData[] d = m_Database.GetUsers(scopeID, query);
|
|
|
|
if (d == null)
|
|
return new List<UserAccount>();
|
|
|
|
List<UserAccount> ret = new List<UserAccount>();
|
|
|
|
foreach (UserAccountData data in d)
|
|
ret.Add(MakeUserAccount(data));
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Console commands
|
|
|
|
/// <summary>
|
|
/// Handle the create user command from the console.
|
|
/// </summary>
|
|
/// <param name="cmdparams">string array with parameters: firstname, lastname, password, locationX, locationY, email</param>
|
|
protected void HandleCreateUser(string module, string[] cmdparams)
|
|
{
|
|
string firstName;
|
|
string lastName;
|
|
string password;
|
|
string email;
|
|
string rawPrincipalId;
|
|
|
|
List<char> excluded = new List<char>(new char[]{' '});
|
|
|
|
if (cmdparams.Length < 3)
|
|
firstName = MainConsole.Instance.CmdPrompt("First name", "Default", excluded);
|
|
else firstName = cmdparams[2];
|
|
|
|
if (cmdparams.Length < 4)
|
|
lastName = MainConsole.Instance.CmdPrompt("Last name", "User", excluded);
|
|
else lastName = cmdparams[3];
|
|
|
|
if (cmdparams.Length < 5)
|
|
password = MainConsole.Instance.PasswdPrompt("Password");
|
|
else password = cmdparams[4];
|
|
|
|
if (cmdparams.Length < 6)
|
|
email = MainConsole.Instance.CmdPrompt("Email", "");
|
|
else email = cmdparams[5];
|
|
|
|
if (cmdparams.Length < 7)
|
|
rawPrincipalId = MainConsole.Instance.CmdPrompt("User ID", UUID.Random().ToString());
|
|
else
|
|
rawPrincipalId = cmdparams[6];
|
|
|
|
UUID principalId = UUID.Zero;
|
|
if (!UUID.TryParse(rawPrincipalId, out principalId))
|
|
throw new Exception(string.Format("ID {0} is not a valid UUID", rawPrincipalId));
|
|
|
|
CreateUser(UUID.Zero, principalId, firstName, lastName, password, email);
|
|
}
|
|
|
|
protected void HandleShowAccount(string module, string[] cmdparams)
|
|
{
|
|
if (cmdparams.Length != 4)
|
|
{
|
|
MainConsole.Instance.Output("Usage: show account <first-name> <last-name>");
|
|
return;
|
|
}
|
|
|
|
string firstName = cmdparams[2];
|
|
string lastName = cmdparams[3];
|
|
|
|
UserAccount ua = GetUserAccount(UUID.Zero, firstName, lastName);
|
|
|
|
if (ua == null)
|
|
{
|
|
MainConsole.Instance.OutputFormat("No user named {0} {1}", firstName, lastName);
|
|
return;
|
|
}
|
|
|
|
MainConsole.Instance.OutputFormat("Name: {0}", ua.Name);
|
|
MainConsole.Instance.OutputFormat("ID: {0}", ua.PrincipalID);
|
|
MainConsole.Instance.OutputFormat("Title: {0}", ua.UserTitle);
|
|
MainConsole.Instance.OutputFormat("E-mail: {0}", ua.Email);
|
|
MainConsole.Instance.OutputFormat("Created: {0}", Utils.UnixTimeToDateTime(ua.Created));
|
|
MainConsole.Instance.OutputFormat("Level: {0}", ua.UserLevel);
|
|
MainConsole.Instance.OutputFormat("Flags: {0}", ua.UserFlags);
|
|
foreach (KeyValuePair<string, Object> kvp in ua.ServiceURLs)
|
|
MainConsole.Instance.OutputFormat("{0}: {1}", kvp.Key, kvp.Value);
|
|
}
|
|
|
|
protected void HandleResetUserPassword(string module, string[] cmdparams)
|
|
{
|
|
string firstName;
|
|
string lastName;
|
|
string newPassword;
|
|
|
|
if (cmdparams.Length < 4)
|
|
firstName = MainConsole.Instance.CmdPrompt("First name");
|
|
else firstName = cmdparams[3];
|
|
|
|
if (cmdparams.Length < 5)
|
|
lastName = MainConsole.Instance.CmdPrompt("Last name");
|
|
else lastName = cmdparams[4];
|
|
|
|
if (cmdparams.Length < 6)
|
|
newPassword = MainConsole.Instance.PasswdPrompt("New password");
|
|
else newPassword = cmdparams[5];
|
|
|
|
UserAccount account = GetUserAccount(UUID.Zero, firstName, lastName);
|
|
if (account == null)
|
|
{
|
|
MainConsole.Instance.OutputFormat("No such user as {0} {1}", firstName, lastName);
|
|
return;
|
|
}
|
|
|
|
bool success = false;
|
|
if (m_AuthenticationService != null)
|
|
success = m_AuthenticationService.SetPassword(account.PrincipalID, newPassword);
|
|
|
|
if (!success)
|
|
MainConsole.Instance.OutputFormat("Unable to reset password for account {0} {1}.", firstName, lastName);
|
|
else
|
|
MainConsole.Instance.OutputFormat("Password reset for user {0} {1}", firstName, lastName);
|
|
}
|
|
|
|
protected void HandleSetUserLevel(string module, string[] cmdparams)
|
|
{
|
|
string firstName;
|
|
string lastName;
|
|
string rawLevel;
|
|
int level;
|
|
|
|
if (cmdparams.Length < 4)
|
|
firstName = MainConsole.Instance.CmdPrompt("First name");
|
|
else firstName = cmdparams[3];
|
|
|
|
if (cmdparams.Length < 5)
|
|
lastName = MainConsole.Instance.CmdPrompt("Last name");
|
|
else lastName = cmdparams[4];
|
|
|
|
UserAccount account = GetUserAccount(UUID.Zero, firstName, lastName);
|
|
if (account == null) {
|
|
MainConsole.Instance.OutputFormat("No such user");
|
|
return;
|
|
}
|
|
|
|
if (cmdparams.Length < 6)
|
|
rawLevel = MainConsole.Instance.CmdPrompt("User level");
|
|
else rawLevel = cmdparams[5];
|
|
|
|
if(int.TryParse(rawLevel, out level) == false) {
|
|
MainConsole.Instance.OutputFormat("Invalid user level");
|
|
return;
|
|
}
|
|
|
|
account.UserLevel = level;
|
|
|
|
bool success = StoreUserAccount(account);
|
|
if (!success)
|
|
MainConsole.Instance.OutputFormat("Unable to set user level for account {0} {1}.", firstName, lastName);
|
|
else
|
|
MainConsole.Instance.OutputFormat("User level set for user {0} {1} to {2}", firstName, lastName, level);
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Create a user
|
|
/// </summary>
|
|
/// <param name="scopeID">Allows hosting of multiple grids in a single database. Normally left as UUID.Zero</param>
|
|
/// <param name="principalID">ID of the user</param>
|
|
/// <param name="firstName"></param>
|
|
/// <param name="lastName"></param>
|
|
/// <param name="password"></param>
|
|
/// <param name="email"></param>
|
|
public UserAccount CreateUser(UUID scopeID, UUID principalID, string firstName, string lastName, string password, string email)
|
|
{
|
|
UserAccount account = GetUserAccount(UUID.Zero, firstName, lastName);
|
|
if (null == account)
|
|
{
|
|
account = new UserAccount(UUID.Zero, principalID, firstName, lastName, email);
|
|
if (account.ServiceURLs == null || (account.ServiceURLs != null && account.ServiceURLs.Count == 0))
|
|
{
|
|
account.ServiceURLs = new Dictionary<string, object>();
|
|
account.ServiceURLs["HomeURI"] = string.Empty;
|
|
account.ServiceURLs["GatekeeperURI"] = string.Empty;
|
|
account.ServiceURLs["InventoryServerURI"] = string.Empty;
|
|
account.ServiceURLs["AssetServerURI"] = string.Empty;
|
|
}
|
|
|
|
if (StoreUserAccount(account))
|
|
{
|
|
bool success;
|
|
if (m_AuthenticationService != null)
|
|
{
|
|
success = m_AuthenticationService.SetPassword(account.PrincipalID, password);
|
|
if (!success)
|
|
m_log.WarnFormat("[USER ACCOUNT SERVICE]: Unable to set password for account {0} {1}.",
|
|
firstName, lastName);
|
|
}
|
|
|
|
GridRegion home = null;
|
|
if (m_GridService != null)
|
|
{
|
|
List<GridRegion> defaultRegions = m_GridService.GetDefaultRegions(UUID.Zero);
|
|
if (defaultRegions != null && defaultRegions.Count >= 1)
|
|
home = defaultRegions[0];
|
|
|
|
if (m_GridUserService != null && home != null)
|
|
m_GridUserService.SetHome(account.PrincipalID.ToString(), home.RegionID, new Vector3(128, 128, 0), new Vector3(0, 1, 0));
|
|
else
|
|
m_log.WarnFormat("[USER ACCOUNT SERVICE]: Unable to set home for account {0} {1}.",
|
|
firstName, lastName);
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("[USER ACCOUNT SERVICE]: Unable to retrieve home region for account {0} {1}.",
|
|
firstName, lastName);
|
|
}
|
|
|
|
if (m_InventoryService != null)
|
|
{
|
|
success = m_InventoryService.CreateUserInventory(account.PrincipalID);
|
|
if (!success)
|
|
{
|
|
m_log.WarnFormat("[USER ACCOUNT SERVICE]: Unable to create inventory for account {0} {1}.",
|
|
firstName, lastName);
|
|
}
|
|
else
|
|
{
|
|
m_log.DebugFormat(
|
|
"[USER ACCOUNT SERVICE]; Created user inventory for {0} {1}", firstName, lastName);
|
|
}
|
|
|
|
if (m_CreateDefaultAvatarEntries)
|
|
CreateDefaultAppearanceEntries(account.PrincipalID);
|
|
}
|
|
|
|
m_log.InfoFormat(
|
|
"[USER ACCOUNT SERVICE]: Account {0} {1} {2} created successfully",
|
|
firstName, lastName, account.PrincipalID);
|
|
}
|
|
else
|
|
{
|
|
m_log.ErrorFormat("[USER ACCOUNT SERVICE]: Account creation failed for account {0} {1}", firstName, lastName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.ErrorFormat("[USER ACCOUNT SERVICE]: A user with the name {0} {1} already exists!", firstName, lastName);
|
|
}
|
|
|
|
return account;
|
|
}
|
|
|
|
private void CreateDefaultAppearanceEntries(UUID principalID)
|
|
{
|
|
m_log.DebugFormat("[USER ACCOUNT SERVICE]: Creating default appearance items for {0}", principalID);
|
|
|
|
InventoryFolderBase bodyPartsFolder = m_InventoryService.GetFolderForType(principalID, AssetType.Bodypart);
|
|
|
|
InventoryItemBase eyes = new InventoryItemBase(UUID.Random(), principalID);
|
|
eyes.AssetID = new UUID("4bb6fa4d-1cd2-498a-a84c-95c1a0e745a7");
|
|
eyes.Name = "Default Eyes";
|
|
eyes.CreatorId = principalID.ToString();
|
|
eyes.AssetType = (int)AssetType.Bodypart;
|
|
eyes.InvType = (int)InventoryType.Wearable;
|
|
eyes.Folder = bodyPartsFolder.ID;
|
|
eyes.BasePermissions = (uint)PermissionMask.All;
|
|
eyes.CurrentPermissions = (uint)PermissionMask.All;
|
|
eyes.EveryOnePermissions = (uint)PermissionMask.All;
|
|
eyes.GroupPermissions = (uint)PermissionMask.All;
|
|
eyes.NextPermissions = (uint)PermissionMask.All;
|
|
eyes.Flags = (uint)WearableType.Eyes;
|
|
m_InventoryService.AddItem(eyes);
|
|
|
|
InventoryItemBase shape = new InventoryItemBase(UUID.Random(), principalID);
|
|
shape.AssetID = AvatarWearable.DEFAULT_BODY_ASSET;
|
|
shape.Name = "Default Shape";
|
|
shape.CreatorId = principalID.ToString();
|
|
shape.AssetType = (int)AssetType.Bodypart;
|
|
shape.InvType = (int)InventoryType.Wearable;
|
|
shape.Folder = bodyPartsFolder.ID;
|
|
shape.BasePermissions = (uint)PermissionMask.All;
|
|
shape.CurrentPermissions = (uint)PermissionMask.All;
|
|
shape.EveryOnePermissions = (uint)PermissionMask.All;
|
|
shape.GroupPermissions = (uint)PermissionMask.All;
|
|
shape.NextPermissions = (uint)PermissionMask.All;
|
|
shape.Flags = (uint)WearableType.Shape;
|
|
m_InventoryService.AddItem(shape);
|
|
|
|
InventoryItemBase skin = new InventoryItemBase(UUID.Random(), principalID);
|
|
skin.AssetID = AvatarWearable.DEFAULT_SKIN_ASSET;
|
|
skin.Name = "Default Skin";
|
|
skin.CreatorId = principalID.ToString();
|
|
skin.AssetType = (int)AssetType.Bodypart;
|
|
skin.InvType = (int)InventoryType.Wearable;
|
|
skin.Folder = bodyPartsFolder.ID;
|
|
skin.BasePermissions = (uint)PermissionMask.All;
|
|
skin.CurrentPermissions = (uint)PermissionMask.All;
|
|
skin.EveryOnePermissions = (uint)PermissionMask.All;
|
|
skin.GroupPermissions = (uint)PermissionMask.All;
|
|
skin.NextPermissions = (uint)PermissionMask.All;
|
|
skin.Flags = (uint)WearableType.Skin;
|
|
m_InventoryService.AddItem(skin);
|
|
|
|
InventoryItemBase hair = new InventoryItemBase(UUID.Random(), principalID);
|
|
hair.AssetID = AvatarWearable.DEFAULT_HAIR_ASSET;
|
|
hair.Name = "Default Hair";
|
|
hair.CreatorId = principalID.ToString();
|
|
hair.AssetType = (int)AssetType.Bodypart;
|
|
hair.InvType = (int)InventoryType.Wearable;
|
|
hair.Folder = bodyPartsFolder.ID;
|
|
hair.BasePermissions = (uint)PermissionMask.All;
|
|
hair.CurrentPermissions = (uint)PermissionMask.All;
|
|
hair.EveryOnePermissions = (uint)PermissionMask.All;
|
|
hair.GroupPermissions = (uint)PermissionMask.All;
|
|
hair.NextPermissions = (uint)PermissionMask.All;
|
|
hair.Flags = (uint)WearableType.Hair;
|
|
m_InventoryService.AddItem(hair);
|
|
|
|
InventoryFolderBase clothingFolder = m_InventoryService.GetFolderForType(principalID, AssetType.Clothing);
|
|
|
|
InventoryItemBase shirt = new InventoryItemBase(UUID.Random(), principalID);
|
|
shirt.AssetID = AvatarWearable.DEFAULT_SHIRT_ASSET;
|
|
shirt.Name = "Default Shirt";
|
|
shirt.CreatorId = principalID.ToString();
|
|
shirt.AssetType = (int)AssetType.Clothing;
|
|
shirt.InvType = (int)InventoryType.Wearable;
|
|
shirt.Folder = clothingFolder.ID;
|
|
shirt.BasePermissions = (uint)PermissionMask.All;
|
|
shirt.CurrentPermissions = (uint)PermissionMask.All;
|
|
shirt.EveryOnePermissions = (uint)PermissionMask.All;
|
|
shirt.GroupPermissions = (uint)PermissionMask.All;
|
|
shirt.NextPermissions = (uint)PermissionMask.All;
|
|
shirt.Flags = (uint)WearableType.Shirt;
|
|
m_InventoryService.AddItem(shirt);
|
|
|
|
InventoryItemBase pants = new InventoryItemBase(UUID.Random(), principalID);
|
|
pants.AssetID = AvatarWearable.DEFAULT_PANTS_ASSET;
|
|
pants.Name = "Default Pants";
|
|
pants.CreatorId = principalID.ToString();
|
|
pants.AssetType = (int)AssetType.Clothing;
|
|
pants.InvType = (int)InventoryType.Wearable;
|
|
pants.Folder = clothingFolder.ID;
|
|
pants.BasePermissions = (uint)PermissionMask.All;
|
|
pants.CurrentPermissions = (uint)PermissionMask.All;
|
|
pants.EveryOnePermissions = (uint)PermissionMask.All;
|
|
pants.GroupPermissions = (uint)PermissionMask.All;
|
|
pants.NextPermissions = (uint)PermissionMask.All;
|
|
pants.Flags = (uint)WearableType.Pants;
|
|
m_InventoryService.AddItem(pants);
|
|
|
|
if (m_AvatarService != null)
|
|
{
|
|
m_log.DebugFormat("[USER ACCOUNT SERVICE]: Creating default avatar entries for {0}", principalID);
|
|
|
|
AvatarWearable[] wearables = new AvatarWearable[6];
|
|
wearables[AvatarWearable.EYES] = new AvatarWearable(eyes.ID, eyes.AssetID);
|
|
wearables[AvatarWearable.BODY] = new AvatarWearable(shape.ID, shape.AssetID);
|
|
wearables[AvatarWearable.SKIN] = new AvatarWearable(skin.ID, skin.AssetID);
|
|
wearables[AvatarWearable.HAIR] = new AvatarWearable(hair.ID, hair.AssetID);
|
|
wearables[AvatarWearable.SHIRT] = new AvatarWearable(shirt.ID, shirt.AssetID);
|
|
wearables[AvatarWearable.PANTS] = new AvatarWearable(pants.ID, pants.AssetID);
|
|
|
|
AvatarAppearance ap = new AvatarAppearance();
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
ap.SetWearable(i, wearables[i]);
|
|
}
|
|
|
|
m_AvatarService.SetAppearance(principalID, ap);
|
|
}
|
|
}
|
|
}
|
|
} |