public Yield GetUsers(DreamContext context, DreamMessage request, Result <DreamMessage> response) { // TODO (steveb): add 'emailfilter' and use it to obsolete 'usernameemailfilter'; 'usernamefilter', 'fullnamefilter', and 'emailfilter' // should be OR'ed together when they are present. PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ); uint totalCount; uint queryCount; var users = UserBL.GetUsersByQuery(context, null, out totalCount, out queryCount); XDoc result = new XDoc("users"); result.Attr("count", users.Count()); result.Attr("querycount", queryCount); result.Attr("totalcount", totalCount); result.Attr("href", DekiContext.Current.ApiUri.At("users")); bool verbose = context.GetParam <bool>("verbose", true); foreach (UserBE u in users) { if (verbose) { result.Add(UserBL.GetUserXmlVerbose(u, null, Utils.ShowPrivateUserInfo(u), true, true)); } else { result.Add(UserBL.GetUserXml(u, null, Utils.ShowPrivateUserInfo(u))); } } response.Return(DreamMessage.Ok(result)); yield break; }
private IEnumerable <XDoc> YieldAll(int limit, int offset) { var docResults = new List <QueryItem>(); _catalog.NewQuery(string.Format("SELECT id, revision, doc FROM {0} ORDER BY {0}.id{1}", _name, GetLimitAndOffsetClause(limit, offset))) .Execute(delegate(IDataReader dr) { while (dr.Read()) { var docResult = new QueryItem { Id = dr.GetInt32(0), Revision = dr.GetInt32(1), Doc = dr.GetString(2) }; docResults.Add(docResult); } }); foreach (var docResult in docResults) { XDoc doc = XDocFactory.From(docResult.Doc, MimeType.TEXT_XML); Map(doc); doc.Attr("docstore:revision", docResult.Revision); doc.Attr("docstore:id", docResult.Id); yield return(doc); } }
public void WriteConfig() { XDoc exportDocument = new XDoc("config") .Attr("archive", Archive) .Add(ExportDocument); switch (Mode) { case Mode.Export: exportDocument.Attr("export", true); break; case Mode.Copy: exportDocument.Attr("copy", true); break; } if (DekiApi != null) { exportDocument.Attr("uri", DekiApi.Uri); } if (!string.IsNullOrEmpty(User)) { exportDocument.Attr("user", User); } if (!string.IsNullOrEmpty(Password)) { exportDocument.Attr("password", Password); } if (!string.IsNullOrEmpty(AuthToken)) { exportDocument.Attr("authtoken", AuthToken); } if (!string.IsNullOrEmpty(FilePath)) { exportDocument.Elem("target", FilePath); } if (Mode != Import.Mode.Export && !string.IsNullOrEmpty(ImportReltoPath)) { exportDocument.Attr("importreltopath", ImportReltoPath); } if (Mode != Import.Mode.Import && !string.IsNullOrEmpty(ExportReltoPath)) { exportDocument.Attr("exportreltopath", ExportReltoPath); } if (ImportRelto.HasValue) { exportDocument.Attr("importrelto", ImportRelto.Value); } if (ExportRelto.HasValue) { exportDocument.Attr("exportrelto", ExportRelto.Value); } string dir = Path.GetDirectoryName(Path.GetFullPath(_genConfigPath)); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } exportDocument.Save(_genConfigPath); }
/// <summary> /// Query the collection based on an indexed key in the document. /// </summary> /// <param name="keyName">Name of the index key.</param> /// <param name="keyValue">Value of the key.</param> /// <param name="offset">Offset into collection.</param> /// <param name="limit">Maximum number of documents to retrieve.</param> /// <returns>Enumerable of matching documents.</returns> public IEnumerable <XDoc> Get(string keyName, string keyValue, int offset, int limit) { var info = _indexer.GetIndexInfo(keyName); if (info == null) { throw new ArgumentException(string.Format("No key '{0}' defined", keyName), "keyName"); } var docs = new List <XDoc>(); _catalog.NewQuery(string.Format("SELECT id, revision, doc FROM {0} LEFT JOIN {1} ON {0}.id = {1}.ref_id WHERE {1}.idx_value = ?KEY ORDER BY {0}.id{2}", _name, info.Table, GetLimitAndOffsetClause(limit, offset))) .With("KEY", keyValue) .Execute(delegate(IDataReader reader) { while (reader.Read()) { XDoc doc = XDocFactory.From(reader.GetString(2), MimeType.TEXT_XML); Map(doc); foreach (XDoc match in doc[info.XPath]) { if (StringUtil.EqualsInvariant(match.AsText, keyValue)) { int id = reader.GetInt32(0); int revision = reader.GetInt32(1); doc.Attr("docstore:revision", revision); doc.Attr("docstore:id", id); docs.Add(doc); break; } } } }); return(docs); }
public Yield GetGroupUsers(DreamContext context, DreamMessage request, Result <DreamMessage> response) { PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ); GroupBE group = GetGroupFromUrl(); DreamMessage responseMsg = null; uint totalCount; uint queryCount; var usersInGroup = UserBL.GetUsersByQuery(context, group.Id, out totalCount, out queryCount); XDoc ret = new XDoc("users"); ret.Attr("count", usersInGroup.Count()); ret.Attr("querycount", queryCount); ret.Attr("totalcount", totalCount); ret.Attr("href", DekiContext.Current.ApiUri.At("groups", group.Id.ToString(), "users")); foreach (UserBE member in usersInGroup) { ret.Add(UserBL.GetUserXml(member, null, Utils.ShowPrivateUserInfo(member))); } responseMsg = DreamMessage.Ok(ret); response.Return(responseMsg); yield break; }
public static XDoc GetGroupXmlVerbose(GroupBE group, string relation) { XDoc groupXml = GetGroupXml(group, relation); ServiceBE authService = ServiceBL.GetServiceById(group.ServiceId); if (authService != null) { groupXml.Add(ServiceBL.GetServiceXml(authService, "authentication")); } groupXml.Start("users"); if (group.UserIdsList != null) { groupXml.Attr("count", group.UserIdsList.Length); } groupXml.Attr("href", DekiContext.Current.ApiUri.At("groups", group.Id.ToString(), "users")); groupXml.End(); //Permissions for the group RoleBE role = PermissionsBL.GetRoleById(group.RoleId); groupXml.Add(PermissionsBL.GetRoleXml(role, "group")); return(groupXml); }
public XDoc GetAttachmentRevisionListXml(IList <ResourceBE> fileList, XUri href) { XDoc attachmentListDoc = null; attachmentListDoc = new XDoc("files"); attachmentListDoc.Attr("count", fileList == null ? 0 : fileList.Count); if (href != null) { attachmentListDoc.Attr("href", href); } if (fileList != null) { List <ResourceBE> sortedFiles = new List <ResourceBE>(fileList); sortedFiles = SortFileListByNameAndRevision(sortedFiles); //HACK: Convenient place to ensure all images that haven't been identified are looked at IdentifyUnknownImages(sortedFiles); //Add attachment info to list wrapper xml foreach (ResourceBE att in sortedFiles) { attachmentListDoc.Add(GetFileXml(att, true, null, null)); } } return(attachmentListDoc); }
private static XDoc AppendBanXml(XDoc doc, BanBE ban) { UserBE createdBy = UserBL.GetUserById(ban.ByUserId); doc.Attr("id", ban.Id); doc.Attr("href", DekiContext.Current.ApiUri.At("site", "bans", ban.Id.ToString())); if (createdBy != null) { doc.Add(UserBL.GetUserXml(createdBy, "createdby", Utils.ShowPrivateUserInfo(createdBy))); } doc.Elem("date.modified", ban.LastEdit); doc.Elem("description", ban.Reason); doc.Elem("date.expires", ban.Expires); doc.Add(PermissionsBL.GetPermissionXml(ban.RevokeMask, "revoked")); doc.Start("ban.addresses"); if (ban.BanAddresses != null) { foreach (string address in ban.BanAddresses) { doc.Elem("address", address); } } doc.End(); doc.Start("ban.users"); if (ban.BanUserIds != null) { var banUsers = DbUtils.CurrentSession.Users_GetByIds(ban.BanUserIds); foreach (UserBE u in banUsers) { doc.Add(UserBL.GetUserXml(u, null, Utils.ShowPrivateUserInfo(createdBy))); } } doc.End(); return(doc); }
public XDoc GetTagXml(TagBE tag, bool showPages, string pageFilterLanguage) { string uriText = null, titleText = null; switch (tag.Type) { case TagType.DEFINE: uriText = Utils.AsPublicUiUri(tag.DefinedTo.Title); titleText = tag.Name; break; case TagType.DATE: uriText = _dekiContext.UiUri.Uri.AtPath("Special:Events").With("from", tag.Name).ToString(); DateTime date = DateTime.ParseExact(tag.Name, "yyyy-MM-dd", _culture, DateTimeStyles.None); titleText = date.ToString("D", _culture); break; case TagType.TEXT: if (null != tag.DefinedTo) { uriText = Utils.AsPublicUiUri(tag.DefinedTo.Title); } else { uriText = _dekiContext.UiUri.AtPath("Special:Tags").With("tag", tag.Name).ToString(); } titleText = tag.Name; break; } XDoc result = new XDoc("tag"); result.Attr("value", tag.PrefixedName); result.Attr("id", tag.Id); result.Attr("href", _dekiContext.ApiUri.At("site", "tags", tag.Id.ToString()).ToString()); if (tag.OccuranceCount > 0) { result.Attr("count", tag.OccuranceCount); } result.Elem("type", tag.Type.ToString().ToLowerInvariant()); result.Elem("uri", uriText); result.Elem("title", titleText); if (null != tag.RelatedPages) { result.Add(PageBL.GetPageListXml(tag.RelatedPages, "related")); } if (showPages) { IList <PageBE> pages = GetTaggedPages(tag); if (pageFilterLanguage != null) { // filter pages by language pages = (from page in pages where page.Language == pageFilterLanguage select page).ToList(); } result.Add(PageBL.GetPageListXml(pages, "pages")); } return(result); }
public static XDoc ConvertFromXSpan(XDoc xspanWidget) { XDoc data = XDoc.FromXSpan(xspanWidget); data.Attr("id", xspanWidget["@widgetid"].Contents); data.Attr("type", xspanWidget["@widgettype"].Contents); return(data); }
public static XDoc GetServiceXml(ServiceBE service, string relation) { XDoc serviceXml = new XDoc(string.IsNullOrEmpty(relation) ? "service" : "service." + relation); serviceXml.Attr("id", service.Id); serviceXml.Attr("href", DekiContext.Current.ApiUri.At("site", "services", service.Id.ToString())); return(serviceXml); }
public XDoc SlideShow( [DekiExtParam("list of image URIs")] ArrayList uris, [DekiExtParam("slideshow width (default: 300px)", true)] float?width, [DekiExtParam("slideshow height (default: 300px)", true)] float?height, [DekiExtParam("interval in seconds (default: 5.0)", true)] double?interval, [DekiExtParam("slideshow effect; one of {slideright, slideleft, slideup, squeezeleft, squeezeright, squeezeup, squeezedown, fadeout} (default: 'fadeout')", true)] string effect ) { // convert URIs to XUri objects XUri[] xuris = new XUri[uris.Count]; for (int i = 0; i < uris.Count; ++i) { xuris[i] = SysUtil.ChangeType <XUri>(uris[i]); if (xuris[i] == null) { throw new ArgumentNullException(string.Format("entry {0} is null", i)); } } // create response document string id = "_" + StringUtil.CreateAlphaNumericKey(8); XDoc result = new XDoc("html") .Start("head") .Start("link").Attr("type", "text/css").Attr("rel", "stylesheet").Attr("href", Files.At("slideshow.css")).End() .Start("script").Attr("type", "text/javascript").Attr("src", Files.At("slideshow.js")).End() .End(); result.Start("body") .Start("div").Attr("id", id).Attr("class", "yui-sldshw-displayer").Attr("style", string.Format("width:{0};height:{1};", AsSize(width ?? 300), AsSize(height ?? 300))); // add each image int counter = 0; foreach (XUri uri in xuris) { ++counter; result.Start("img"); result.Attr("id", id + counter); if (counter == 1) { result.Attr("class", "yui-sldshw-active yui-sldshw-frame"); } else { result.Attr("class", "yui-sldshw-cached yui-sldshw-frame"); } result.Attr("src", uri).Attr("onclick", string.Format("{0}.transition();", id)).End(); } result.End().End(); // add code to kick star the slideshow result.Start("tail") .Start("script").Attr("type", "text/javascript") .Value(string.Format("var {0} = new YAHOO.myowndb.slideshow('{0}', {{ interval: {1}, effect: YAHOO.myowndb.slideshow.effects.{2} }}); {0}.loop();", id, (int)((interval ?? 5.0) * 1000), (effect ?? "fadeOut").ToLowerInvariant())) .End(); result.End(); return(result); }
public static XDoc GetGroupXml(GroupBE group, string relation) { XDoc groupXml = new XDoc(string.IsNullOrEmpty(relation) ? "group" : "group." + relation); groupXml.Attr("id", group.Id); groupXml.Attr("href", DekiContext.Current.ApiUri.At("groups", group.Id.ToString())); groupXml.Start("groupname").Value(group.Name).End(); return(groupXml); }
public void LogSpaceConversion(XDoc spaceManifest, string space, string confUrl, string mtPath) { string xpath = string.Format("space[@space='{0}']", space); XDoc spaceXml = spaceManifest[xpath]; if(spaceXml.IsEmpty) { spaceManifest.Start("url"); spaceManifest.Attr("space", space); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, confUrl, false, false)); spaceManifest.Attr("mt.path", mtPath); spaceManifest.End(); } }
private XDoc GetFileXml(IList <ResourceBE> files, bool verbose, bool list, string fileSuffix, bool?explicitRevisionInfo, int?totalCount, XUri listUri) { Dictionary <uint, UserBE> users = new Dictionary <uint, UserBE>(); Dictionary <ulong, PageBE> pages = new Dictionary <ulong, PageBE>(); List <uint> parentIds = new List <uint>(); //Collect related entity id's foreach (ResourceBE f in files) { users[f.UserId] = null; pages[f.ParentPageId.Value] = null; parentIds.Add(f.ResourceId); } //Perform batch lookups of related entities users = _session.Users_GetByIds(users.Keys.ToArray()).AsHash(e => e.ID); if (verbose) { pages = PageBL.GetPagesByIdsPreserveOrder(pages.Keys.ToArray()).AsHash(e => e.ID); } //Associate properties with the given attachments files = _resourceBL.PopulateChildren(files.ToArray(), new[] { ResourceBE.Type.PROPERTY }, explicitRevisionInfo ?? false); XDoc ret = XDoc.Empty; if (list) { List <ResourceBE> sortedFiles = new List <ResourceBE>(files); files = SortFileListByNameAndRevision(sortedFiles).ToArray(); ret = new XDoc(string.IsNullOrEmpty(fileSuffix) ? "files" : "files." + fileSuffix); ret.Attr("count", files.Count); if (totalCount != null) { ret.Attr("totalcount", totalCount.Value); } if (listUri != null) { ret.Attr("href", listUri); } } foreach (ResourceBE f in files) { UserBE updatedByUser; PageBE parentPage; users.TryGetValue(f.UserId, out updatedByUser); pages.TryGetValue(f.ParentPageId.Value, out parentPage); ret = AppendFileXml(ret, f, fileSuffix, explicitRevisionInfo, updatedByUser, parentPage); } return(ret); }
public void AppendXml(XDoc doc) { doc.Start("param").Attr("name", Name).Attr("type", DekiScriptLiteral.AsScriptTypeName(ScriptType)); if (Default.IsNil) { doc.Attr("optional", Optional ? "true" : null); } else { doc.Attr("default", Default.ToString()); } doc.Value(Hint); doc.End(); }
public void LogSpaceConversion(XDoc spaceManifest, string space, string confUrl, string mtPath) { string xpath = string.Format("space[@space='{0}']", space); XDoc spaceXml = spaceManifest[xpath]; if (spaceXml.IsEmpty) { spaceManifest.Start("url"); spaceManifest.Attr("space", space); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, confUrl, false, false)); spaceManifest.Attr("mt.path", mtPath); spaceManifest.End(); } }
public void LogCommentConversion(XDoc spaceManifest, string space, RemoteComment comment, string mtPath) { string xpath = string.Format("comment[@c.commentid='{0}']", comment.id); XDoc commentXml = spaceManifest[xpath]; if(commentXml.IsEmpty) { spaceManifest.Start("comment"); spaceManifest.Attr("c.space", space); spaceManifest.Attr("c.commentid", comment.id); spaceManifest.Attr("c.pageid", comment.pageId); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, comment.url, true, false)); spaceManifest.Attr("mt.path", mtPath); spaceManifest.End(); } }
public static XDoc GetUserMetricsXml(UserBE user) { var metrics = DbUtils.CurrentSession.Users_GetUserMetrics(user.ID); var ret = new XDoc("metrics"); ret.Attr("user.id", user.ID); ret.Attr("href", DekiContext.Current.ApiUri.At("users", user.ID.ToString(), "metrics")); ret.Elem("metric.comments", metrics.CommentPosts); ret.Elem("metric.pages-created", metrics.PagesCreated); ret.Elem("metric.pages-edited", metrics.PagesChanged); ret.Elem("metric.files-added", metrics.FilesUploaded); ret.Elem("metric.ratings-up", metrics.UpRatings); ret.Elem("metric.ratings-down", metrics.DownRatings); return(ret); }
private static void EnsureAttribute(XDoc doc, string attr, string def) { if (doc["@" + attr].IsEmpty) { doc.Attr(attr, def); } }
public void LogCommentConversion(XDoc spaceManifest, string space, RemoteComment comment, string mtPath) { string xpath = string.Format("comment[@c.commentid='{0}']", comment.id); XDoc commentXml = spaceManifest[xpath]; if (commentXml.IsEmpty) { spaceManifest.Start("comment"); spaceManifest.Attr("c.space", space); spaceManifest.Attr("c.commentid", comment.id); spaceManifest.Attr("c.pageid", comment.pageId); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, comment.url, true, false)); spaceManifest.Attr("mt.path", mtPath); spaceManifest.End(); } }
public void LogUserConversion(XDoc spaceManifest, string confUserName, string mtUserId, string mtUserName, string confUserUrl) { string xpath = string.Format("user[@c.username='******']", confUserName); XDoc userXml = spaceManifest[xpath]; if (userXml.IsEmpty) { spaceManifest.Start("user"); spaceManifest.Attr("c.username", confUserName); spaceManifest.Attr("mt.userid", mtUserId); spaceManifest.Attr("mt.username", mtUserName); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, confUserUrl, false, true)); spaceManifest.Attr("mt.path", Utils.GetDekiUserPageByUserName(mtUserName)); spaceManifest.End(); } }
private void BuildResultXmlFragment(XDoc doc, LoggedSearchResultBE pick) { doc.Attr("type", pick.Type.ToString().ToLower()) .Elem("date.selected", pick.Created) .Start("page") .Attr("id", pick.PageId) .Attr("href", _apiUri.At("pages", pick.PageId.ToString()).AsPublicUri()) .End(); switch (pick.Type) { case SearchResultType.File: doc.Start("file") .Attr("id", pick.TypeId) .Attr("href", _apiUri.At("files", pick.TypeId.ToString(), "info").AsPublicUri()) .End(); break; case SearchResultType.Comment: doc.Start("comment") .Attr("id", pick.TypeId) .Attr("href", _apiUri.At("comments", pick.TypeId.ToString()).AsPublicUri()) .End(); break; } }
private void InsertRecord(DirectoryRecord record) { // add value to directory lock (_directory) { _directory[record.Name] = record; } // check if value has an expiration time if (record.HasExpiration) { TimerFactory.New(record.Expiration, OnExpire, record.Name, TaskEnv.New()); } SaveToFileSystem(record.Name, record.Value); // notify event channel XDoc notify = new XDoc("insert").Attr("name", record.Name); if (record.HasExpiration) { notify.Attr("expire", record.Expiration); } notify.Add(record.Value); _events.Post(notify, new Result <DreamMessage>(TimeSpan.MaxValue)); }
private static void WriteXSpan(XmlNode node, XDoc output) { switch (node.NodeType) { case XmlNodeType.Document: WriteXSpan(((XmlDocument)node).DocumentElement, output); break; case XmlNodeType.Element: XDoc childOutput = output.Start("span"); childOutput.Attr("class", node.Name); foreach (XmlNode attr in node.Attributes) { output.Attr("xml:" + attr.Name, attr.Value); } foreach (XmlNode child in node.ChildNodes) { WriteXSpan(child, output); } output.End(); break; case XmlNodeType.Text: output.Value(node.Value); break; } }
static void AddFile(attachments attachment, XDoc doc, bool wrap) { if (wrap) { doc.Start("file"); } doc .Attr("id", attachment.ID.ToString()) .Attr("page", attachment.From.ToString()) .Start("full-name").Value(attachment.GetFullName()).End() .Start("name").Value(attachment.Name).End() .Start("extension").Value(attachment.Extension).End() .Start("filename").Value(attachment.FileName).End() .Start("description").Value(attachment.Description).End() .Start("size").Value(attachment.FileSize.ToString()).End() .Start("type").Value(attachment.FileType).End() .Start("timestamp").Value(attachment.TimeStamp).End() .Start("user").Value(attachment.UserText).End(); if (attachment.Removed != DateTime.MinValue) { doc.Start("removed").Value(attachment.Removed).End() .Start("removed-by").Value(attachment.RemovedByText).End(); } if (wrap) { doc.End(); } }
internal static XDoc ExecuteFork(Plug env, DreamHeaders headers, XDoc fork) { // execute script commands XDoc reply = new XDoc("results"); string ID = fork["@ID"].Contents; if (!string.IsNullOrEmpty(ID)) { reply.Attr("ID", ID); } // TODO (steveb): we should use a 'fixed capacity' cue which marks itself as done when 'count' is reached XDoc forks = fork.Elements; foreach (XDoc cmd in forks) { // TODO (steveb): we should be doing this in parallel, not sequentially! try { reply.Add(ExecuteCommand(env, headers, cmd)); } catch (Exception e) { reply.Add(new XException(e)); } } return(reply); }
//--- Methods --- public XDoc ToXml(XUri uri) { XDoc result = new XDoc("function"); result.Attr("transform", Transform); if(IsProperty) { result.Attr("usage", "property"); } result.Elem("name", Name); result.Elem("uri", uri); result.Elem("description", Description); if(Access != DreamAccess.Public) { result.Elem("access", Access.ToString().ToLowerInvariant()); } foreach(DekiScriptParameter param in Parameters) { param.AppendXml(result); } result.Start("return").Attr("type", DekiScriptLiteral.AsScriptTypeName(ReturnType)).End(); return result; }
public Yield GetGroups(DreamContext context, DreamMessage request, Result<DreamMessage> response) { PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ); uint totalCount, queryCount; IList<GroupBE> groups = GroupBL.GetGroupsByQuery(context, out totalCount, out queryCount); XDoc result = new XDoc("groups"); result.Attr("count", groups.Count); result.Attr("querycount", queryCount); result.Attr("totalcount", totalCount); result.Attr("href", DekiContext.Current.ApiUri.At("groups")); foreach(GroupBE g in groups) { result.Add(GroupBL.GetGroupXmlVerbose(g, null)); } response.Return(DreamMessage.Ok(result)); yield break; }
//--- Methods --- public XDoc ToXml() { XDoc result = new XDoc("group"); result.Attr("name", Name); if(HasCustom) { foreach(KeyValuePair<string, string> custom in ArrayUtil.AllKeyValues(Custom)) { result.Elem(custom.Key, custom.Value); } } return result; }
public Yield GetServices(DreamContext context, DreamMessage request, Result<DreamMessage> response) { bool privateDetails = PermissionsBL.IsUserAllowed(DekiContext.Current.User, Permissions.ADMIN); //Private feature requires api-key uint totalCount; uint queryCount; IList<ServiceBE> services = ServiceBL.GetServicesByQuery(context, out totalCount, out queryCount); XDoc result = new XDoc("services"); result.Attr("count", services.Count); result.Attr("querycount", queryCount); result.Attr("totalcount", totalCount); result.Attr("href", DekiContext.Current.ApiUri.At("site", "services")); foreach(ServiceBE s in services) { result.Add(ServiceBL.GetServiceXmlVerbose(DekiContext.Current.Instance, s, null, privateDetails)); } response.Return(DreamMessage.Ok(result)); yield break; }
public Yield GetSiteRoles(DreamContext context, DreamMessage request, Result<DreamMessage> response) { IList<RoleBE> roles = DbUtils.CurrentSession.RolesRestrictions_GetRoles(); XDoc ret = new XDoc("roles"); ret.Attr("href", DekiContext.Current.ApiUri.At("site", "roles")); if (roles != null) { foreach (RoleBE r in roles) { ret.Add(PermissionsBL.GetRoleXml(r, null)); } } response.Return(DreamMessage.Ok(ret)); yield break; }
internal static XDoc ExecuteScript(Plug env, DreamHeaders headers, XDoc script) { // execute script commands XDoc reply = new XDoc("results"); string ID = script["@ID"].Contents; if(!string.IsNullOrEmpty(ID)) { reply.Attr("ID", ID); } foreach(XDoc cmd in script.Elements) { reply.Add(ExecuteCommand(env, headers, cmd)); } return reply; }
public void LogPageConversion(XDoc spaceManifest, ACConverterPageInfo pageInfo) { string xpath = string.Format("page[@c.pageid='{0}']", pageInfo.ConfluencePage.id); XDoc pageXml = spaceManifest[xpath]; if(pageXml.IsEmpty) { spaceManifest.Start("page"); spaceManifest.Attr("c.space", pageInfo.ConfluencePage.space); spaceManifest.Attr("c.pageid", pageInfo.ConfluencePage.id); spaceManifest.Attr("c.parentpageid", pageInfo.ConfluencePage.parentId); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, pageInfo.ConfluencePage.url, true, false)); spaceManifest.Attr("c.tinyurl", pageInfo.TinyUrl); spaceManifest.Attr("mt.pageid", pageInfo.DekiPageId); spaceManifest.Attr("mt.path", pageInfo.DekiPageUrl); spaceManifest.Attr("title", pageInfo.PageTitle); spaceManifest.End(); } }
public void LogFileConversion(XDoc spaceManifest, RemoteAttachment fileInfo, string contentUrl) { string xpath = string.Format("file[@c.fileid='{0}']", fileInfo.id); XDoc fileXml = spaceManifest[xpath]; if(fileXml.IsEmpty) { spaceManifest.Start("file"); spaceManifest.Attr("c.fileid", fileInfo.id); spaceManifest.Attr("c.pageid", fileInfo.pageId); spaceManifest.Attr("c.filename", fileInfo.fileName); spaceManifest.Attr("c.filesize", fileInfo.fileSize); spaceManifest.Attr("c.mimetype", fileInfo.contentType); spaceManifest.Attr("c.path", Utils.GetUrlLocalUri(_confBaseUrl, fileInfo.url, false, true)); spaceManifest.Attr("mt.path", Utils.GetApiUrl(Utils.GetUrlLocalUri(_confBaseUrl, contentUrl, true, true))); spaceManifest.End(); } }
internal static XDoc ExecuteFork(Plug env, DreamHeaders headers, XDoc fork) { // execute script commands XDoc reply = new XDoc("results"); string ID = fork["@ID"].Contents; if(!string.IsNullOrEmpty(ID)) { reply.Attr("ID", ID); } // TODO (steveb): we should use a 'fixed capacity' cue which marks itself as done when 'count' is reached XDoc forks = fork.Elements; foreach(XDoc cmd in forks) { // TODO (steveb): we should be doing this in parallel, not sequentially! try { reply.Add(ExecuteCommand(env, headers, cmd)); } catch(Exception e) { reply.Add(new XException(e)); } } return reply; }
private void SaveConvertedUsersAndGroups() { XDoc usersDoc = new XDoc(ConvertedUsersRootName); foreach (string tWikiUserName in _convertedUsers.Keys) { XDoc userDoc = new XDoc(ConvertedUserTagName); userDoc.Attr(TWikiUserNameAttribute, tWikiUserName); userDoc.Attr(DekiUserNameAttribute, _convertedUsers[tWikiUserName].DekiName); usersDoc.Add(userDoc); } foreach (string tWikiGroupName in _convertedGroups.Keys) { XDoc groupDoc = new XDoc(ConvertedGroupTagName); groupDoc.Attr(TWikiGroupNameAttribute, tWikiGroupName); groupDoc.Attr(DekiGroupNameAttribute, _convertedGroups[tWikiGroupName].DekiName); usersDoc.Add(groupDoc); } usersDoc.Save(ConvertedUsersFileName); }
//--- Class Methods --- /// <summary> /// Create a service blueprint from reflection and attribute meta-data for an <see cref="IDreamService"/> implementation. /// </summary> /// <param name="type">Type of examine.</param> /// <returns>Xml formatted blueprint.</returns> public static XDoc CreateServiceBlueprint(Type type) { if(type == null) { throw new ArgumentNullException("type"); } XDoc result = new XDoc("blueprint"); // load assembly Dictionary<string, string> assemblySettings = new Dictionary<string, string>(StringComparer.Ordinal); string[] assemblyParts = type.Assembly.FullName.Split(','); foreach(string parts in assemblyParts) { string[] assign = parts.Trim().Split(new char[] { '=' }, 2); if(assign.Length == 2) { assemblySettings[assign[0].Trim()] = assign[1].Trim(); } } result.Start("assembly"); foreach(KeyValuePair<string, string> entry in assemblySettings) { result.Attr(entry.Key, entry.Value); } result.Value(assemblyParts[0]); result.End(); result.Elem("class", type.FullName); // retrieve DreamService attribute on class definition DreamServiceAttribute serviceAttrib = (DreamServiceAttribute)Attribute.GetCustomAttribute(type, typeof(DreamServiceAttribute), false); result.Elem("name", serviceAttrib.Name); result.Elem("copyright", serviceAttrib.Copyright); result.Elem("info", serviceAttrib.Info); // retrieve DreamServiceUID attributes foreach(XUri sid in serviceAttrib.GetSIDAsUris()) { result.Elem("sid", sid); } // check if service has blueprint settings foreach(DreamServiceBlueprintAttribute blueprintAttrib in Attribute.GetCustomAttributes(type, typeof(DreamServiceBlueprintAttribute), true)) { result.InsertValueAt(blueprintAttrib.Name, blueprintAttrib.Value); } // check if service has configuration information DreamServiceConfigAttribute[] configAttributes = (DreamServiceConfigAttribute[])Attribute.GetCustomAttributes(type, typeof(DreamServiceConfigAttribute), true); if(!ArrayUtil.IsNullOrEmpty(configAttributes)) { result.Start("configuration"); foreach(DreamServiceConfigAttribute configAttr in configAttributes) { result.Start("entry") .Elem("name", configAttr.Name) .Elem("valuetype", configAttr.ValueType) .Elem("description", configAttr.Description) .End(); } result.End(); } // retrieve DreamFeature attributes on method definitions result.Start("features"); MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach(MethodInfo method in methods) { // retrieve feature description Attribute[] featureAttributes = Attribute.GetCustomAttributes(method, typeof(DreamFeatureAttribute), false); if(featureAttributes.Length == 0) { continue; } if(method.IsGenericMethod || method.IsGenericMethodDefinition) { throw new NotSupportedException(string.Format("generic methods are not supported ({0})", method.Name)); } // determine access level string access; if(method.IsPublic) { access = "public"; } else if(method.IsAssembly) { access = "internal"; } else if(method.IsPrivate || method.IsFamily) { access = "private"; } else { throw new NotSupportedException(string.Format("access level is not supported ({0})", method.Name)); } // retrieve feature parameter descriptions, filters, prologues, and epilogues Attribute[] paramAttributes = Attribute.GetCustomAttributes(method, typeof(DreamFeatureParamAttribute), false); var pathAttributes = method.GetParameters().Select(p => { var attr = (PathAttribute)p.GetCustomAttributes(typeof(PathAttribute), false).FirstOrDefault(); return ((attr != null) && (attr.Name == null)) ? new PathAttribute { Description = attr.Description, Name = p.Name } : attr; }).Where(p => p != null); var queryAttributes = method.GetParameters().Select(q => { var attr = (QueryAttribute)q.GetCustomAttributes(typeof(QueryAttribute), false).FirstOrDefault(); return ((attr != null) && (attr.Name == null)) ? new QueryAttribute { Description = attr.Description, Name = q.Name } : attr; }).Where(q => q != null); Attribute[] statusAttributes = Attribute.GetCustomAttributes(method, typeof(DreamFeatureStatusAttribute), false); foreach(DreamFeatureAttribute featureAttrib in featureAttributes) { result.Start("feature"); result.Elem("obsolete", featureAttrib.Obsolete); result.Elem("pattern", featureAttrib.Pattern); result.Elem("description", featureAttrib.Description); string info = featureAttrib.Info ?? serviceAttrib.Info; if(info != null) { result.Elem("info", info); } result.Elem("method", method.Name); // add parameter descriptions (as seen on the method definition) foreach(DreamFeatureParamAttribute paramAttrib in paramAttributes) { result.Start("param"); result.Elem("name", paramAttrib.Name); if(!string.IsNullOrEmpty(paramAttrib.ValueType)) { result.Elem("valuetype", paramAttrib.ValueType); } result.Elem("description", paramAttrib.Description); result.End(); } // add parameter descriptions (as seen on the method parameters) foreach(PathAttribute pathAttrib in pathAttributes) { result.Start("param") .Elem("name", "{" + pathAttrib.Name + "}") .Elem("description", pathAttrib.Description) .End(); } // add parameter descriptions (as seen on the method parameters) foreach(QueryAttribute queryAttrib in queryAttributes) { result.Start("param") .Elem("name", queryAttrib.Name) .Elem("description", queryAttrib.Description) .End(); } // add status codes foreach(DreamFeatureStatusAttribute paramAttrib in statusAttributes) { result.Start("status"); result.Attr("value", (int)paramAttrib.Status); result.Value(paramAttrib.Description); result.End(); } // add access level result.Elem("access", access); result.End(); } } result.End(); return result.EndAll(); }
public Yield UserLogin(DreamContext context, DreamMessage request, Result<DreamMessage> response) { string userSuppliedIdentifier = context.GetParam("url", null); if (String.IsNullOrEmpty(userSuppliedIdentifier)) { _log.Info("No identifier was specified"); throw new DreamBadRequestException("No identifier was specified."); } XUri returnUri = new XUri(context.GetParam("returnurl", null)); String realm = context.GetParam("realm", null); if (String.IsNullOrEmpty(realm)) { realm = returnUri.WithoutPathQueryFragment().ToString(); } IAuthenticationRequest openIdRequest; // dummy parameters required by DotNetOpenId 2.x; in 3.x, you can // just pass null to the OpenIdRelyingParty constructor. Uri identifierUri = new Uri(userSuppliedIdentifier); NameValueCollection queryCol = System.Web.HttpUtility.ParseQueryString(identifierUri.Query); OpenIdRelyingParty openid = new OpenIdRelyingParty(null, identifierUri, queryCol); // creating an OpenID request will authenticate that // the endpoint exists and is an OpenID provider. _log.DebugFormat("Creating OpenID request: identifier {0}, return URL {1}, realm {2}", userSuppliedIdentifier, returnUri.ToString(), realm); try { openIdRequest = openid.CreateRequest( userSuppliedIdentifier, realm, returnUri.ToUri()); } catch (OpenIdException ex) { _log.WarnFormat("'{0}' rejected as OpenID identifier: {1}", userSuppliedIdentifier, ex.Message); throw new DreamBadRequestException(string.Format("'{0}' is not a valid OpenID identifier. {1}", userSuppliedIdentifier, ex.Message)); } // Ask for the e-mail address on this request. // Use both SREG and AX, to increase the odds of getting it. openIdRequest.AddExtension(new ClaimsRequest{ Email = DemandLevel.Require, }); var fetch = new FetchRequest(); fetch.AddAttribute(new AttributeRequest(WellKnownAttributes.Contact.Email, true)); openIdRequest.AddExtension(fetch); // The RedirectingResponse either contains a "Location" header for // a HTTP GET, which will return in the response as 'endpoint', or // a HTML FORM which needs to be displayed to the user, which will // return in the response as 'form'. IResponse wr = openIdRequest.RedirectingResponse; XDoc result = new XDoc("openid"); if (String.IsNullOrEmpty(wr.Headers["Location"])) { System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); string formBody = enc.GetString(wr.Body); _log.DebugFormat("OpenID redirect by HTML FORM: {0}", formBody); result.Attr("form", formBody); } else { string redirectUrl = wr.Headers["Location"]; _log.DebugFormat("OpenID redirect URL: {0}", redirectUrl); result.Attr("endpoint", redirectUrl); } response.Return(DreamMessage.Ok(result)); yield break; }
public Yield ValidateOpenIdResponse(DreamContext context, DreamMessage request, Result<DreamMessage> response) { XUri publicUri = new XUri(context.GetParam("url", null)); NameValueCollection queryColl = System.Web.HttpUtility.ParseQueryString(context.GetParam("query", null)); // process the response, including validating the endpoint of the claimed identifier. OpenIdRelyingParty openid = new OpenIdRelyingParty(null, publicUri, queryColl); var openIdResponse = openid.Response; if (openIdResponse != null) { switch (openIdResponse.Status) { case AuthenticationStatus.Authenticated: // Throw an exception if there is a regex for acceptable // identifiers defined, and the ID does not match. if (!String.IsNullOrEmpty(_validIdPattern)) { Regex identifierAccept = new Regex(_validIdPattern); if (!identifierAccept.IsMatch(openIdResponse.ClaimedIdentifier)) { _log.InfoFormat("Identifier {0} denied access by valid-id-pattern regular expression {1}", openIdResponse.ClaimedIdentifier, _validIdPattern); throw new DreamBadRequestException("This service is configured to deny access to this OpenID identifier."); } } var claimsResponse = openIdResponse.GetExtension<ClaimsResponse>(); var fetchResponse = openIdResponse.GetExtension<FetchResponse>(); XDoc result = new XDoc("openid"); result.Attr("validated", true); result.Elem("identifier", openIdResponse.ClaimedIdentifier); // SREG response if (claimsResponse != null) { string email = claimsResponse.Email; if (email != null) { result.Elem("email", email); _log.DebugFormat("E-mail address from SREG: {0}", email); } } // AX response if (fetchResponse != null) { foreach (AttributeValues v in fetchResponse.Attributes) { if (v.TypeUri == WellKnownAttributes.Contact.Email) { IList<string> emailAddresses = v.Values; string email = emailAddresses.Count > 0 ? emailAddresses[0] : null; result.Elem("email", email); _log.DebugFormat("E-mail address from AX: {0}", email); } } } response.Return(DreamMessage.Ok(result)); break; case AuthenticationStatus.Canceled: _log.InfoFormat("Authentication was cancelled by the user."); throw new DreamBadRequestException("Authentication was cancelled by the user."); case AuthenticationStatus.Failed: _log.InfoFormat("Authentication failed: " + openIdResponse.Exception.Message); throw new DreamBadRequestException("Authentication failed: " + openIdResponse.Exception.Message); default: _log.WarnFormat("Authentication error: " + openIdResponse.Exception.Message); throw new DreamBadRequestException("Authentication error: " + openIdResponse.Exception.Message); } } else { _log.Warn("OpenID response was null"); throw new DreamBadRequestException("No OpenID response was returned."); } yield break; }
private static void FixupManifest(XDoc manifest, Opts opts) { if(opts.ImportOnce) { manifest.Attr("import-once", true); } if(opts.InitOnly) { manifest.Attr("init-only", true); } if(manifest["@preserve-local"].IsEmpty) { manifest.Attr("preserve-local", opts.PreserveLocalChanges ?? false); } else { manifest["@preserve-local"].ReplaceValue(opts.PreserveLocalChanges ?? false); } if(opts.Restriction != Restriction.Default) { manifest.Start("security") .Start("permissions.page") .Elem("restriction", GetRestrictionString(opts.Restriction)) .End() .End(); } foreach(var capability in opts.Capabilities) { manifest.Start("capability").Attr("name", capability.Key); if(!string.IsNullOrEmpty(capability.Value)) { manifest.Attr("value", capability.Value); } manifest.End(); } }
public Yield GetGroupUsers(DreamContext context, DreamMessage request, Result<DreamMessage> response) { PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ); GroupBE group = GetGroupFromUrl(); DreamMessage responseMsg = null; uint totalCount; uint queryCount; var usersInGroup = UserBL.GetUsersByQuery(context, group.Id, out totalCount, out queryCount); XDoc ret = new XDoc("users"); ret.Attr("count", usersInGroup.Count()); ret.Attr("querycount", queryCount); ret.Attr("totalcount", totalCount); ret.Attr("href", DekiContext.Current.ApiUri.At("groups", group.Id.ToString(), "users")); foreach(UserBE member in usersInGroup) ret.Add(UserBL.GetUserXml(member, null, Utils.ShowPrivateUserInfo(member))); responseMsg = DreamMessage.Ok(ret); response.Return(responseMsg); yield break; }
private void SaveUsersAndGroupsToXML() { XDoc doc = new XDoc(UsersAndGroupsXMLRootName); foreach (string confluenceUserName in _convertedUsers.Keys) { ACConverterUserInfo userInfo = _convertedUsers[confluenceUserName]; XDoc userDoc = new XDoc(UserXMLTagName); userDoc.Attr(ConfluenceUserNameXMLAttributeName, confluenceUserName); userDoc.Attr(DekiUserNameXMLAttributeName, userInfo.DekiUserName); doc.Add(userDoc); } foreach (string confluenceGroupName in _convertedGroups.Keys) { ACConverterGroupInfo groupInfo = _convertedGroups[confluenceGroupName]; XDoc groupDoc = new XDoc(GroupXMLTagName); groupDoc.Attr(ConfluenceGroupNameXMLAttributeName, confluenceGroupName); groupDoc.Attr(DekiGroupNameXMLAttributeName, groupInfo.DekiGroupName); doc.Add(groupDoc); } doc.Save(ConvertedUsersAndGroupsFileName); }
public static XDoc GetServiceXml(ServiceBE service, string relation) { XDoc serviceXml = new XDoc(string.IsNullOrEmpty(relation) ? "service" : "service." + relation); serviceXml.Attr("id", service.Id); serviceXml.Attr("href", DekiContext.Current.ApiUri.At("site", "services", service.Id.ToString())); return serviceXml; }
//--- Methods --- /// <summary> /// Create a new subscription set document. /// </summary> /// <returns>Set Xml document.</returns> public XDoc AsDocument() { XDoc doc = new XDoc("subscription-set") .Attr("max-failures", MaxFailures) .Elem("uri.owner", Owner); if(Version.HasValue) { doc.Attr("version", Version.Value); } foreach(PubSubSubscription subscription in Subscriptions) { doc.Add(subscription.AsDocument()); } return doc; }
private void ReplaceAttribute(XDoc doc, string attributeName, string pageName, string currentWeb) { string atAttributeName = "@" + attributeName; string link = doc[atAttributeName].AsText; if (link == null) { return; } string dekiUrl = GetDekiUrlFromTWikiUrl(link, currentWeb); if (dekiUrl != null) { doc.Attr(attributeName, dekiUrl); } }
public static XDoc WebImage( [DekiScriptParam("image uri")] string uri, [DekiScriptParam("image width", true)] float? width, [DekiScriptParam("image height", true)] float? height, [DekiScriptParam("image alternative text", true)] string text ) { XDoc result = new XDoc("html").Start("body"); if(uri.EndsWithInvariantIgnoreCase(".svg")) { result.Start("iframe").Attr("marginwidth", "0").Attr("marginheight", "0").Attr("hspace", "0").Attr("vspace", "0").Attr("frameborder", "0").Attr("scrolling", "no"); } else { result.Start("img"); } result.Attr("src", WebCheckUri(uri)); result.Attr("width", WebSize(width)); result.Attr("height", WebSize(height)); result.Attr("alt", text); result.Attr("title", text); result.End(); result.End(); return result; }
private XDoc GetFileXml(IList<ResourceBE> files, bool verbose, bool list, string fileSuffix, bool? explicitRevisionInfo, int? totalCount, XUri listUri) { Dictionary<uint, UserBE> users = new Dictionary<uint, UserBE>(); Dictionary<ulong, PageBE> pages = new Dictionary<ulong, PageBE>(); List<uint> parentIds = new List<uint>(); //Collect related entity id's foreach(ResourceBE f in files) { users[f.UserId] = null; pages[f.ParentPageId.Value] = null; parentIds.Add(f.ResourceId); } //Perform batch lookups of related entities users = _session.Users_GetByIds(users.Keys.ToArray()).AsHash(e => e.ID); if(verbose) { pages = PageBL.GetPagesByIdsPreserveOrder(pages.Keys.ToArray()).AsHash(e => e.ID); } //Associate properties with the given attachments files = _resourceBL.PopulateChildren(files.ToArray(), new[] { ResourceBE.Type.PROPERTY }, explicitRevisionInfo ?? false); XDoc ret = XDoc.Empty; if(list) { List<ResourceBE> sortedFiles = new List<ResourceBE>(files); files = SortFileListByNameAndRevision(sortedFiles).ToArray(); ret = new XDoc(string.IsNullOrEmpty(fileSuffix) ? "files" : "files." + fileSuffix); ret.Attr("count", files.Count); if(totalCount != null) { ret.Attr("totalcount", totalCount.Value); } if(listUri != null) { ret.Attr("href", listUri); } } foreach(ResourceBE f in files) { UserBE updatedByUser; PageBE parentPage; users.TryGetValue(f.UserId, out updatedByUser); pages.TryGetValue(f.ParentPageId.Value, out parentPage); ret = AppendFileXml(ret, f, fileSuffix, explicitRevisionInfo, updatedByUser, parentPage); } return ret; }
//--- Class Methods --- /// <summary> /// Convert an XSpan document to a regular Xml document. /// </summary> /// <param name="xspan">XSpan document.</param> /// <returns>New Xml document instance.</returns> public static XDoc FromXSpan(XDoc xspan) { XDoc xml = new XDoc(xspan["@class"].Contents); foreach(XDoc attr in xspan["@*"]) { if(attr.Name.StartsWithInvariant("xml:")) xml.Attr(attr.Name.Substring("xml:".Length), attr.Contents); } string value = xspan["text()"].Contents; if(value.Length != 0) xml.Value(value); foreach(XDoc child in xspan.Elements) xml.Add(FromXSpan(child)); return xml; }
/// <summary> /// Read a Versit string from a text reader and parse it into an Xml document. /// </summary> /// <param name="reader">Source reader.</param> /// <param name="root">Name to use as thexml document root node.</param> /// <returns>Xml document instance.</returns> public static XDoc FromVersit(TextReader reader, string root) { string value = reader.ReadToEnd().Trim(); XDoc result = new XDoc(string.IsNullOrEmpty(root) ? "root" : root); // NOTE (steveb): the versit format is "KEY;ATTR_KEY=ATTR_VALUE;ATTR_KEY=ATTR_VALUE:VALUE\r\n" // join line continuations value = value.Replace("\r\n ", ""); // split lines string[] lines = value.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); // process each line foreach(string line in lines) { if(line.StartsWithInvariant("BEGIN:")) { result.Start(line.Substring(6).ToLowerInvariant()); } else if(line.StartsWithInvariant("END:")) { result.End(); } else { string[] pair = line.Split(new[] { ':' }, 2); string[] attrs = pair[0].Split(';'); result.Start(attrs[0].ToLowerInvariant()); for(int i = 1; i < attrs.Length; ++i) { string[] attr = attrs[i].Split(new[] { '=' }, 2); result.Attr(attr[0].ToLowerInvariant(), (attr.Length > 1) ? DecodeVersitString(attr[1]) : string.Empty); } if(pair.Length > 1) { result.Value(DecodeVersitString(pair[1])); } result.End(); } } return result; }
public static XDoc GetGroupXml(GroupBE group, string relation) { XDoc groupXml = new XDoc(string.IsNullOrEmpty(relation) ? "group" : "group." + relation); groupXml.Attr("id", group.Id); groupXml.Attr("href", DekiContext.Current.ApiUri.At("groups", group.Id.ToString())); groupXml.Start("groupname").Value(group.Name).End(); return groupXml; }
private static void WriteXSpan(XmlNode node, XDoc output) { switch(node.NodeType) { case XmlNodeType.Document: WriteXSpan(((XmlDocument)node).DocumentElement, output); break; case XmlNodeType.Element: XDoc childOutput = output.Start("span"); childOutput.Attr("class", node.Name); foreach(XmlNode attr in node.Attributes) { output.Attr("xml:" + attr.Name, attr.Value); } foreach(XmlNode child in node.ChildNodes) { WriteXSpan(child, output); } output.End(); break; case XmlNodeType.Text: output.Value(node.Value); break; } }
public static XDoc GetUserXml(UserBE user, string relation, bool showPrivateInfo) { XDoc userXml = new XDoc(string.IsNullOrEmpty(relation) ? "user" : "user." + relation); userXml.Attr("id", user.ID); userXml.Attr("href", DekiContext.Current.ApiUri.At("users", user.ID.ToString())); userXml.Elem("nick", user.Name); userXml.Elem("username", user.Name); userXml.Elem("fullname", user.RealName ?? String.Empty); // check if we can add the email address if(showPrivateInfo) { userXml.Elem("email", user.Email); } else { userXml.Start("email").Attr("hidden", true).End(); } // add gravatar if(!IsAnonymous(user) && !string.IsNullOrEmpty(user.Email)) { DekiContext context = DekiContext.CurrentOrNull; XUri gravatar = new XUri("http://www.gravatar.com/avatar"); string hash = string.Empty; if(context != null) { DekiInstance deki = context.Instance; string secure = context.Instance.GravatarSalt ?? string.Empty; if(!secure.EqualsInvariantIgnoreCase("hidden")) { hash = StringUtil.ComputeHashString(secure + (user.Email ?? string.Empty).Trim().ToLowerInvariant(), System.Text.Encoding.UTF8); } // add size, if any string size = deki.GravatarSize; if(size != null) { gravatar = gravatar.With("s", size); } // add rating, if any string rating = deki.GravatarRating; if(rating != null) { gravatar = gravatar.With("r", rating); } // add default icon, if any string def = deki.GravatarDefault; if(def != null) { gravatar = gravatar.With("d", def); } } if(!string.IsNullOrEmpty(hash)) { userXml.Elem("hash.email", hash); userXml.Elem("uri.gravatar", gravatar.At(hash + ".png")); } else { userXml.Elem("hash.email", string.Empty); userXml.Elem("uri.gravatar", gravatar.At("no-email.png")); } } return userXml; }
public Yield GetUsers(DreamContext context, DreamMessage request, Result<DreamMessage> response) { // TODO (steveb): add 'emailfilter' and use it to obsolete 'usernameemailfilter'; 'usernamefilter', 'fullnamefilter', and 'emailfilter' // should be OR'ed together when they are present. PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ); uint totalCount; uint queryCount; IList<UserBE> users = UserBL.GetUsersByQuery(context, null, out totalCount, out queryCount); XDoc result = new XDoc("users"); result.Attr("count", users.Count); result.Attr("querycount", queryCount); result.Attr("totalcount", totalCount); result.Attr("href", DekiContext.Current.ApiUri.At("users")); foreach (UserBE u in users) { result.Add(UserBL.GetUserXmlVerbose(u, null, Utils.ShowPrivateUserInfo(u))); } response.Return(DreamMessage.Ok(result)); yield break; }
public XDoc Table( [DekiExtParam("SELECT query")] string query ) { XDoc result = new XDoc("html") .Start("head") .Start("script").Attr("type", "text/javascript").Attr("src", Files.At("sorttable.js")).End() .Start("style").Attr("type", "text/css").Value(@".feedtable { border:1px solid #999; line-height:1.5em; overflow:hidden; width:100%; } .feedtable th { background-color:#ddd; border-bottom:1px solid #999; font-size:14px; } .feedtable tr { background-color:#FFFFFF; } .feedtable tr.feedroweven td { background-color:#ededed; }").End() .End() .Start("body"); result.Start("table").Attr("border", 0).Attr("cellpadding", 0).Attr("cellspacing", 0).Attr("class", "feedtable sortable"); _catalog.NewQuery(query).Execute(delegate(IDataReader reader) { // capture row columns result.Start("thead").Start("tr"); int count = reader.FieldCount; for(int i = 0; i < count; ++i) { result.Start("th").Elem("strong", reader.GetName(i)).End(); } result.End().End(); // read records int rowcount = 0; result.Start("tbody"); while(reader.Read()) { result.Start("tr"); result.Attr("class", ((rowcount++ & 1) == 0) ? "feedroweven" : "feedrowodd"); for (int i = 0; i < count; ++i) { string val = string.Empty; try { if (!reader.IsDBNull(i)) { val = reader.GetValue(i).ToString(); } } catch { } result.Elem("td", val); } result.End(); } result.End(); }); result.End().End(); return result; }