public AvatarAppearance GetAndEnsureAppearance(UUID principalID, string defaultUserAvatarArchive, out bool loadedArchive)
{
loadedArchive = false;
AvatarAppearance avappearance = GetAppearance(principalID);
if (avappearance == null)
{
// Create an appearance for the user if one doesn't exist
if (defaultUserAvatarArchive != "")
{
AvatarArchive arch = m_ArchiveService.LoadAvatarArchive(defaultUserAvatarArchive, principalID);
if (arch != null)
{
avappearance = arch.Appearance;
SetAppearance(principalID, avappearance);
loadedArchive = true;
}
}
if (avappearance == null)//Set as Ruth
{
avappearance = new AvatarAppearance(principalID);
SetAppearance(principalID, avappearance);
}
}
return(avappearance);
}
/// <summary>
/// Gets all public avatar archives
/// </summary>
/// <returns></returns>
public List <AvatarArchive> GetAvatarArchives()
{
var archives = new List <AvatarArchive>();
if (Directory.Exists(m_storeDirectory))
{
foreach (string file in Directory.GetFiles(m_storeDirectory, "*.aa"))
{
try
{
AvatarArchive archive = new AvatarArchive();
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(file)));
if (archive.IsPublic)
{
archives.Add(archive);
}
}
catch
{
}
}
}
return(archives);
}
/// <summary>
/// Returns a list object of AvatarArchives. This is being used for WebUI
/// </summary>
/// <param name = "Public"></param>
/// <returns></returns>
public List <AvatarArchive> GetAvatarArchives(bool isPublic)
{
List <AvatarArchive> returnValue = new List <AvatarArchive>();
try
{
IDataReader RetVal = GD.QueryData("where IsPublic = 1", "avatararchives", "Name, Snapshot, IsPublic");
while (RetVal.Read())
{
AvatarArchive Archive = new AvatarArchive
{
Name = RetVal["Name"].ToString(),
Snapshot = RetVal["Snapshot"].ToString(),
IsPublic = int.Parse(RetVal["IsPublic"].ToString())
};
returnValue.Add(Archive);
}
RetVal.Close();
RetVal.Dispose();
}
catch
{
}
GD.CloseDatabase();
return(returnValue);
}
/// <summary>
/// Returns a list object of AvatarArchives. This is being used for WebUI
/// </summary>
/// <param name = "Public"></param>
/// <returns></returns>
public List <AvatarArchive> GetAvatarArchives(bool isPublic)
{
List <AvatarArchive> returnValue = new List <AvatarArchive>();
DataReaderConnection RetVal = null;
try
{
RetVal = GD.QueryData("where IsPublic = 1", "avatararchives", "Name, Snapshot, IsPublic");
while (RetVal.DataReader.Read())
{
AvatarArchive Archive = new AvatarArchive
{
Name = RetVal.DataReader["Name"].ToString(),
Snapshot = RetVal.DataReader["Snapshot"].ToString(),
IsPublic = int.Parse(RetVal.DataReader["IsPublic"].ToString())
};
returnValue.Add(Archive);
}
}
catch
{
GD.CloseDatabase(RetVal);
}
return(returnValue);
}
public void SaveAvatarArchive(AvatarArchive archive)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["Name"] = archive.Name;
List <string> Check = GD.Query(new string[] { "Name" }, "avatararchives", filter, null, null, null);
if (Check.Count == 0)
{
GD.Insert("avatararchives", new object[] {
archive.Name,
archive.ArchiveXML,
archive.Snapshot,
archive.IsPublic
});
}
else
{
Dictionary <string, object> values = new Dictionary <string, object>(1);
values["Archive"] = archive.ArchiveXML;
values["Snapshot"] = archive.Snapshot;
values["IsPublic"] = archive.IsPublic;
GD.Update("avatararchives", values, null, filter, null, null);
}
}
/// <summary>
/// Gets all public avatar archives
/// </summary>
/// <returns></returns>
public List <AvatarArchive> GetAvatarArchives()
{
var archives = new List <AvatarArchive> ();
if (Directory.Exists(m_storeDirectory))
{
foreach (string file in Directory.GetFiles(m_storeDirectory, "*.aa"))
{
try {
AvatarArchive archive = new AvatarArchive();
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(file)));
if (archive.IsPublic)
{
//check for a local snapshot
var localPic = Path.ChangeExtension(file, "jpg");
if (File.Exists(localPic))
{
archive.LocalSnapshot = localPic;
}
else
{
archive.LocalSnapshot = string.Empty;
}
archives.Add(archive);
}
} catch {
MainConsole.Instance.ErrorFormat("[Avatar Archiver]: error deserializing {0} archive", file);
}
}
}
return(archives);
}
public AvatarArchive LoadAvatarArchive(string fileName, UUID principalID)
{
AvatarArchive archive = new AvatarArchive();
UserAccount account = UserAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return(null);
}
if (!File.Exists(fileName))
{
MainConsole.Instance.Error("[AvatarArchive]: Unable to load from file: file does not exist!");
return(null);
}
MainConsole.Instance.Info("[AvatarArchive]: Loading archive from " + fileName);
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(fileName)));
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(archive.BodyMap);
appearance.Owner = principalID;
InventoryFolderBase AppearanceFolder = InventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
AssetType.Clothing);
List <InventoryItemBase> items = new List <InventoryItemBase>();
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), archive.FolderName, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
InventoryService.AddFolder(folderForAppearance);
folderForAppearance = InventoryService.GetFolder(folderForAppearance);
try
{
LoadAssets(archive.AssetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance,
account.PrincipalID, archive.ItemsMap, out items);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
MainConsole.Instance.Info("[AvatarArchive]: Loaded archive from " + fileName);
archive.Appearance = appearance;
return(archive);
}
public bool SaveAvatarArchive(string fileName, UUID principalID, string folderName, UUID snapshotUUID, bool isPublic)
{
UserAccount account = UserAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return(false);
}
AvatarAppearance appearance = AvatarService.GetAppearance(account.PrincipalID);
if (appearance == null)
{
MainConsole.Instance.Error("[AvatarArchive] Appearance not found!");
return(false);
}
AvatarArchive archive = new AvatarArchive();
archive.AssetsMap = new OSDMap();
archive.BodyMap = appearance.Pack();
archive.Appearance = appearance;
archive.ItemsMap = new OSDMap();
foreach (AvatarWearable wear in appearance.Wearables)
{
for (int i = 0; i < wear.Count; i++)
{
WearableItem w = wear[i];
if (w.AssetID != UUID.Zero)
{
SaveItem(w.ItemID, ref archive);
SaveAsset(w.AssetID, ref archive);
}
}
}
List <AvatarAttachment> attachments = appearance.GetAttachments();
foreach (AvatarAttachment a in attachments.Where(a => a.AssetID != UUID.Zero))
{
SaveItem(a.ItemID, ref archive);
SaveAsset(a.AssetID, ref archive);
}
archive.FolderName = folderName;
archive.Snapshot = snapshotUUID;
archive.IsPublic = isPublic;
File.WriteAllText(fileName, OSDParser.SerializeLLSDXmlString(archive.ToOSD()));
MainConsole.Instance.Info("[AvatarArchive] Saved archive to " + fileName);
return(true);
}
private void SaveItem(UUID ItemID, ref AvatarArchive archive)
{
InventoryItemBase saveItem = InventoryService.GetItem(UUID.Zero, ItemID);
if (saveItem == null)
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not find item to save: " + ItemID);
return;
}
MainConsole.Instance.Info("[AvatarArchive]: Saving item " + ItemID.ToString());
archive.ItemsMap[ItemID.ToString()] = saveItem.ToOSD();
}
public AvatarArchive LoadAvatarArchive(string fileName, UUID principalID)
{
AvatarArchive archive = new AvatarArchive();
UserAccount account = UserAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return null;
}
if (!File.Exists(fileName))
{
MainConsole.Instance.Error("[AvatarArchive]: Unable to load from file: file does not exist!");
return null;
}
MainConsole.Instance.Info("[AvatarArchive]: Loading archive from " + fileName);
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(fileName)));
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(archive.BodyMap);
appearance.Owner = principalID;
InventoryFolderBase AppearanceFolder = InventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
AssetType.Clothing);
List<InventoryItemBase> items = new List<InventoryItemBase>();
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), archive.FolderName, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
InventoryService.AddFolder(folderForAppearance);
folderForAppearance = InventoryService.GetFolder(folderForAppearance);
try
{
LoadAssets(archive.AssetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance,
account.PrincipalID, out items);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
MainConsole.Instance.Info("[AvatarArchive]: Loaded archive from " + fileName);
archive.Appearance = appearance;
return archive;
}
public AvatarArchive GetAvatarArchive(string Name)
{
List <string> RetVal = GD.Query("Name", Name, "avatararchives", "*");
if (RetVal.Count == 0)
{
return(null);
}
AvatarArchive Archive = new AvatarArchive();
Archive.Name = RetVal[0];
Archive.ArchiveXML = RetVal[1];
return(Archive);
}
/// <summary>
/// Returns a list object of AvatarArchives. This is being used for wiredux
/// </summary>
/// <param name="Public"></param>
/// <returns></returns>
public List <AvatarArchive> GetAvatarArchives(bool isPublic)
{
List <AvatarArchive> returnValue = new List <AvatarArchive>();
IDataReader RetVal = GD.QueryDataFull("where IsPublic = 1", "avatararchives", "Name, Snapshot, IsPublic");
while (RetVal.Read())
{
AvatarArchive Archive = new AvatarArchive();
Archive.Name = RetVal["Name"].ToString();
Archive.Snapshot = RetVal["Snapshot"].ToString();
Archive.IsPublic = int.Parse(RetVal["IsPublic"].ToString());
returnValue.Add(Archive);
}
return(returnValue);
}
public void SaveAvatarArchive(AvatarArchive archive)
{
List <string> Check = GD.Query("Name", archive.Name, "avatararchives", "Name");
if (Check.Count == 0)
{
GD.Insert("avatararchives", new object[] {
archive.Name,
archive.ArchiveXML,
archive.Snapshot,
archive.IsPublic
});
}
else
{
GD.Update("avatararchives", new object[] { archive.ArchiveXML }, new string[] { "Archive" }, new string[] { "Name" }, new object[] { archive.Name });
}
}
public List<AvatarArchive> GetAvatarArchives()
{
List<AvatarArchive> archives = new List<AvatarArchive>();
foreach (string file in Directory.GetFiles(Environment.CurrentDirectory, "*.aa"))
{
try
{
AvatarArchive archive = new AvatarArchive();
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(file)));
if (archive.IsPublic)
archives.Add(archive);
}
catch
{
}
}
return archives;
}
void SaveAsset(UUID AssetID, ref AvatarArchive archive, bool isPortable)
{
IDictionary <UUID, AssetType> assetUuids = new Dictionary <UUID, AssetType> ();
AssetBase assetBase = assetService.Get(AssetID.ToString());
if (assetBase == null)
{
return;
}
if (isPortable)
{
assetGatherer.GatherAssetUuids(assetBase.ID, assetBase.TypeAsset, assetUuids);
}
else
{
// we need this one at least
assetUuids [assetBase.ID] = assetBase.TypeAsset;
}
assetBase.Dispose();
// was //assetBase = null;
// save the required assets
foreach (KeyValuePair <UUID, AssetType> kvp in assetUuids)
{
var asset = assetService.Get(kvp.Key.ToString());
if (asset != null)
{
MainConsole.Instance.Debug("[Avatar Archiver]: Saving asset " + asset.ID);
archive.AssetsMap [asset.ID.ToString()] = asset.ToOSD();
}
else
{
MainConsole.Instance.Debug("[Avatar Archiver]: Could not find asset to save: " + kvp.Key);
return;
}
asset.Dispose();
//was//asset = null;
}
}
private void SaveAsset(UUID AssetID, ref AvatarArchive archive)
{
try
{
AssetBase asset = AssetService.Get(AssetID.ToString());
if (asset != null)
{
MainConsole.Instance.Info("[AvatarArchive]: Saving asset " + asset.ID);
archive.AssetsMap[asset.ID.ToString()] = asset.ToOSD();
}
else
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not find asset to save: " + AssetID.ToString());
return;
}
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not save asset: " + AssetID.ToString() + ", " + ex);
}
}
protected void HandleLoadAvatarArchive(IScene scene, string[] cmdparams)
{
if (cmdparams.Length != 6)
{
MainConsole.Instance.Info("[AvatarArchive]: Not enough parameters!");
return;
}
UserAccount account = UserAccountService.GetUserAccount(null, cmdparams[3] + " " + cmdparams[4]);
if (account == null)
{
MainConsole.Instance.Info("[AvatarArchive]: No such account found!");
return;
}
AvatarArchive archive = LoadAvatarArchive(cmdparams[5], account.PrincipalID);
if (archive != null)
{
AvatarService.SetAppearance(account.PrincipalID, archive.Appearance);
}
}
public void SaveAvatarArchive(AvatarArchive archive)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["Name"] = archive.Name;
List <string> Check = GD.Query(new string[] { "Name" }, "avatararchives", filter, null, null, null);
if (Check.Count == 0)
{
GD.Insert("avatararchives", new object[]
{
archive.Name.MySqlEscape(),
archive.ArchiveXML,
archive.Snapshot.MySqlEscape(),
archive.IsPublic
});
}
else
{
GD.Update("avatararchives", new object[] { archive.ArchiveXML }, new[] { "Archive" }, new[] { "Name" }, new object[] { archive.Name.MySqlEscape() });
}
}
/// <summary>
/// Handles loading of an avatar archive.
/// </summary>
/// <param name="scene">Scene.</param>
/// <param name="cmdparams">Cmdparams.</param>
protected void HandleLoadAvatarArchive(IScene scene, string[] cmdparams)
{
string userName;
string fileName;
if (cmdparams.Length < 5)
{
userName = MainConsole.Instance.Prompt("Avatar name for archive upload (<first> <last>)", "");
if (userName == "")
{
return;
}
}
else
{
userName = cmdparams [3] + " " + cmdparams [4];
}
UserAccount account = userAccountService.GetUserAccount(null, userName);
if (account == null)
{
MainConsole.Instance.Info("[AvatarArchive]: Sorry, unable to find an account for " + userName + "!");
return;
}
// filename to load
if (cmdparams.Length < 6)
{
do
{
fileName = MainConsole.Instance.Prompt("Avatar archive filename to load (? for list)", "");
if (fileName == "?")
{
var archives = GetAvatarArchiveFilenames();
MainConsole.Instance.CleanInfo(" Available archives are : ");
foreach (string avatar in archives)
{
MainConsole.Instance.CleanInfo(" " + avatar);
}
}
} while (fileName == "?");
if (fileName == "")
{
return;
}
}
else
{
fileName = cmdparams [5];
}
//some file sanity checks
fileName = PathHelpers.VerifyReadFile(fileName, ".aa", m_storeDirectory);
if (fileName == "")
{
return;
}
AvatarArchive archive = LoadAvatarArchive(fileName, account.PrincipalID);
if (archive != null)
{
avatarService.SetAppearance(account.PrincipalID, archive.Appearance);
}
}
private void SaveAsset(UUID AssetID, ref AvatarArchive archive)
{
try
{
AssetBase asset = AssetService.Get(AssetID.ToString());
if (asset != null)
{
MainConsole.Instance.Info("[AvatarArchive]: Saving asset " + asset.ID);
archive.AssetsMap[asset.ID.ToString()] = asset.ToOSD();
}
else
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not find asset to save: " + AssetID.ToString());
return;
}
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not save asset: " + AssetID.ToString() + ", " + ex);
}
}
private void SaveItem(UUID ItemID, ref AvatarArchive archive)
{
InventoryItemBase saveItem = InventoryService.GetItem(UUID.Zero, ItemID);
if (saveItem == null)
{
MainConsole.Instance.Warn("[AvatarArchive]: Could not find item to save: " + ItemID);
return;
}
MainConsole.Instance.Info("[AvatarArchive]: Saving item " + ItemID.ToString());
archive.ItemsMap[ItemID.ToString()] = saveItem.ToOSD();
}
public bool SaveAvatarArchive(string fileName, UUID principalID, string folderName, UUID snapshotUUID, bool isPublic)
{
UserAccount account = UserAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return false;
}
AvatarAppearance appearance = AvatarService.GetAppearance(account.PrincipalID);
if (appearance == null)
{
MainConsole.Instance.Error("[AvatarArchive] Appearance not found!");
return false;
}
AvatarArchive archive = new AvatarArchive();
archive.AssetsMap = new OSDMap();
archive.BodyMap = appearance.Pack();
archive.Appearance = appearance;
archive.ItemsMap = new OSDMap();
foreach (AvatarWearable wear in appearance.Wearables)
{
for (int i = 0; i < wear.Count; i++)
{
WearableItem w = wear[i];
if (w.AssetID != UUID.Zero)
{
SaveItem(w.ItemID, ref archive);
SaveAsset(w.AssetID, ref archive);
}
}
}
List<AvatarAttachment> attachments = appearance.GetAttachments();
foreach (AvatarAttachment a in attachments.Where(a => a.AssetID != UUID.Zero))
{
SaveItem(a.ItemID, ref archive);
SaveAsset(a.AssetID, ref archive);
}
archive.FolderName = folderName;
archive.Snapshot = snapshotUUID;
archive.IsPublic = isPublic;
File.WriteAllText(fileName, OSDParser.SerializeLLSDXmlString(archive.ToOSD()));
MainConsole.Instance.Info("[AvatarArchive] Saved archive to " + fileName);
return true;
}
public AvatarAppearance LoadAvatarArchive(string FileName, string Name)
{
UserAccount account = UserAccountService.GetUserAccount(null, Name);
MainConsole.Instance.Info("[AvatarArchive] Loading archive from " + FileName);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive] User not found!");
return(null);
}
string archiveXML = "";
if (FileName.EndsWith(".database"))
{
IAvatarArchiverConnector archiver = DataManager.DataManager.RequestPlugin <IAvatarArchiverConnector>();
if (archiver != null)
{
AvatarArchive archive = archiver.GetAvatarArchive(FileName.Substring(0, FileName.LastIndexOf(".database")));
archiveXML = archive.ArchiveXML;
}
else
{
MainConsole.Instance.Error("[AvatarArchive] Unable to load from database!");
return(null);
}
}
else
{
StreamReader reader = new StreamReader(FileName);
archiveXML = reader.ReadToEnd();
reader.Close();
reader.Dispose();
}
IScenePresence SP = null;
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (IScene scene in manager.GetAllScenes())
{
if (scene.TryGetScenePresence(account.PrincipalID, out SP))
{
break;
}
}
if (SP == null)
{
return(null); //Bad people!
}
}
if (SP != null)
{
SP.ControllingClient.SendAlertMessage("Appearance loading in progress...");
}
string FolderNameToLoadInto = "";
OSDMap map = ((OSDMap)OSDParser.DeserializeLLSDXml(archiveXML));
OSDMap assetsMap = ((OSDMap)map["Assets"]);
//OSDMap itemsMap = ((OSDMap)map["Items"]);
OSDMap bodyMap = ((OSDMap)map["Body"]);
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(bodyMap, out FolderNameToLoadInto);
appearance.Owner = account.PrincipalID;
InventoryFolderBase AppearanceFolder = InventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
AssetType.Clothing);
List <InventoryItemBase> items = new List <InventoryItemBase>();
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), FolderNameToLoadInto, account.PrincipalID,
-1, AppearanceFolder.ID, 1);
InventoryService.AddFolder(folderForAppearance);
folderForAppearance = InventoryService.GetFolder(folderForAppearance);
try
{
LoadAssets(assetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance, account.PrincipalID, out items);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
//Now update the client about the new items
if (SP != null)
{
SP.ControllingClient.SendBulkUpdateInventory(folderForAppearance);
}
MainConsole.Instance.Info("[AvatarArchive] Loaded archive from " + FileName);
return(appearance);
}
public AvatarArchive LoadAvatarArchive(string fileName, UUID principalID)
{
AvatarArchive archive = new AvatarArchive();
UserAccount account = userAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[Avatar Archiver]: User not found!");
return(null);
}
// need to be smart here...
fileName = PathHelpers.VerifyReadFile(fileName, ".aa", m_storeDirectory);
if (!File.Exists(fileName))
{
MainConsole.Instance.Error("[Avatar Archiver]: Unable to load from file: file does not exist!");
return(null);
}
MainConsole.Instance.Info("[Avatar Archiver]: Loading archive from " + fileName);
archive.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(File.ReadAllText(fileName)));
AvatarAppearance appearance = ConvertXMLToAvatarAppearance(archive.BodyMap);
appearance.Owner = principalID;
InventoryFolderBase AppearanceFolder = inventoryService.GetFolderForType(account.PrincipalID,
InventoryType.Wearable,
FolderType.Clothing);
if (AppearanceFolder == null)
{
AppearanceFolder = new InventoryFolderBase(); // does not exist so...
AppearanceFolder.Owner = account.PrincipalID;
AppearanceFolder.ID = UUID.Random();
AppearanceFolder.Type = (short)FolderType.Clothing;
}
List <InventoryItemBase> items;
InventoryFolderBase folderForAppearance
= new InventoryFolderBase(
UUID.Random(), archive.FolderName, account.PrincipalID,
(short)FolderType.None, AppearanceFolder.ID, 1);
inventoryService.AddFolder(folderForAppearance);
folderForAppearance = inventoryService.GetFolder(folderForAppearance);
try {
LoadAssets(archive.AssetsMap);
appearance = CopyWearablesAndAttachments(account.PrincipalID, UUID.Zero, appearance, folderForAppearance,
account.PrincipalID, archive.ItemsMap, out items);
} catch (Exception ex) {
MainConsole.Instance.Warn("[AvatarArchiver]: Error loading assets and items, " + ex);
}
/* implement fully if we need to
* // inform the client if needed
*
* ScenePresence SP;
* MainConsole.Instance.ConsoleScenes[0].TryGetScenePresence(account.PrincipalID, out SP);
* if (SP == null)
* return; // nobody home!
*
* SP.ControllingClient.SendAlertMessage("Appearance loading in progress...");
* SP.ControllingClient.SendBulkUpdateInventory(folderForAppearance);
*/
MainConsole.Instance.Info("[Avatar Archiver]: Loaded archive from " + fileName);
archive.Appearance = appearance;
return(archive);
}
/// <summary>
/// Saves the avatar archive.
/// </summary>
/// <returns><c>true</c>, if avatar archive was saved, <c>false</c> otherwise.</returns>
/// <param name="fileName">File name.</param>
/// <param name="principalID">Principal I.</param>
/// <param name="folderName">Folder name.</param>
/// <param name="snapshotUUID">Snapshot UUI.</param>
/// <param name="isPublic">If set to <c>true</c> is public.</param>
public bool SaveAvatarArchive(string fileName, UUID principalID, string folderName, UUID snapshotUUID, bool isPublic)
{
UserAccount account = userAccountService.GetUserAccount(null, principalID);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive]: User not found!");
return(false);
}
AvatarAppearance appearance = avatarService.GetAppearance(account.PrincipalID);
if (appearance == null)
{
MainConsole.Instance.Error("[AvatarArchive] Appearance not found!");
return(false);
}
string archiveName = Path.GetFileNameWithoutExtension(fileName);
string filePath = Path.GetDirectoryName(fileName);
AvatarArchive archive = new AvatarArchive();
archive.AssetsMap = new OSDMap();
archive.ItemsMap = new OSDMap();
int wearCount = 0;
foreach (AvatarWearable wear in appearance.Wearables)
{
for (int i = 0; i < wear.Count; i++)
{
WearableItem w = wear[i];
if (w.AssetID != UUID.Zero)
{
SaveItem(w.ItemID, ref archive);
SaveAsset(w.AssetID, ref archive);
wearCount++;
}
}
}
MainConsole.Instance.InfoFormat("[AvatarArchive] Adding {0} wearables to {1}", wearCount, archiveName);
int attachCount = 0;
List <AvatarAttachment> attachments = appearance.GetAttachments();
foreach (AvatarAttachment a in attachments.Where(a => a.AssetID != UUID.Zero))
{
SaveItem(a.ItemID, ref archive);
SaveAsset(a.AssetID, ref archive);
attachCount++;
}
MainConsole.Instance.InfoFormat("[AvatarArchive] Adding {0} attachments to {1}", attachCount, archiveName);
// set details
archive.Appearance = appearance;
archive.BodyMap = appearance.Pack();
archive.FolderName = folderName;
archive.Snapshot = snapshotUUID;
archive.IsPublic = isPublic;
File.WriteAllText(fileName, OSDParser.SerializeLLSDXmlString(archive.ToOSD()));
if (snapshotUUID != UUID.Zero)
{
ExportArchiveImage(snapshotUUID, archiveName, filePath);
MainConsole.Instance.Info("[AvatarArchive] Saved archive snapshot");
}
MainConsole.Instance.Info("[AvatarArchive] Saved archive to " + fileName);
return(true);
}
protected void HandleSaveAvatarArchive(string[] cmdparams)
{
if (cmdparams.Length < 7)
{
MainConsole.Instance.Info("[AvatarArchive] Not enough parameters!");
}
UserAccount account = UserAccountService.GetUserAccount(null, cmdparams[3] + " " + cmdparams[4]);
if (account == null)
{
MainConsole.Instance.Error("[AvatarArchive] User not found!");
return;
}
IScenePresence SP = null;
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (IScene scene in manager.GetAllScenes())
{
if (scene.TryGetScenePresence(account.PrincipalID, out SP))
{
break;
}
}
if (SP == null)
{
return; //Bad people!
}
}
if (SP != null)
{
SP.ControllingClient.SendAlertMessage("Appearance saving in progress...");
}
AvatarAppearance appearance = AvatarService.GetAppearance(account.PrincipalID);
if (appearance == null)
{
IAvatarAppearanceModule appearancemod = m_registry.RequestModuleInterface <IAvatarAppearanceModule>();
appearance = appearancemod.Appearance;
}
OSDMap map = new OSDMap();
OSDMap body = new OSDMap();
OSDMap assets = new OSDMap();
OSDMap items = new OSDMap();
body = appearance.Pack();
body.Add("FolderName", OSD.FromString(cmdparams[6]));
foreach (AvatarWearable wear in appearance.Wearables)
{
for (int i = 0; i < wear.Count; i++)
{
WearableItem w = wear[i];
if (w.AssetID != UUID.Zero)
{
SaveItem(w.ItemID, items, assets);
SaveAsset(w.AssetID, assets);
}
}
}
List <AvatarAttachment> attachments = appearance.GetAttachments();
#if (!ISWIN)
foreach (AvatarAttachment a in attachments)
{
if (a.AssetID != UUID.Zero)
{
SaveItem(a.ItemID, items, assets);
SaveAsset(a.AssetID, assets);
}
}
#else
foreach (AvatarAttachment a in attachments.Where(a => a.AssetID != UUID.Zero))
{
SaveItem(a.ItemID, items, assets);
SaveAsset(a.AssetID, assets);
}
#endif
map.Add("Body", body);
map.Add("Assets", assets);
map.Add("Items", items);
//Write the map
if (cmdparams[5].EndsWith(".database"))
{
IAvatarArchiverConnector archiver = DataManager.DataManager.RequestPlugin <IAvatarArchiverConnector>();
if (archiver != null)
{
AvatarArchive archive = new AvatarArchive();
archive.ArchiveXML = OSDParser.SerializeLLSDXmlString(map);
// Add the extra details for archives
archive.Name = cmdparams[5].Substring(0, cmdparams[5].LastIndexOf(".database"));
if (cmdparams.Length > 7)
{
if (cmdparams.Contains("--snapshot"))
{
UUID snapshot;
int index = 0;
for (; index < cmdparams.Length; index++)
{
if (cmdparams[index] == "--snapshot")
{
index++;
break;
}
}
if (index < cmdparams.Length && UUID.TryParse(cmdparams[index], out snapshot))
{
archive.Snapshot = snapshot.ToString();
}
}
else
{
archive.Snapshot = UUID.Zero.ToString();
}
if (cmdparams.Contains("--public"))
{
archive.IsPublic = 1;
}
}
else
{
archive.Snapshot = UUID.Zero.ToString();
archive.IsPublic = 0;
}
// Save the archive
archiver.SaveAvatarArchive(archive);
MainConsole.Instance.Info("[AvatarArchive] Saved archive to database as: " + archive.Name);
}
else
{
MainConsole.Instance.Error("[AvatarArchive] Unable to save to database!");
return;
}
}
else
{
StreamWriter writer = new StreamWriter(cmdparams[5], false);
writer.Write(OSDParser.SerializeLLSDXmlString(map));
writer.Close();
writer.Dispose();
MainConsole.Instance.Info("[AvatarArchive] Saved archive to " + cmdparams[5]);
}
}
