private void CommentChanged(DateTime eventTime, CommentBE comment, PageBE parent, UserBE user, params string[] channelPath)
{
try {
XUri channel = _channel.At(COMMENTS).At(channelPath);
XUri resource = CommentBL.GetUri(comment).WithHost(_wikiid);
string[] origin = new string[] { CommentBL.GetUri(comment).AsServerUri().ToString() };
string path = parent.Title.AsUiUriPath() + "#comment" + comment.Number;
XDoc doc = new XDoc("deki-event")
//userid is deprecated and user/id should be used instead
.Elem("userid", comment.PosterUserId)
.Elem("pageid", comment.PageId)
.Elem("uri.page", PageBL.GetUriCanonical(parent).AsServerUri().ToString())
.Start("user")
.Attr("id", user.ID)
.Attr("anonymous", UserBL.IsAnonymous(user))
.Elem("uri", UserBL.GetUri(user))
.End()
.Elem("channel", channel)
.Elem("uri", CommentBL.GetUri(comment).AsServerUri().ToString())
.Elem("path", path)
.Start("content").Attr("uri", CommentBL.GetUri(comment).AsServerUri().At("content").ToString()).End();
if (comment.Content.Length < 255)
{
doc["content"].Attr("type", comment.ContentMimeType).Value(comment.Content);
}
Queue(eventTime, channel, resource, origin, doc);
} catch (Exception e) {
_log.WarnMethodCall("CommentChanged", "event couldn't be created");
}
}
public void PageMove(DateTime eventTime, PageBE oldPage, PageBE newPage, UserBE user)
{
try {
XUri channel = _channel.At(PAGES, MOVE);
XUri resource = PageBL.GetUriCanonical(newPage).WithHost(_wikiid);
var origin = new[] {
PageBL.GetUriCanonical(newPage).AsServerUri().ToString(),
XUri.Localhost + "/" + oldPage.Title.AsUiUriPath(),
XUri.Localhost + "/" + newPage.Title.AsUiUriPath(),
};
Queue(eventTime, channel, resource, origin, new XDoc("deki-event")
.Elem("channel", channel)
.Elem("uri", PageBL.GetUriCanonical(newPage).AsServerUri().ToString())
.Elem("pageid", newPage.ID)
.Start("user")
.Attr("id", user.ID)
.Attr("anonymous", UserBL.IsAnonymous(user))
.Elem("uri", UserBL.GetUri(user))
.End()
.Start("content.uri")
.Attr("type", "application/xml")
.Value(PageBL.GetUriContentsCanonical(newPage).AsServerUri().With("format", "xhtml").ToString())
.End()
.Elem("revision.uri", PageBL.GetUriRevisionCanonical(newPage).AsServerUri().ToString())
.Elem("tags.uri", PageBL.GetUriCanonical(newPage).At("tags").AsServerUri().ToString())
.Elem("comments.uri", PageBL.GetUriCanonical(newPage).At("comments").AsServerUri().ToString())
.Elem("path", newPage.Title.AsUiUriPath())
.Elem("previous-path", oldPage.Title.AsUiUriPath()));
} catch (Exception e) {
_log.WarnExceptionMethodCall(e, "PageMove", "event couldn't be created");
}
}
public Yield PostUserAuth(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
uint serviceId = context.GetParam <uint>("authprovider", 0);
bool altPassword;
//This will internally fail with a 501 response if credentials are invalid.
//Anonymous accounts (no credentials/authtoken) are not allowed -> 401
UserBE u = SetContextAndAuthenticate(request, serviceId, context.Verb == Verb.POST, false, true, out altPassword);
PermissionsBL.CheckUserAllowed(u, Permissions.LOGIN);
string token = AuthBL.CreateAuthTokenForUser(u);
try {
PageBL.CreateUserHomePage(DekiContext.Current.User);
} catch { }
XUri redirectUri = XUri.TryParse(context.GetParam("redirect", null));
DreamMessage ret = BuildSetAuthTokenResponse(token, redirectUri);
DekiContext.Current.Instance.EventSink.UserLogin(DekiContext.Current.Now, DekiContext.Current.User);
//TODO Max: Set a response header or status to indicate that an alt password was used.
response.Return(ret);
yield break;
}
public static XDoc GetCommentXmlAsAtom(IList <CommentBE> comments, XUri feedUri, PageBE page)
{
var resources = DekiContext.Current.Resources;
string title = resources.Localize(DekiResources.COMMENT_FOR(page.Title.AsUserFriendlyName()));
XAtomFeed feed = new XAtomFeed(title, feedUri, DateTime.UtcNow);
feed.AddLink(PageBL.GetUriUi(page), XAtomBase.LinkRelation.Alternate, MimeType.XHTML, null, page.Title.AsUserFriendlyName());
feed.Id = feedUri;
foreach (CommentBE c in comments)
{
UserBE posterUser = UserBL.GetUserById(c.PosterUserId);
title = c.Title;
if (string.IsNullOrEmpty(title))
{
title = resources.Localize(DekiResources.COMMENT_BY_TO(posterUser.Name, page.Title.AsUserFriendlyName()));
}
XAtomEntry entry = feed.StartEntry(title, c.CreateDate, (c.LastEditDate == null || c.LastEditDate == DateTime.MinValue) ? c.CreateDate : c.LastEditDate.Value);
entry.Id = GetUri(c);
entry.AddAuthor(posterUser.Name, UserBL.GetUriUiHomePage(posterUser), posterUser.Email);
MimeType commentMimetype;
MimeType.TryParse(c.ContentMimeType, out commentMimetype);
entry.AddContent(c.Content);
XUri entryLink = PageBL.GetUriUi(page).WithFragment("comment" + c.Number);
entry.AddLink(entryLink, XAtomBase.LinkRelation.Alternate, null, null, null);
entry.AddLink(GetUri(c).At("content"), XAtomBase.LinkRelation.Enclosure, commentMimetype, c.Content.Length, "content");
feed.End();
}
return(feed);
}
private IList <PageBE> GetTaggedPages(TagBE tag)
{
IList <ulong> pageIds = _session.Tags_GetPageIds(tag.Id);
IList <PageBE> pages = PageBL.GetPagesByIdsPreserveOrder(pageIds);
return(PermissionsBL.FilterDisallowed(_user, pages, false, Permissions.BROWSE));
}
internal static Title GetRelToTitleFromUrl(DreamContext context)
{
Title relToTitle = null;
uint rootId = context.GetParam <uint>("relto", 0);
if (0 == rootId)
{
string path = context.GetParam("reltopath", null);
if (null != path)
{
relToTitle = Title.FromPrefixedDbPath(path, null);
}
}
else
{
PageBE rootPage = PageBL.GetPageById(rootId);
if ((null == rootPage) || (0 == rootPage.ID))
{
throw new PageIdInvalidArgumentException();
}
else
{
relToTitle = rootPage.Title;
}
}
if ((null != relToTitle) && relToTitle.IsTalk)
{
throw new PageReltoTalkInvalidOperationException();
}
return(relToTitle);
}
public Yield GetFavoritePagesForUser(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
XDoc result = PageBL.GetFavoritePagesForUser(GetUserFromUrlMustExist());
response.Return(DreamMessage.Ok(result));
yield break;
}
public override DekiScriptLiteral ResolveMissingName(string name)
{
var result = base.ResolveMissingName(name);
if (result != null)
{
return(result);
}
// check if name refers to a template name
Title title = Title.FromUriPath(name);
// If the page title is prefixed with :, do not assume the template namespace
if (title.Path.StartsWith(":"))
{
title.Path = title.Path.Substring(1);
}
else if (title.IsMain)
{
title.Namespace = NS.TEMPLATE;
}
PageBE page = PageBL.GetPageByTitle(title);
if ((page == null) || (page.ID == 0))
{
return(null);
}
return(DekiScriptExpression.Constant(DekiContext.Current.Deki.Self.At("template"), new DekiScriptList().Add(DekiScriptExpression.Constant(title.AsPrefixedDbPath()))));
}
private void PropertyExport(PageBE page, ResourceBE file, ResourceBE property)
{
// Export the property
XUri propertyUri = null;
string filename = null;
if (null != file)
{
propertyUri = property.PropertyContentUri(AttachmentBL.Instance.GetUri(file));
filename = file.Name;
}
else
{
propertyUri = property.PropertyContentUri(PageBL.GetUriCanonical(page));
}
if (!_uris.ContainsKey(propertyUri))
{
_uris.Add(propertyUri, null);
XDoc manifestDoc = new XDoc("property").Elem("name", property.Name)
.Elem("filename", filename)
.Elem("path", page.Title.AsRelativePath(_relToTitle))
.Start("contents").Attr("type", property.MimeType.ToString()).End();
Add(propertyUri, manifestDoc);
}
}
public virtual ResourceBE Delete(ResourceBE resource, PageBE parentPage, uint changeSetId)
{
//Build the new revision
ResourceBE res = BuildRevForRemove(resource, DateTime.UtcNow, changeSetId);
//Update db
res = SaveResource(res);
//Update indexes and parent page's timestamp
//TODO MaxM: Changesink needs to accept a resource
if (res.ResourceType == ResourceBE.Type.FILE)
{
DekiContext.Current.Instance.EventSink.AttachmentDelete(DekiContext.Current.Now, res, DekiContext.Current.User);
// Recent changes
RecentChangeBL.AddFileRecentChange(DekiContext.Current.Now, parentPage, DekiContext.Current.User, DekiResources.FILE_REMOVED(res.Name), changeSetId);
}
if (parentPage != null)
{
PageBL.Touch(parentPage, DateTime.UtcNow);
}
return(res);
}
private void NotifyPropertyParent(DateTime eventTime, ResourceBE prop, UserBE user, ResourceBE.ParentType parentType, string action)
{
if (parentType == ResourceBE.ParentType.PAGE && prop.ParentPageId != null)
{
PageBE parentPage = PageBL.GetPageById(prop.ParentPageId.Value);
if (parentPage != null)
{
PageDependentChanged(eventTime, parentPage, user, PROPERTY, action);
}
}
else if (parentType == ResourceBE.ParentType.USER)
{
// Owner of property may not be same as requesting user.
// The dependentschanged event is triggered on the property owner.
if (prop.ParentUserId != null)
{
// Optimization to avoid a db call when operating on your own user property.
if (user.ID != prop.ParentUserId.Value)
{
user = UserBL.GetUserById(prop.ParentUserId.Value);
if (user == null)
{
_log.WarnFormat("Could not find owner user (id: {0}) of user property (key: {1})", prop.ParentUserId.Value, prop.Name);
return;
}
}
}
UserDependentChanged(eventTime, user, PROPERTY, action);
}
//TODO (maxm): trigger file property changes
}
public static XDoc BuildXmlSiteMap(PageBE rootPage, string language)
{
Dictionary <ulong, PageBE> pagesById = null;
rootPage = PageBL.PopulateDescendants(rootPage, null, out pagesById, ConfigBL.GetInstanceSettingsValueAs <int>(ConfigBL.MAX_SITEMAP_SIZE_KEY, ConfigBL.MAX_SITEMAP_SIZE));
PageBE[] allowedPages = PermissionsBL.FilterDisallowed(DekiContext.Current.User, new List <PageBE>(pagesById.Values).ToArray(), false, new Permissions[] { Permissions.BROWSE });
Dictionary <ulong, PageBE> allowedPagesById = allowedPages.AsHash(e => e.ID);
Dictionary <ulong, PageBE> addedPagesById = null;
if (!string.IsNullOrEmpty(language))
{
List <ulong> pagesToRemove = new List <ulong>();
foreach (KeyValuePair <ulong, PageBE> page in allowedPagesById)
{
if (!string.IsNullOrEmpty(page.Value.Language) && !StringUtil.EqualsInvariantIgnoreCase(page.Value.Language, language))
{
pagesToRemove.Add(page.Key);
}
}
foreach (ulong pageId in pagesToRemove)
{
allowedPagesById.Remove(pageId);
}
}
PageBL.AddParentsOfAllowedChildren(rootPage, allowedPagesById, addedPagesById);
return(BuildXmlSiteMap(rootPage, new XDoc("pages"), allowedPagesById));
}
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);
}
private void PropertyChanged(DateTime eventTime, ResourceBE prop, UserBE user, ResourceBE.ParentType parentType, XUri parentUri, params string[] path)
{
try {
string parent = string.Empty;
switch (parentType)
{
case ResourceBE.ParentType.PAGE:
parent = PAGES;
break;
case ResourceBE.ParentType.FILE:
parent = FILES;
break;
case ResourceBE.ParentType.USER:
parent = USERS;
break;
case ResourceBE.ParentType.SITE:
parent = SITE;
break;
}
XUri channel = _channel.At(parent).At(PROPERTY).At(path);
XUri resource = prop.PropertyInfoUri(parentUri);
string[] origin = new string[] { resource.ToString() };
XDoc doc = new XDoc("deki-event")
.Elem("channel", channel)
.Elem("name", prop.Name)
.Elem("uri", resource)
.Start("content")
.Attr("mime-type", prop.MimeType.FullType)
.Attr("size", prop.Size)
.Attr("href", prop.PropertyContentUri(parentUri));
if (prop.MimeType.MainType == MimeType.TEXT.MainType && prop.Size < 256)
{
doc.Value(ResourceContentBL.Instance.Get(prop).ToText());
}
doc.End();
if (parentType == ResourceBE.ParentType.PAGE)
{
doc.Elem("pageid", prop.ParentPageId ?? 0);
}
else if (parentType == ResourceBE.ParentType.USER)
{
doc.Elem("userid", prop.ParentUserId ?? 0);
}
else if (parentType == ResourceBE.ParentType.FILE)
{
ResourceBE attachment = ResourceBL.Instance.GetResource(prop.ParentId.Value);
doc.Elem("fileid", attachment.MetaXml.FileId ?? 0);
PageDependentChanged(eventTime, PageBL.GetPageById(attachment.ParentPageId.Value), user, ArrayUtil.Concat(new string[] { FILES, PROPERTY }, path));
}
Queue(eventTime, channel, resource, origin, doc);
} catch (Exception e) {
_log.WarnExceptionMethodCall(e, "PropertyChanged", "event couldn't be created");
}
}
public Yield GetNavigationSiblings(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
CheckResponseCache(context, false);
PageBE page = PageBL_GetPageFromUrl(context, false);
if (page.Title.IsTalk)
{
page = PageBL.GetPageByTitle(page.Title.AsFront());
}
// build response
IList <NavBE> list = NavBL.QueryNavSiblingsData(page, context.Culture);
if (ShowDebug(context))
{
response.Return(DreamMessage.Ok(NavBL.ConvertNavPageListToDoc(list)));
}
else
{
XDoc doc = NavBL.ComputeNavigationDocument(list, page, (uint)page.ID, 0, true, context.GetParam("width", int.MaxValue));
if (ShowXml(context))
{
response.Return(DreamMessage.Ok(doc));
}
else
{
XDoc result = new XDoc("tree");
result.Start("siblings");
// add name of sibling nodes
System.Text.StringBuilder nodes = new System.Text.StringBuilder();
ulong homepageId = DekiContext.Current.Instance.HomePageId;
foreach (NavBE sibling in list)
{
if ((sibling.ParentId == page.ParentID) && (sibling.Id != homepageId))
{
if (nodes.Length != 0)
{
nodes.Append(",");
}
nodes.AppendFormat("n{0}", sibling.Id);
}
}
result.Elem("nodes", nodes.ToString());
// add sibling nodes
result.Start("html");
result.Elem("pre", doc["siblings-pre"].Contents);
result.Elem("post", doc["siblings-post"].Contents);
result.End();
result.End();
response.Return(DreamMessage.Ok(result));
}
}
yield break;
}
public Yield PutFile(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
// Retrieve the file
PageBE page;
string userFileName;
ResourceBE file = GetAttachmentFromUrl(context, false, out page, false, false);
// If the file does not exist, attempt to retrieve the page
if (null == file)
{
if (null == page)
{
if (null != DreamContext.Current.GetParam <string>("fileid"))
{
throw new AttachmentNotFoundException();
}
page = PageBL_GetPageFromUrl(context, true);
}
userFileName = GetFilenameFromPathSegment(DreamContext.Current.GetParam <string>("filename"));
}
else
{
string fileNameParam = DreamContext.Current.GetParam("filename", null);
if (fileNameParam == null)
{
userFileName = file.Name;
}
else
{
userFileName = GetFilenameFromPathSegment(fileNameParam);
}
}
// Retrieve the file description
string userDescription = context.GetParam("description", string.Empty);
if (userDescription.Length > AttachmentBL.MAX_DESCRIPTION_LENGTH)
{
userDescription = userDescription.Substring(0, AttachmentBL.MAX_DESCRIPTION_LENGTH);
}
// Validate the page
PageBL.AuthorizePage(DekiContext.Current.User, Permissions.UPDATE, page, false);
// Get entire stream so it can be reused
var isMSWebDAV = MSWEBDAV_USER_AGENT_REGEX.IsMatch(request.Headers.UserAgent ?? string.Empty);
ResourceBE savedFileRevision = AttachmentBL.Instance.AddAttachment(file, request.AsStream(), request.ContentLength, request.ContentType, page, userDescription, userFileName, isMSWebDAV);
// report an error on failure, and don't redirect
if (savedFileRevision == null)
{
throw new AttachmentUploadSaveFatalException();
}
response.Return(DreamMessage.Ok(AttachmentBL.Instance.GetFileXml(savedFileRevision, true, null, null)));
yield break;
}
protected void btnSacuvaj_Click(object sender, EventArgs e)
{
ekogradnjaBE.Page page = new ekogradnjaBE.Page();
page.IdPage = int.Parse(txtIdPage.Text);
page.Title = txtTitle.Text;
page.Description = txtDescription.Text;
page.Keywords = txtKeywords.Text;
page.Content = txtContent.Text;
page.Url = txtUrl.Text;
PageBL.Save(page, true);
}
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);
}
private void UpdateTag(TagBE tag)
{
_session.Tags_Update(tag);
// update tagged pages
var taggedPages = GetTaggedPages(tag);
foreach (var page in taggedPages)
{
PageBL.Touch(page, _dekiContext.Now);
_eventSink.PageTagsUpdate(_dekiContext.Now, page, _user);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
string query = Page.Request["url"];
ekogradnjaBE.Page page = PageBL.LoadPage(0, query);
lblNaslov.Text = page.Title;
txtContent.InnerHtml = page.Content;
Page.Title = page.Title;
}
}
private IList <TagBE> AssignDefinePages(IList <TagBE> tags)
{
foreach (TagBE tag in tags)
{
if (tag.Type == TagType.DEFINE)
{
ulong pageId = _session.Tags_GetPageIds(tag.Id).FirstOrDefault();
if (0 != pageId)
{
tag.DefinedTo = PageBL.GetPageById(pageId);
}
}
}
return(tags);
}
private ResourceBE GetAttachment(DreamContext context, DreamMessage request, Permissions access, bool allowRevs, bool allowDeleted, out PageBE parentPage)
{
ResourceBE file = GetAttachmentFromUrl(context, true, out parentPage, allowRevs, allowDeleted);
PageBL.AuthorizePage(DekiContext.Current.User, access, parentPage, false);
DreamContext.Current.SetState <UserBE>(DekiContext.Current.User);
DreamContext.Current.SetState <PageBE>(parentPage);
//Identify images for upgrades
List <ResourceBE> fileList = new List <ResourceBE>();
fileList.Add(file);
AttachmentBL.Instance.IdentifyUnknownImages(fileList);
return(file);
}
public static void DeleteComment(PageBE page, CommentBE comment)
{
if (comment.PosterUserId != DekiContext.Current.User.ID)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
}
if (!comment.IsCommentMarkedAsDeleted)
{
comment.DeleteDate = DateTime.UtcNow;
comment.DeleterUserId = DekiContext.Current.User.ID;
DbUtils.CurrentSession.Comments_Update(comment);
PageBL.Touch(page, comment.DeleteDate.Value);
RecentChangeBL.AddCommentDeleteRecentChange(comment.DeleteDate.Value, page, DekiContext.Current.User, DekiResources.COMMENT_DELETED(comment.Number), comment);
DekiContext.Current.Instance.EventSink.CommentDelete(DekiContext.Current.Now, comment, page, DekiContext.Current.User);
}
}
private void PageSecurityChanged(DateTime eventTime, PageBE page, CascadeType cascade, params string[] path)
{
try {
XUri channel = _channel.At(PAGES).At(path);
XUri resource = PageBL.GetUriCanonical(page).WithHost(_wikiid);
string[] origin = new string[] { PageBL.GetUriCanonical(page).AsServerUri().ToString(), XUri.Localhost + "/" + page.Title.AsUiUriPath() };
Queue(eventTime, channel, resource, origin, new XDoc("deki-event")
.Elem("channel", channel)
.Elem("uri", PageBL.GetUriCanonical(page).AsServerUri().ToString())
.Elem("pageid", page.ID)
.Start("security")
.Attr("cascade", cascade.ToString().ToLower())
.End());
} catch (Exception e) {
_log.WarnExceptionMethodCall(e, "PageSecurityChanged", "event couldn't be created");
}
}
/// <summary>
/// Builds an HTML view of the site (with permissions enforced)
/// </summary>
/// <param name="rootPage"></param>
/// <returns></returns>
public static XDoc BuildHtmlSiteMap(PageBE rootPage, string language, int depth, bool reverse)
{
if (depth <= 0)
{
return(XDoc.Empty);
}
Dictionary <ulong, PageBE> pagesById = null;
if (depth == 1)
{
rootPage.ChildPages = PageBL.GetChildren(rootPage, true).ToArray();
pagesById = rootPage.ChildPages.ToDictionary(p => p.ID, true);
}
else
{
rootPage = PageBL.PopulateDescendants(rootPage, null, out pagesById, ConfigBL.GetInstanceSettingsValueAs <int>(ConfigBL.MAX_SITEMAP_SIZE_KEY, ConfigBL.MAX_SITEMAP_SIZE));
}
PageBE[] filteredPages = null;
PageBE[] allowedPages = PermissionsBL.FilterDisallowed(DekiContext.Current.User, new List <PageBE>(pagesById.Values).ToArray(), false, out filteredPages, new Permissions[] { Permissions.BROWSE });
Dictionary <ulong, PageBE> allowedPagesById = allowedPages.AsHash(e => e.ID);
Dictionary <ulong, PageBE> filteredPagesById = filteredPages.AsHash(e => e.ID);
if (!string.IsNullOrEmpty(language))
{
List <ulong> pagesToRemove = new List <ulong>();
foreach (KeyValuePair <ulong, PageBE> page in allowedPagesById)
{
if (!string.IsNullOrEmpty(page.Value.Language) && !StringUtil.EqualsInvariantIgnoreCase(page.Value.Language, language))
{
pagesToRemove.Add(page.Key);
}
}
foreach (ulong pageId in pagesToRemove)
{
allowedPagesById.Remove(pageId);
}
}
Dictionary <ulong, PageBE> addedPagesById = null;
PageBL.AddParentsOfAllowedChildren(rootPage, allowedPagesById, addedPagesById);
XDoc result = new XDoc("ul");
result = BuildHtmlSiteMap(rootPage, result, allowedPagesById, filteredPagesById, depth, reverse);
return(result);
}
public static UserBE CreateNewUser(UserBE newUser)
{
if (newUser == null)
{
return(null);
}
//throw exception if licensing does not allow creation of another user
DekiContext.Current.LicenseManager.IsUserCreationAllowed(true);
if (newUser.RoleId == 0)
{
RoleBE defaultRole = PermissionsBL.RetrieveDefaultRoleForNewAccounts();
if (defaultRole != null)
{
newUser.RoleId = defaultRole.ID;
}
}
ValidateUser(newUser);
newUser.CreateTimestamp = DateTime.UtcNow;
uint userId = DbUtils.CurrentSession.Users_Insert(newUser);
if (userId == 0)
{
return(null);
}
newUser.ID = userId;
PageBE userHomepage = null;
try {
// User homepages are created upon user creation (an attempt to create user homepages may also be done upon login)
userHomepage = PageBL.CreateUserHomePage(newUser);
} catch (Exception e) {
_log.WarnExceptionFormat(e, "Error creating user page for {0}", newUser);
}
if (userHomepage != null)
{
var rcUser = UserBL.GetUserById(userHomepage.UserID) ?? DekiContext.Current.User ?? newUser;
RecentChangeBL.AddUserCreatedRecentChange(DekiContext.Current.Now, userHomepage, rcUser, DekiResources.USER_ADDED(newUser.Name));
}
DekiContext.Current.Instance.EventSink.UserCreate(DekiContext.Current.Now, newUser);
return(newUser);
}
public static CommentBE EditExistingComment(PageBE page, CommentBE comment, DreamMessage request, DreamContext context)
{
if (comment.PosterUserId != DekiContext.Current.User.ID)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
}
ValidateCommentText(request.ContentType, request.AsText());
comment.LastEditDate = DateTime.UtcNow;
comment.LastEditUserId = DekiContext.Current.User.ID;
comment.Content = request.AsText();
comment.ContentMimeType = request.ContentType.ToString();
DbUtils.CurrentSession.Comments_Update(comment);
PageBL.Touch(page, comment.LastEditDate.Value);
RecentChangeBL.AddCommentUpdateRecentChange(comment.LastEditDate.Value, page, DekiContext.Current.User, DekiResources.COMMENT_EDITED(comment.Number), comment);
return(comment);
}
public void RestoreAttachment(ResourceBE attachmentToRestore, PageBE toPage, DateTime timestamp, uint transactionId)
{
if (toPage == null || toPage.ID == 0)
{
ArchiveBE archivesMatchingPageId = _session.Archive_GetPageHeadById(attachmentToRestore.ParentPageId.Value);
if (archivesMatchingPageId == null)
{
throw new AttachmentRestoreFailedNoParentFatalException();
}
else
{
toPage = PageBL.GetPageByTitle(archivesMatchingPageId.Title);
if (0 == toPage.ID)
{
PageBL.Save(toPage, _resources.Localize(DekiResources.RESTORE_ATTACHMENT_NEW_PAGE_TEXT()), DekiMimeType.DEKI_TEXT, null);
}
}
}
string filename = attachmentToRestore.Name;
//Check for name conflicts on target page
ResourceBE conflictingFile = GetPageAttachment(toPage.ID, filename);
if (conflictingFile != null)
{
//rename the restored file
filename = string.Format("{0}(restored {1}){2}", attachmentToRestore.FilenameWithoutExtension, DateTime.Now.ToString("g"), string.IsNullOrEmpty(attachmentToRestore.FilenameExtension) ? string.Empty : "." + attachmentToRestore.FilenameExtension);
conflictingFile = GetPageAttachment(toPage.ID, filename);
if (conflictingFile != null)
{
throw new AttachmentRestoreNameConflictException();
}
}
//Build new revision for restored file
attachmentToRestore = BuildRevForRestore(attachmentToRestore, toPage, filename, transactionId);
//Insert new revision into DB
attachmentToRestore = SaveResource(attachmentToRestore);
//Recent Changes
RecentChangeBL.AddFileRecentChange(_dekiContext.Now, toPage, _dekiContext.User, DekiResources.FILE_RESTORED(attachmentToRestore.Name), transactionId);
_dekiContext.Instance.EventSink.AttachmentRestore(_dekiContext.Now, attachmentToRestore, _dekiContext.User);
}
private IList <TagBE> FilterDisallowed(IList <TagBE> tags)
{
List <TagBE> tagsToRemove = new List <TagBE>();
tags = AssignDefinePages(tags);
foreach (TagBE tag in tags)
{
if (tag.Type == TagType.DEFINE)
{
if (tag.DefinedTo == null || PermissionsBL.FilterDisallowed(_user, new PageBE[] { tag.DefinedTo }, false, Permissions.BROWSE).Length != 1)
{
tagsToRemove.Add(tag);
}
tag.OccuranceCount = 1;
}
else
{
// filter the tags based on permissions
IList <ulong> pageIds = _session.Tags_GetPageIds(tag.Id);
IList <PageBE> pages = PageBL.GetPagesByIdsPreserveOrder(pageIds);
if (pages == null)
{
// this should never happen
tagsToRemove.Add(tag);
}
else
{
// apply permissions
int count = PermissionsBL.FilterDisallowed(_user, pages, false, Permissions.BROWSE).Length;
if (count == 0)
{
tagsToRemove.Add(tag);
}
tag.OccuranceCount = count;
}
}
}
foreach (TagBE tag in tagsToRemove)
{
tags.Remove(tag);
}
return(tags);
}
private static UserBE RenameUser(UserBE user, string newUserName, string newFullName)
{
//Renaming requires admin rights.
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
if (!ServiceBL.IsLocalAuthService(user.ServiceId))
{
//TODO MaxM: allow renaming of external users
throw new ExternalUserRenameNotImplementedExceptionException();
}
//Check for already existing user with same name
UserBE existingUser = DbUtils.CurrentSession.Users_GetByName(newUserName);
if (existingUser != null)
{
throw new UserWithIdExistsConflictException(existingUser.Name, existingUser.ID);
}
PageBE existingTargetUserHomePage = PageBL.GetPageByTitle(Title.FromUIUsername(newUserName));
if (existingTargetUserHomePage != null && existingTargetUserHomePage.ID != 0 && !existingTargetUserHomePage.IsRedirect)
{
throw new UserHomepageRenameConflictException();
}
//Try to move the homepage.
PageBE userHomePage = GetHomePage(user);
if (userHomePage != null && userHomePage.ID != 0)
{
Title newTitle = Title.FromUIUsername(newUserName);
// new user homepage displayname is the user's full name or rebuilt from the username
newTitle.DisplayName = !string.IsNullOrEmpty(newFullName) ? newFullName : newTitle.AsUserFriendlyDisplayName();
PageBL.MovePage(userHomePage, newTitle, true);
}
//Rename the user
user.Name = newUserName;
UserBL.UpdateUser(user);
return(user);
}
