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); } }