public Yield PostBans(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
BanBE ban = BanningBL.SaveBan(request.ToDocument());
DekiContext.Current.Instance.EventSink.BanCreated(context.StartTime, ban);
response.Return(DreamMessage.Ok(BanningBL.GetBanXml(ban)));
yield break;
}
public Yield SetPageTags(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PageBE page = PageBL.AuthorizePage(DekiContext.Current.User, Permissions.UPDATE, false);
XUri href = DekiContext.Current.ApiUri.At("pages", page.ID.ToString(), "tags");
TagBL.PutTagsFromXml(page, request.ToDocument());
XDoc doc = TagBL.GetTagListXml(TagBL.GetTagsForPage(page), "tags", href, false);
response.Return(DreamMessage.Ok(doc));
yield break;
}
public Yield GetPageAllowedUsers(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
List<uint> userids = new List<uint>();
if(request.HasDocument) {
foreach(XDoc userid in request.ToDocument()["user/@id"]) {
uint? id = userid.AsUInt;
if(id.HasValue) {
userids.Add(id.Value);
} else {
throw new DreamBadRequestException(string.Format("'{0}' is not a valid userid", userid.AsText));
}
}
}
if(userids.Count == 0) {
throw new DreamBadRequestException("must provide at least one userid");
}
string permissionsList = context.GetParam("permissions");
bool filterDisabled = context.GetParam("filterdisabled", false);
if(filterDisabled) {
List<uint> activeUsers = new List<uint>();
foreach(UserBE user in DbUtils.CurrentSession.Users_GetByIds(userids)) {
if(user.UserActive) {
activeUsers.Add(user.ID);
}
}
userids = activeUsers;
if(userids.Count == 0) {
response.Return(DreamMessage.Ok(new XDoc("users")));
yield break;
}
}
Permissions permissions = Permissions.READ;
if(!string.IsNullOrEmpty(permissionsList)) {
bool first = true;
foreach(string perm in permissionsList.Split(',')) {
Permissions p;
if(!SysUtil.TryParseEnum(perm, out p)) {
throw new DreamBadRequestException(string.Format("'{0}' is not a valid permission value", perm));
}
if(first) {
permissions = p;
} else {
permissions |= p;
}
first = false;
}
}
uint[] filteredIds = PermissionsBL.FilterDisallowed(userids.ToArray(), context.GetParam<uint>("pageid"), false, permissions);
XDoc msg = new XDoc("users");
foreach(int userid in filteredIds) {
msg.Start("user").Attr("id", userid).End();
}
response.Return(DreamMessage.Ok(msg));
yield break;
}
internal IEnumerator<IYield> QueueUpdateTemplates(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
var doc = request.ToDocument();
var wikiId = doc["@wikiid"].AsText;
var channel = doc["channel"].AsText;
_log.DebugFormat("received event '{0}' from '{1}'", channel, wikiId);
if(!_processingQueue.TryEnqueue(doc)) {
throw new InvalidOperationException("Enqueue of update event failed.");
}
response.Return(DreamMessage.Ok());
yield break;
}
internal IEnumerator<IYield> PostUpdateTemplates(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
var doc = request.ToDocument();
var wikiId = doc["@wikiid"].AsText;
var apiUri = doc["uri"].AsText;
var apiPlug = CreateApiPlug(apiUri, wikiId);
_log.DebugFormat("received manual tickle from '{0}' @ '{1}'", wikiId, apiUri);
XDoc importReport = null;
yield return GetInstance(wikiId, true).UpdatePackages(apiPlug, _apikey, new Result<XDoc>()).Set(x => importReport = x);
response.Return(DreamMessage.Ok(importReport));
yield break;
}
internal Yield QueuePurge(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
XDoc doc = request.ToDocument();
XUri channel = doc["channel"].AsUri;
string action = channel.Segments[2];
// there are certain sub-events we don't use to trigger on
if(action != "view") {
_updateDelayQueue.Enqueue(doc);
}
response.Return(DreamMessage.Ok());
yield break;
}
public Yield PutUser(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
UserBE user = GetUserFromUrl();
//Authorization is performed later.
if (user == null) {
throw new DreamAbortException(DreamMessage.NotFound(DekiResources.GIVEN_USER_NOT_FOUND_USE_POST));
}
string accountPassword = context.GetParam("accountpassword", null);
user = UserBL.PostUserFromXml(request.ToDocument(), user, accountPassword, context.GetParam("authusername", null), context.GetParam("authpassword", null));
response.Return(DreamMessage.Ok(UserBL.GetUserXmlVerbose(user, null, Utils.ShowPrivateUserInfo(user))));
yield break;
}
public Yield PostGroupUsers(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
GroupBE group = GetGroupFromUrl();
group = GroupBL.AddGroupMembers(group, request.ToDocument());
response.Return(DreamMessage.Ok(GroupBL.GetGroupXmlVerbose(group, null)));
yield break;
}
//--- Constructors ---
/// <summary>
/// Serialize message into Xml.
/// </summary>
/// <param name="message">Message to serialize.</param>
public XMessage(DreamMessage message)
: base("message")
{
Elem("status", (int)message.Status);
Start("headers");
foreach(KeyValuePair<string, string> pair in message.Headers) {
Elem(pair.Key, pair.Value ?? string.Empty);
}
if(message.HasCookies) {
foreach(DreamCookie cookie in message.Cookies) {
// NOTE (steveb): we rely on the 'Version' being set to differentiate between 'Cookie' and a 'Set-Cookie' headers
if(cookie.Version != 0) {
Add(cookie.AsSetCookieDocument);
} else {
Add(cookie.AsCookieDocument);
}
}
}
End();
Start("body");
if(message.HasDocument) {
Attr("format", "xml").Add(message.ToDocument());
} else {
byte[] bytes = message.ToBytes();
string body = null;
string attr = "none";
// TODO (steveb): we need to use a content-type matching algorithm and match against all known text types (text/*, application/json, etc.)
if(bytes.Length > 0) {
if(message.ContentType.Match(MimeType.ANY_TEXT)) {
body = message.ContentType.CharSet.GetString(bytes).EncodeHtmlEntities(Encoding.UTF8, false);
attr = "text";
} else {
body = Convert.ToBase64String(bytes);
attr = "base64";
}
}
Attr("format", attr).Value(body);
}
End();
}
internal Yield PostGrant(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
lock(Cookies) {
Cookies.Update(DreamCookie.ParseAllSetCookieNodes(request.ToDocument()), null);
}
response.Return(DreamMessage.Ok());
yield break;
}
private void rc_moved_to_title_check(DreamMessage msg, string path)
{
string pathMeta = msg.ToDocument()["change/rc_moved_to_title"].AsText ?? String.Empty;
Assert.AreEqual(path, pathMeta, "Unexpected rc_moved_to_title");
}
private void rc_type_check(DreamMessage msg, int t)
{
int typeMeta = msg.ToDocument()["change/rc_type"].AsInt ?? -1;
Assert.AreEqual(t, typeMeta, "Unexpected rc_type");
}
private void cmnt_content_mimetype_check(DreamMessage msg, string cmnt_content_mimetype)
{
string cmnt_content_mimetype_meta = msg.ToDocument()["change/cmnt_content_mimetype"].AsText ?? String.Empty;
Assert.AreEqual(cmnt_content_mimetype, cmnt_content_mimetype_meta, "Unexpected cmnt_content_mimetype");
}
private void cmnt_number_check(DreamMessage msg, int cmnt_number)
{
int cmnt_number_meta = msg.ToDocument()["change/cmnt_number"].AsInt ?? 0;
Assert.AreEqual(cmnt_number, cmnt_number_meta, "Unexpected cmnt_number");
}
private void rc_summary_check(DreamMessage msg, string summary)
{
string sumMeta = msg.ToDocument()["change/rc_summary"].AsText ?? String.Empty;
Assert.AreEqual(summary.ToLower(), sumMeta.ToLower(), "Unexpected rc_summary");
}
private void rc_timestamp_check(DreamMessage msg, string timestamp)
{
string timestampMeta = msg.ToDocument()["change/rc_timestamp"].AsText ?? String.Empty;
Assert.AreEqual(timestamp, timestampMeta, "Unexpected rc_timestamp");
}
private void cmnt_deleted_check(DreamMessage msg, int deleted)
{
int delMeta = msg.ToDocument()["change/cmnt_deleted"].AsInt ?? -1;
Assert.AreEqual(deleted, delMeta, "Unexpected cmnt_deleted");
}
private void rc_moved_to_ns_check(DreamMessage msg, int ns)
{
int nsMeta = msg.ToDocument()["change/rc_moved_to_ns"].AsInt ?? -1;
Assert.AreEqual(ns, nsMeta, "Unexpected rc_moved_to_ns");
}
private void old_is_hidden_check(DreamMessage msg, bool old_is_hidden)
{
bool? old_is_hidden_meta = msg.ToDocument()["change/old_is_hidden"].AsBool;
Assert.IsTrue(old_is_hidden == old_is_hidden_meta, "Unexpected old_is_hidden");
}
private void rc_user_name_check(DreamMessage msg, string user)
{
string userMeta = msg.ToDocument()["change/rc_user_name"].AsText.ToLower() ?? String.Empty;
Assert.AreEqual(user.ToLower(), userMeta.ToLower(), "Unexpected rc_user_name");
}
private void rc_id_check(DreamMessage msg)
{
int rc_id = msg.ToDocument()["change/rc_id"].AsInt ?? 0;
Assert.IsTrue(rc_id > 0, "Invalid feed rc_id");
}
protected virtual Yield PutConfig(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
XDoc config = request.ToDocument();
if(config.Name != "config") {
throw new DreamBadRequestException("bad document type");
}
if(IsStarted) {
throw new DreamBadRequestException("service must be stopped first");
}
_timerFactory = TaskTimerFactory.Create(this);
// configure service container
var lifetimeScope = _env.CreateServiceLifetimeScope(this, (c, b) => PreInitializeLifetimeScope(c, b, config));
// call container-less start (which contains shared start logic)
yield return Coroutine.Invoke(Start, request.ToDocument(), new Result());
// call start with container for sub-classes that want to resolve instances at service start
yield return Coroutine.Invoke(Start, config, lifetimeScope, new Result());
response.Return(DreamMessage.Ok(new XDoc("service-info")
.Start("private-key")
.Add(DreamCookie.NewSetCookie("service-key", PrivateAccessKey, Self.Uri).AsSetCookieDocument)
.End()
.Start("internal-key")
.Add(DreamCookie.NewSetCookie("service-key", InternalAccessKey, Self.Uri).AsSetCookieDocument)
.End()
));
}
private void rc_comment_check(DreamMessage msg, string comment)
{
string commentMeta = msg.ToDocument()["change/rc_comment"].AsText ?? String.Empty;
Assert.AreEqual(comment, commentMeta, "Unexpected rc_comment");
}
public Yield PostGroup(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
DreamMessage responseMsg = null;
GroupBE group = GroupBL.PostGroupFromXml(request.ToDocument(), null, context.GetParam("authusername", null), context.GetParam("authpassword", null));
responseMsg = DreamMessage.Ok(GroupBL.GetGroupXmlVerbose(group, null));
response.Return(responseMsg);
yield break;
}
private void rc_this_oldid_check(DreamMessage msg, int oldid)
{
int oldidMeta = msg.ToDocument()["change/rc_this_oldid"].AsInt ?? 0;
Assert.AreEqual(oldid, oldidMeta, "Unexpected rc_last_oldid");
}
private static object GetRequestAsDocument(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
return(request.ToDocument());
}
private void rc_cur_id_check(DreamMessage msg, int id)
{
int rc_cur_id = msg.ToDocument()["change/rc_cur_id"].AsInt ?? 0;
Assert.AreEqual(id, rc_cur_id, "Unexpected rc_cur_id");
}
public Yield PostUser(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
if(!PermissionsBL.IsUserAllowed(DekiContext.Current.User, Permissions.ADMIN)) {
throw new DreamForbiddenException("Must provide an apikey or admin authtoken to create a user");
}
UserBE user = null;
//Authorization is performed later.
string accountPassword = context.GetParam("accountpassword", null);
//standard user creation/editing
user = UserBL.PostUserFromXml(request.ToDocument(), null, accountPassword, context.GetParam("authusername", null), context.GetParam("authpassword", null));
response.Return(DreamMessage.Ok(UserBL.GetUserXmlVerbose(user, null, Utils.ShowPrivateUserInfo(user))));
yield break;
}
private void rc_timestamp_check(DreamMessage msg)
{
string timestamp = msg.ToDocument()["change/rc_timestamp"].AsText ?? String.Empty;
Assert.IsTrue(timestamp.Length > 0, "rc_timestamp is not present!");
}
public Yield PostUsersAllowed(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
ulong permissionMask = context.GetParam<ulong>("mask", 0);
string operationList = context.GetParam("operations", "");
UserBE u = GetUserFromUrlMustExist();
//Use comma separated permission list or permissionmask from request.
Permissions p = Permissions.NONE;
if (permissionMask != 0) {
p = (Permissions) permissionMask;
}
//Convert operation list to mask combined with provided mask
if (!string.IsNullOrEmpty(operationList)) {
try {
p |= (Permissions) PermissionsBL.MaskFromPermissionList(PermissionsBL.PermissionListFromString(operationList));
}
catch {
throw new DreamAbortException(DreamMessage.BadRequest(DekiResources.INVALID_OPERATION_LIST));
}
}
if (request.ToDocument().HasName("pages")) {
//Parse provided page list into objects
IList<PageBE> result = PageBL.ReadPagesXml(request.ToDocument());
if (p != Permissions.NONE) {
result = PermissionsBL.FilterDisallowed(u, result, false, p);
}
XDoc responseDoc = new XDoc("pages");
if (result != null) {
foreach (PageBE pg in result) {
responseDoc.Add(PageBL.GetPageXml(pg, null));
}
}
response.Return(DreamMessage.Ok(responseDoc));
}
else {
throw new DreamAbortException(DreamMessage.BadRequest(DekiResources.EXPECTED_ROOT_NODE_PAGES));
}
yield break;
}
private void rc_timestamp_check(DreamMessage msg, int pageid)
{
Plug p = Utils.BuildPlugForAdmin();
// Retrieve page date.modified and strip all non-digit characters
DreamMessage newmsg = p.At("pages", pageid.ToString()).GetAsync().Wait();
Assert.AreEqual(DreamStatus.Ok, newmsg.Status, "Page retrieval failed");
string timestamp = newmsg.ToDocument()["date.modified"].AsText ?? String.Empty;
timestamp = Regex.Replace(timestamp, "[^0-9]", "");
string timestampMeta = msg.ToDocument()["change/rc_timestamp"].AsText ?? String.Empty;
Assert.AreEqual(timestamp, timestampMeta, "Unexpected rc_timestamp");
}
