public ActionResult DeleteConfirmed(int id)
{
Notecard notecard = db.Notecards.Find(id);
db.Notecards.Remove(notecard);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
Notecard notecard = db.Notecards.Find(id);
db.Notecards.Remove(notecard);
db.SaveChanges();
return(RedirectToAction("Notecards", new { id = (int)Session["DeckID"] }));
}
public ActionResult Edit([Bind(Include = "ID,DeckID,Question,Answer")] Notecard notecard)
{
if (ModelState.IsValid)
{
db.Entry(notecard).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Notecards", new { id = (int)Session["DeckID"] }));
}
return(View(notecard));
}
public ActionResult Edit([Bind(Include = "Id,Owner,DateCreated,LastModified,Font,Back,DeckId,Rating")] Notecard notecard)
{
if (ModelState.IsValid)
{
db.Entry(notecard).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(Json(notecard, JsonRequestBehavior.AllowGet));
}
public ActionResult Create([Bind(Include = "Id,Owner,DateCreated,LastModified,Font,Back,DeckId,Rating")] Notecard notecard)
{
if (ModelState.IsValid)
{
db.Notecards.Add(notecard);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(notecard));
}
public static void CacheCheck()
{
lock (m_Notecards) {
foreach (UUID key in new List <UUID>(m_Notecards.Keys))
{
Notecard nc = m_Notecards[key];
if (nc.lastRef.AddSeconds(30) < DateTime.Now)
{
m_Notecards.Remove(key);
}
}
}
}
// GET: Notecards/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Notecard notecard = db.Notecards.Find(id);
if (notecard == null)
{
return(HttpNotFound());
}
return(Json(notecard, JsonRequestBehavior.AllowGet));
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Notecard notecard = db.Notecards.Find(id);
if (notecard == null)
{
return(HttpNotFound());
}
return(View(notecard));
}
public static void Cache(UUID assetID, string text)
{
CacheCheck();
lock (m_Notecards)
{
if (m_Notecards.ContainsKey(assetID))
return;
Notecard nc = new Notecard();
nc.lastRef = DateTime.Now;
nc.text = ParseText(text.Replace("\r", "").Split('\n'));
m_Notecards[assetID] = nc;
}
}
public static void Cache(UUID assetID, string text)
{
CacheCheck();
lock (m_Notecards) {
if (m_Notecards.ContainsKey(assetID))
{
return;
}
Notecard nc = new Notecard {
lastRef = DateTime.Now, text = SLUtil.ParseNotecardToList(text).ToArray()
};
m_Notecards[assetID] = nc;
}
}
public ActionResult Create(Notecard model)
{
if (ModelState.IsValid)
{
Notecard notecard = new Notecard()
{
DeckID = (int)Session["DeckID"], Question = model.Question, Answer = model.Answer
};
db.Notecards.Add(notecard);
Deck deck = db.Decks.Find((int)Session["DeckID"]);
deck.notecards.Add(notecard);
db.SaveChanges();
return(RedirectToAction("Notecards", new { id = (int)Session["DeckID"] }));
}
return(View(model));
}
private void CreateNpcCommand(List <string> args, Main.Common.CmdIO.TTY io, UUID limitedToScene)
{
UUID ncid;
UGI group = UGI.Unknown;
if (args[0] == "help" || args.Count < 5)
{
io.Write("create npc <firstname> <lastname> <notecardid> [params...] - Remove NPC\n" +
" owner <owner>\n" +
" group <group>\n" +
" position <position>\n" +
" notecard <assetid>|(<primname>:<itemname>)\n" +
" persistent\n" +
" senseasagent");
return;
}
UUID sceneId;
if (limitedToScene != UUID.Zero)
{
sceneId = limitedToScene;
}
else if (io.SelectedScene == UUID.Zero)
{
io.Write("Please select a region first");
return;
}
else
{
sceneId = io.SelectedScene;
}
var options = NpcOptions.None;
var position = new Vector3(128, 128, 23);
SceneInterface scene;
if (!m_KnownScenes.TryGetValue(sceneId, out scene))
{
io.Write("Scene not found");
return;
}
if (!UUID.TryParse(args[4], out ncid))
{
string[] parts = args[4].Split(new char[] { ':' }, 2);
ObjectPart part;
ObjectPartInventoryItem item;
if (parts.Length >= 2 &&
scene.Primitives.TryGetValueByName(parts[0], out part) &&
part.Inventory.TryGetValue(parts[1], out item) &&
item.InventoryType == InventoryType.Notecard)
{
ncid = item.AssetID;
}
else
{
io.Write("Notecard not found by prim / item reference");
return;
}
}
UGUI owner = scene.Owner;
UUID groupid;
for (int argi = 4; argi < args.Count; ++argi)
{
switch (args[argi])
{
case "owner":
if (!scene.AvatarNameService.TranslateToUUI(args[argi + 1], out owner))
{
io.WriteFormatted("{0} is not a valid owner.", args[argi + 1]);
return;
}
break;
case "group":
if (scene.GroupsNameService == null)
{
io.WriteFormatted("Groups not enabled");
return;
}
else if (++argi >= args.Count)
{
io.WriteFormatted("Missing group id");
return;
}
else if (!UUID.TryParse(args[argi], out groupid))
{
io.WriteFormatted("Invalid group id {0}", args[argi]);
return;
}
else if (!scene.GroupsNameService.TryGetValue(groupid, out group))
{
io.WriteFormatted("Invalid group id {0}", groupid);
return;
}
break;
case "position":
if (++argi < args.Count && !Vector3.TryParse(args[argi], out position))
{
position = new Vector3(128, 128, 23);
}
break;
case "persistent":
options |= NpcOptions.Persistent;
break;
case "senseasagent":
options |= NpcOptions.SenseAsAgent;
break;
}
}
AssetData asset;
if (!scene.AssetService.TryGetValue(ncid, out asset))
{
io.Write("Notecard not found");
return;
}
if (asset.Type != AssetType.Notecard)
{
io.Write("Not a notecard");
return;
}
Notecard nc;
try
{
nc = new Notecard(asset);
}
catch
{
io.Write("Not a valid notecard");
return;
}
NpcAgent agent = CreateNpc(sceneId, owner, group, args[2], args[3], position, nc, options);
io.WriteFormatted("Npc {0} {1} ({2}) created", agent.FirstName, agent.LastName, agent.ID);
}
public static void Cache(UUID assetID, string text)
{
CacheCheck();
lock (m_Notecards)
{
if (m_Notecards.ContainsKey(assetID))
return;
Notecard nc = new Notecard();
nc.lastRef = DateTime.Now;
nc.text = SLUtil.ParseNotecardToList(text).ToArray();
m_Notecards[assetID] = nc;
}
}
public NpcAgent CreateNpc(UUID sceneid, UGUI owner, UGI group, string firstName, string lastName, Vector3 position, Notecard nc, NpcOptions options = NpcOptions.None)
{
SceneInterface scene;
AgentServiceList agentServiceList = m_NonpersistentAgentServices;
if ((options & NpcOptions.Persistent) != NpcOptions.None)
{
if (m_NpcPresenceService == null)
{
throw new InvalidOperationException("Persistence of NPCs not configured");
}
agentServiceList = m_PersistentAgentServices;
}
NpcPresenceServiceInterface presenceService = agentServiceList.Get <NpcPresenceServiceInterface>();
InventoryServiceInterface inventoryService = agentServiceList.Get <InventoryServiceInterface>();
var npcId = new UGUIWithName
{
ID = UUID.Random,
FirstName = firstName,
LastName = lastName
};
if (m_KnownScenes.TryGetValue(sceneid, out scene))
{
var agent = new NpcAgent(npcId, agentServiceList, sceneid)
{
NpcOwner = owner,
Group = group
};
try
{
m_NpcAgents.Add(agent.ID, agent);
var npcInfo = new NpcPresenceInfo
{
RegionID = sceneid,
Npc = agent.NamedOwner,
Owner = agent.NpcOwner,
Group = agent.Group,
};
inventoryService.CheckInventory(npcInfo.Npc.ID);
presenceService.Store(npcInfo);
agent.CurrentScene = scene;
agent.Position = position;
scene.Add(agent);
}
catch
{
if (m_NpcPresenceService != null)
{
presenceService.Remove(agent.ID);
}
inventoryService.Remove(agent.ID);
m_NpcAgents.Remove(agent.ID);
throw;
}
agent.EnableListen();
scene.SendAgentObjectToAllAgents(agent);
agent.SendAnimations();
ThreadPool.QueueUserWorkItem(LoadAppearanceFromNotecardJob, new RebakeJob {
Notecard = nc, Agent = agent
});
return(agent);
}
throw new KeyNotFoundException("Scene not found");
}
public bool Run()
{
Notecard notecard;
Notecard ncserialized;
AssetData asset;
var theCreator = new UGUIWithName
{
HomeURI = new Uri("http://example.com/"),
ID = UUID.Random,
FirstName = "The",
LastName = "Creator"
};
m_Log.Info("Testing Notecard without Inventory");
notecard = new Notecard()
{
Text = "The Notecard"
};
asset = notecard.Asset();
ncserialized = new Notecard(asset);
if (ncserialized.Text != notecard.Text)
{
m_Log.Fatal("Notecard Text is not identical");
return(false);
}
if (ncserialized.Inventory.Count != 0)
{
m_Log.Fatal("Notecard Inventory Count is not identical");
return(false);
}
m_Log.Info("Testing Notecard with Inventory");
notecard = new Notecard()
{
Text = "The Notecard"
};
var ncitem = new NotecardInventoryItem()
{
AssetID = UUID.Random,
AssetType = AssetType.CallingCard,
Creator = theCreator,
Description = "Item Description",
Flags = (InventoryFlags)1,
Group = UGI.Unknown,
InventoryType = InventoryType.CallingCard,
IsGroupOwned = true,
LastOwner = theCreator,
Name = "Item Name",
Owner = theCreator,
ParentFolderID = UUID.Random,
ExtCharIndex = 1
};
ncitem.SaleInfo.Price = 10;
ncitem.SaleInfo.Type = InventoryItem.SaleInfoData.SaleType.Copy;
ncitem.Permissions.Base = InventoryPermissionsMask.All;
ncitem.Permissions.Current = InventoryPermissionsMask.All;
ncitem.Permissions.EveryOne = InventoryPermissionsMask.All;
ncitem.Permissions.Group = InventoryPermissionsMask.All;
ncitem.Permissions.NextOwner = InventoryPermissionsMask.All;
notecard.Inventory = new NotecardInventory
{
{ UUID.Random, ncitem }
};
asset = notecard.Asset();
ncserialized = new Notecard(asset);
if (ncserialized.Text != notecard.Text)
{
m_Log.Fatal("Notecard Text is not identical");
return(false);
}
if (ncserialized.Inventory.Count != notecard.Inventory.Count)
{
m_Log.Fatal("Notecard Inventory Count is not identical");
return(false);
}
NotecardInventoryItem ncserializeditem = ncserialized.Inventory[1];
if (ncitem.AssetID != ncserializeditem.AssetID)
{
m_Log.Fatal("Notecard Inventory Item Asset ID is not identical");
return(false);
}
if (ncitem.AssetType != ncserializeditem.AssetType)
{
m_Log.Fatal("Notecard Inventory Item Asset ID is not identical");
return(false);
}
if (ncitem.Creator.ID != ncserializeditem.Creator.ID)
{
m_Log.Fatal("Notecard Inventory Item Creator ID is not identical");
return(false);
}
if (ncitem.Description != ncserializeditem.Description)
{
m_Log.Fatal("Notecard Inventory Item Description is not identical");
return(false);
}
if (ncitem.Flags != ncserializeditem.Flags)
{
m_Log.Fatal("Notecard Inventory Item Flags is not identical");
return(false);
}
if (ncitem.Group.ID != ncserializeditem.Group.ID)
{
m_Log.Fatal("Notecard Inventory Item GroupID is not identical");
return(false);
}
if (ncitem.ID != ncserializeditem.ID)
{
m_Log.Fatal("Notecard Inventory Item ID is not identical");
return(false);
}
if (ncitem.InventoryType != ncserializeditem.InventoryType)
{
m_Log.Fatal("Notecard Inventory Item InventoryType is not identical");
return(false);
}
if (ncitem.LastOwner.ID != ncserializeditem.LastOwner.ID)
{
m_Log.Fatal("Notecard Inventory Item LastOwner is not identical");
return(false);
}
if (ncitem.ParentFolderID != ncserializeditem.ParentFolderID)
{
m_Log.Fatal("Notecard Inventory Item ParentFolderID is not identical");
return(false);
}
if (ncitem.Permissions.Base != ncserializeditem.Permissions.Base)
{
m_Log.Fatal("Notecard Inventory Item Permissions.Base is not identical");
return(false);
}
if (ncitem.Permissions.Current != ncserializeditem.Permissions.Current)
{
m_Log.Fatal("Notecard Inventory Item Permissions.Current is not identical");
return(false);
}
if (ncitem.Permissions.EveryOne != ncserializeditem.Permissions.EveryOne)
{
m_Log.Fatal("Notecard Inventory Item Permissions.EveryOne is not identical");
return(false);
}
if (ncitem.Permissions.Group != ncserializeditem.Permissions.Group)
{
m_Log.Fatal("Notecard Inventory Item Permissions.Group is not identical");
return(false);
}
if (ncitem.Permissions.NextOwner != ncserializeditem.Permissions.NextOwner)
{
m_Log.Fatal("Notecard Inventory Item Permissions.NextOwner is not identical");
return(false);
}
if (ncitem.SaleInfo.Price != ncserializeditem.SaleInfo.Price)
{
m_Log.Fatal("Notecard Inventory Item SaleInfo.Price is not identical");
return(false);
}
if (ncitem.SaleInfo.Type != ncserializeditem.SaleInfo.Type)
{
m_Log.Fatal("Notecard Inventory Item SaleInfo.Type is not identical");
return(false);
}
m_Log.Info("Testing references");
List <UUID> refs = ncserialized.References;
if (refs.Count != 1)
{
m_Log.Fatal("Notecard Inventory Item Reference count is wrong");
return(false);
}
if (!refs.Contains(ncitem.AssetID))
{
m_Log.Fatal("Notecard Inventory Item AssetID is not referenced");
return(false);
}
return(true);
}
public void HandleRezObjectFromNotecard(Message m)
{
var req = (Messages.Object.RezObjectFromNotecard)m;
if (req.AgentID != req.CircuitAgentID || req.SessionID != req.CircuitSessionID)
{
return;
}
SceneInterface scene = Circuits[m.CircuitSceneID].Scene;
ObjectPart part;
Notecard nc;
AssetData data;
if (req.NotecardData.ObjectID == UUID.Zero)
{
/* from inventory */
InventoryItem item;
if (!InventoryService.Item.TryGetValue(req.AgentID, req.NotecardData.NotecardItemID, out item))
{
return;
}
if (item.AssetType != AssetType.Notecard)
{
return;
}
if (!AssetService.TryGetValue(item.AssetID, out data))
{
return;
}
try
{
nc = new Notecard(data);
}
catch
{
return;
}
}
else if (scene.Primitives.TryGetValue(req.NotecardData.ObjectID, out part))
{
/* from object */
ObjectPartInventoryItem item;
if (!part.Inventory.TryGetValue(req.NotecardData.NotecardItemID, out item))
{
return;
}
if (item.AssetType != AssetType.Notecard)
{
return;
}
if (!scene.AssetService.TryGetValue(item.AssetID, out data))
{
return;
}
try
{
nc = new Notecard(data);
}
catch
{
return;
}
}
else
{
return;
}
var assetids = new List <UUID>();
foreach (UUID itemid in req.InventoryData)
{
NotecardInventoryItem item;
if (nc.Inventory.TryGetValue(itemid, out item) && item.AssetType == AssetType.Object)
{
assetids.Add(item.AssetID);
}
}
var rezparams = new SceneInterface.RezObjectParams
{
RayStart = req.RezData.RayStart,
RayEnd = req.RezData.RayEnd,
RayTargetID = req.RezData.RayTargetID,
RayEndIsIntersection = req.RezData.RayEndIsIntersection,
RezSelected = req.RezData.RezSelected,
RemoveItem = req.RezData.RemoveItem,
Scale = Vector3.One,
Rotation = Quaternion.Identity,
ItemFlags = req.RezData.ItemFlags,
GroupMask = req.RezData.GroupMask,
EveryoneMask = req.RezData.EveryoneMask,
NextOwnerMask = req.RezData.NextOwnerMask
};
new AgentRezObjectHandler(
Circuits[m.CircuitSceneID].Scene,
rezparams.RayEnd,
assetids,
AssetService,
Owner,
rezparams).QueueWorkItem();
}
public static void Cache(UUID assetID, byte[] text)
{
CheckCache();
lock (m_Notecards)
{
if (m_Notecards.ContainsKey(assetID))
return;
Notecard nc = new Notecard();
nc.lastRef = DateTime.Now;
try
{
nc.text = SLUtil.ParseNotecardToArray(text);
}
catch(SLUtil.NotANotecardFormatException)
{
nc.text = new string[0];
}
m_Notecards[assetID] = nc;
}
}
public static UUID GenerateNextOwnerAsset(this AssetServiceInterface assetService, UUID firstLevelAssetID)
{
var assetIDs = new List <UUID>();
var replaceAssets = new Dictionary <UUID, UUID>();
var objectAssetIDs = new List <UUID>();
assetIDs.Add(firstLevelAssetID);
int pos = 0;
while (pos < assetIDs.Count)
{
UUID assetid = assetIDs[pos++];
AssetMetadata objmeta;
if (assetService.Metadata.TryGetValue(assetid, out objmeta))
{
if (objmeta.Type == AssetType.Object)
{
if (!objectAssetIDs.Contains(assetid))
{
objectAssetIDs.Add(assetid);
}
assetIDs.AddRange(ObjectReferenceDecoder.GetReferences(assetService[assetid]));
if (!replaceAssets.ContainsKey(assetid))
{
replaceAssets.Add(assetid, UUID.Random);
}
}
else if (objmeta.Type == AssetType.Notecard)
{
if (!objectAssetIDs.Contains(assetid))
{
objectAssetIDs.Add(assetid);
}
var nc = new Notecard(assetService[assetid]);
foreach (NotecardInventoryItem item in nc.Inventory.Values)
{
if ((item.AssetType == AssetType.Object || item.AssetType == AssetType.Notecard) &&
!objectAssetIDs.Contains(item.AssetID))
{
objectAssetIDs.Add(item.AssetID);
}
}
assetIDs.InsertRange(0, nc.References);
if (!replaceAssets.ContainsKey(assetid))
{
replaceAssets.Add(assetid, UUID.Random);
}
}
}
}
objectAssetIDs.Reverse();
foreach (UUID objectid in objectAssetIDs)
{
AssetData data;
AssetData newAsset;
if (assetService.TryGetValue(objectid, out data))
{
switch (data.Type)
{
case AssetType.Object:
List <ObjectGroup> grps = ObjectXML.FromAsset(data, UGUI.Unknown);
foreach (ObjectGroup grp in grps)
{
foreach (ObjectPart part in grp.Values)
{
foreach (ObjectPartInventoryItem item in part.Inventory.Values)
{
if (item.NextOwnerAssetID == UUID.Zero)
{
UUID replaceAssetID;
part.Inventory.SetNextOwnerAssetID(
item.ID,
replaceAssets.TryGetValue(item.AssetID, out replaceAssetID) ? replaceAssetID : item.AssetID);
}
}
}
}
newAsset = (grps.Count == 1) ?
grps[0].Asset(UGUI.Unknown, XmlSerializationOptions.AdjustForNextOwner | XmlSerializationOptions.WriteXml2) :
grps.Asset(UGUI.Unknown, XmlSerializationOptions.AdjustForNextOwner | XmlSerializationOptions.WriteXml2);
newAsset.ID = replaceAssets[objectid];
newAsset.CreateTime = data.CreateTime;
assetService.Store(newAsset);
break;
case AssetType.Notecard:
var nc = new Notecard(data);
foreach (NotecardInventoryItem item in nc.Inventory.Values)
{
UUID replace;
if (replaceAssets.TryGetValue(item.AssetID, out replace))
{
item.AssetID = replace;
}
break;
}
break;
default:
break;
}
}
}
UUID finalAssetID;
return(replaceAssets.TryGetValue(firstLevelAssetID, out finalAssetID) ? finalAssetID : firstLevelAssetID);
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var notecardID = reqmap["notecard-id"].AsUUID;
var objectID = reqmap["object-id"].AsUUID;
var itemID = reqmap["item-id"].AsUUID;
var destinationFolderID = reqmap["folder-id"].AsUUID;
var callbackID = reqmap["callback-id"].AsUInt;
Notecard nc = null;
InventoryFolder destinationFolder = null;
AssetData data;
AssetServiceInterface sourceAssetService = null;
InventoryItem notecarditem;
if (objectID != UUID.Zero)
{
ObjectPart part;
sourceAssetService = m_Scene.AssetService;
if (!m_Scene.Primitives.TryGetValue(objectID, out part))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound);
return;
}
ObjectPartInventoryItem objitem;
if (part.Inventory.TryGetValue(notecardID, out objitem) &&
objitem.InventoryType == InventoryType.Notecard &&
m_Scene.AssetService.TryGetValue(objitem.AssetID, out data))
{
nc = new Notecard(data);
}
notecarditem = objitem;
}
else
{
sourceAssetService = m_Agent.AssetService;
if (m_Agent.InventoryService.Item.TryGetValue(m_Agent.ID, notecardID, out notecarditem) &&
notecarditem.InventoryType == InventoryType.Notecard &&
m_Agent.AssetService.TryGetValue(notecarditem.AssetID, out data))
{
nc = new Notecard(data);
}
}
var transferItems = new List <UUID>();
var destFolder = new Dictionary <AssetType, InventoryFolder>();
InventoryFolder selectedDestFolder = null;
if (nc != null)
{
var invlist = new List <NotecardInventoryItem>();
if (itemID != UUID.Zero)
{
NotecardInventoryItem ncitem;
if (!nc.Inventory.TryGetValue(itemID, out ncitem))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound);
return;
}
else
{
invlist.Add(ncitem);
}
}
else
{
invlist.AddRange(nc.Inventory.Values);
}
foreach (var ncitem in invlist)
{
ncitem.LastOwner = notecarditem.LastOwner;
ncitem.Owner = m_Agent.Owner;
if ((notecarditem.Flags & InventoryFlags.NotecardSlamPerm) != 0)
{
ncitem.AdjustToNextOwner();
}
if ((notecarditem.Flags & InventoryFlags.NotecardSlamSale) != 0)
{
if (notecarditem.AssetType == AssetType.Object)
{
ncitem.Flags |= InventoryFlags.ObjectSlamSale;
}
if (notecarditem.AssetType == AssetType.Notecard)
{
ncitem.Flags |= InventoryFlags.NotecardSlamSale;
}
ncitem.SaleInfo.Type = InventoryItem.SaleInfoData.SaleType.NoSale;
}
try
{
if (destinationFolderID == UUID.Zero)
{
if (!destFolder.ContainsKey(ncitem.AssetType))
{
if (!m_Agent.InventoryService.Folder.TryGetDefaultFolderOrFallback(m_Agent.ID, ncitem.AssetType, out destinationFolder))
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): No Folder found for {3}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, ncitem.AssetType.ToString());
continue;
}
else
{
destFolder.Add(ncitem.AssetType, destinationFolder);
}
}
ncitem.ParentFolderID = destinationFolder.ID;
}
else if (selectedDestFolder != null ||
m_Agent.InventoryService.Folder.TryGetSpecificOrDefaultFolderOrFallback(m_Agent.ID, destinationFolderID, ncitem.AssetType, out selectedDestFolder))
{
ncitem.ParentFolderID = selectedDestFolder.ID;
}
else
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): No Folder found for {3}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, ncitem.AssetType.ToString());
continue;
}
var assetID = CreateInventoryItemFromNotecard(destinationFolder, ncitem, callbackID);
if (!transferItems.Contains(assetID))
{
transferItems.Add(assetID);
}
}
catch (Exception e)
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): {3}: {4}\n{5}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, e.GetType().FullName, e.Message, e.StackTrace);
}
}
if (objectID != UUID.Zero)
{
/* no need to wait for its completion since for the sim processing it the assets are either available through sim assets or user assets
* only transfer assets if it is from prim inventory notecard to user inventory.
*/
new NotecardAssetTransfer(m_Agent.AssetService, sourceAssetService, transferItems).QueueWorkItem();
}
}
using (HttpResponse httpres = httpreq.BeginResponse())
{
httpres.ContentType = "application/llsd+xml";
using (Stream outStream = httpres.GetOutputStream())
{
LlsdXml.Serialize(new Map(), outStream);
}
}
}
public bool Run()
{
var notecard = new Notecard();
return(true);
}
public static void Cache(UUID assetID, byte[] text)
{
CheckCache();
m_Notecards.GetOrAddIfNotExists(assetID,
delegate()
{
Notecard nc = new Notecard();
nc.lastRef = DateTime.Now;
try
{
nc.text = SLUtil.ParseNotecardToArray(text);
}
catch(SLUtil.NotANotecardFormatException e)
{
nc.text = new string[0];
m_log.WarnFormat("[NOTECARD CACHE]: Parsing of notecard asset {0} failed at line number {1}", assetID.ToString(), e.lineNumber);
}
return nc;
});
}
public void LoadAppearanceFromNotecard(Notecard nc)
{
AppearanceInfo appearance = AppearanceInfo.FromNotecard(nc);
InventoryService.CheckInventory(ID);
InventoryService.Folder.Purge(InventoryService.Folder[ID, AssetType.CurrentOutfitFolder].ID);
UUID bodypartsFolder = InventoryService.Folder[ID, AssetType.Bodypart].ID;
UUID clothingFolder = InventoryService.Folder[ID, AssetType.Clothing].ID;
UUID objectFolder = InventoryService.Folder[ID, AssetType.Object].ID;
UUID currentOutfitFolder = InventoryService.Folder[ID, AssetType.CurrentOutfitFolder].ID;
var attachmentsToRez = new List <InventoryItem>();
/* generate inventory entries for wearables */
foreach (KeyValuePair <WearableType, List <AgentWearables.WearableInfo> > kvp in appearance.Wearables.All)
{
UUID targetFolder = clothingFolder;
var assetType = AssetType.Clothing;
switch (kvp.Key)
{
case WearableType.Shape:
case WearableType.Skin:
case WearableType.Hair:
case WearableType.Eyes:
case WearableType.Physics:
targetFolder = bodypartsFolder;
assetType = AssetType.Bodypart;
break;
}
int layer = 0;
foreach (AgentWearables.WearableInfo wInfo in kvp.Value)
{
var item = new InventoryItem(wInfo.ItemID)
{
AssetID = wInfo.AssetID,
LastOwner = Owner,
Owner = Owner,
Creator = UGUI.Unknown,
InventoryType = InventoryType.Wearable,
AssetType = assetType,
Flags = (InventoryFlags)(uint)kvp.Key,
Name = wInfo.ItemID.ToString(),
ParentFolderID = targetFolder
};
item.Permissions.Base = InventoryPermissionsMask.None;
item.Permissions.Current = InventoryPermissionsMask.None;
item.Permissions.EveryOne = InventoryPermissionsMask.None;
item.Permissions.Group = InventoryPermissionsMask.None;
item.Permissions.NextOwner = InventoryPermissionsMask.None;
try
{
InventoryService.Item.Add(item);
}
catch
{
InventoryService.Item.Update(item);
}
item = new InventoryItem
{
LastOwner = Owner,
Owner = Owner,
Creator = Owner,
InventoryType = InventoryType.Wearable,
AssetType = AssetType.Link,
AssetID = wInfo.ItemID,
ParentFolderID = currentOutfitFolder,
Name = wInfo.AssetID.ToString(),
Description = "@" + layer.ToString()
};
item.Permissions.Base = InventoryPermissionsMask.All;
item.Permissions.Current = InventoryPermissionsMask.All;
item.Permissions.EveryOne = InventoryPermissionsMask.None;
item.Permissions.Group = InventoryPermissionsMask.None;
item.Permissions.NextOwner = InventoryPermissionsMask.None;
InventoryService.Item.Add(item);
++layer;
}
}
/* generate inventory entries for attachments */
foreach (KeyValuePair <AttachmentPoint, RwLockedDictionary <UUID, UUID> > kvp in appearance.Attachments)
{
foreach (KeyValuePair <UUID, UUID> kvpInner in kvp.Value)
{
var item = new InventoryItem(kvpInner.Key)
{
AssetID = kvpInner.Value,
LastOwner = Owner,
Owner = Owner,
Creator = UGUI.Unknown,
ParentFolderID = objectFolder,
InventoryType = InventoryType.Object,
AssetType = AssetType.Object,
Flags = (InventoryFlags)(uint)kvp.Key,
Name = kvpInner.Key.ToString()
};
item.Permissions.Base = InventoryPermissionsMask.None;
item.Permissions.Current = InventoryPermissionsMask.None;
item.Permissions.EveryOne = InventoryPermissionsMask.None;
item.Permissions.Group = InventoryPermissionsMask.None;
item.Permissions.NextOwner = InventoryPermissionsMask.None;
try
{
InventoryService.Item.Add(item);
}
catch
{
InventoryService.Item.Update(item);
}
attachmentsToRez.Add(item);
}
}
DetachAllAttachments();
foreach (InventoryItem item in attachmentsToRez)
{
AssetData data;
try
{
data = AssetService[item.AssetID];
}
catch (Exception e)
{
m_Log.WarnFormat("Fetch error for object asset {0} for NPC {1} {2} ({3}): {4}: {5}",
item.AssetID, NamedOwner.FirstName, NamedOwner.LastName, NamedOwner.ID, e.GetType().FullName, e.ToString());
break;
}
if (data.Type != AssetType.Object)
{
m_Log.WarnFormat("Wrong asset for object asset {0} for NPC {1} {2} ({3})",
item.AssetID, NamedOwner.FirstName, NamedOwner.LastName, NamedOwner.ID);
break;
}
AttachFromInventory(data, item.ID);
}
try
{
RebakeAppearance();
}
catch
{
m_Log.WarnFormat("Failed to rebake NPC {0} {1} ({2})",
NamedOwner.FirstName, NamedOwner.LastName, NamedOwner.ID);
}
}
public static AppearanceInfo FromNotecard(Notecard nc)
{
using (var ms = new MemoryStream(nc.Text.ToUTF8Bytes()))
{
var m = LlsdXml.Deserialize(ms) as Map;
if (m == null)
{
throw new InvalidAppearanceInfoSerializationException();
}
var appearanceInfo = new AppearanceInfo
{
AvatarHeight = m["height"].AsReal,
VisualParams = m["visualparams"] as BinaryData
};
var wearables = m["wearables"] as AnArray;
var textures = m["textures"] as AnArray;
foreach (var iv in m["attachments"] as AnArray)
{
var im = iv as Map;
if (im == null)
{
throw new InvalidAppearanceInfoSerializationException();
}
var ap = (AttachmentPoint)im["point"].AsInt;
appearanceInfo.Attachments[ap][im["item"].AsUUID] = im["asset"].AsUUID;
}
AgentWearables wearabledata = new AgentWearables();
for (int i = 0; i < wearables.Count; ++i)
{
var wearablesAt = wearables[i] as AnArray;
if (wearablesAt == null)
{
throw new InvalidAppearanceInfoSerializationException();
}
foreach (var ivw in wearablesAt)
{
var mw = ivw as Map;
if (mw == null)
{
throw new InvalidAppearanceInfoSerializationException();
}
var wi = new AgentWearables.WearableInfo
{
ItemID = mw["item"].AsUUID,
AssetID = mw["asset"].AsUUID
};
wearabledata.Add((WearableType)i, wi);
}
}
appearanceInfo.Wearables = wearabledata;
for (int i = 0; i < textures.Count; ++i)
{
appearanceInfo.AvatarTextures[i] = textures[i].AsUUID;
}
if (m.ContainsKey("serial"))
{
appearanceInfo.Serial = m["serial"].AsInt;
}
return(appearanceInfo);
}
}
