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 Yield DeleteSource(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
Result<bool> result = new Result<bool>();
yield return Context.Current.Instance.SourceController.Delete(context.GetParam("id"), context.GetParam("rev",null), result);
response.Return(DreamMessage.Ok(MimeType.JSON, result.Value.ToString()));
}
public Yield SubscribeToChange(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
uint pageId = context.GetParam<uint>("pageid");
string depth = context.GetParam("depth", "0");
Result<UserInfo> userResult;
yield return userResult = Coroutine.Invoke(GetUserInfo, true, request, new Result<UserInfo>()).Catch();
if(userResult.HasException) {
ReturnUserError(userResult.Exception, response);
yield break;
}
UserInfo userInfo = userResult.Value;
DreamMessage pageAuth = null;
yield return _deki
.At("pages", pageId.ToString(), "allowed")
.With("permissions", "read,subscribe")
.WithHeaders(request.Headers)
.Post(new XDoc("users").Start("user").Attr("id", userInfo.Id).End(), new Result<DreamMessage>())
.Set(x => pageAuth = x);
if(!pageAuth.IsSuccessful || pageAuth.ToDocument()["user/@id"].AsText != userInfo.Id.ToString()) {
throw new DreamForbiddenException("User not permitted to subscribe to page");
}
userInfo.AddResource(pageId, depth);
userInfo.Save();
response.Return(DreamMessage.Ok());
yield break;
}
public Yield PostFileMove(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PageBE sourcePage = null;
PageBE destPage = null;
ResourceBE fileToMove = GetAttachmentFromUrl(context, true, out sourcePage, false, false);
// parameter parsing
string name = context.GetParam("name", null);
string to = context.GetParam("to", null);
if (string.IsNullOrEmpty(name) && string.IsNullOrEmpty(to))
{
throw new AttachmentMoveInvalidArgumentException();
}
if (name == null)
{
name = fileToMove.Name;
}
destPage = to != null?PageBL_GetPageFromPathSegment(true, to) : sourcePage;
//Check if we're actually doing anything
if (sourcePage.ID == destPage.ID && fileToMove.Name.EqualsInvariant(name))
{
throw new AttachmentNotChangedInvalidOperationException(fileToMove.Name, destPage.Title.AsUserFriendlyName());
}
//Ensure write access to source and destination pages.
IList <PageBE> pList = PermissionsBL.FilterDisallowed(DekiContext.Current.User, new PageBE[] { sourcePage, destPage }, true, Permissions.UPDATE);
// perform the move
ResourceBE ret = AttachmentBL.Instance.MoveAttachment(fileToMove, sourcePage, destPage, name, true);
response.Return(DreamMessage.Ok(AttachmentBL.Instance.GetFileXml(ret, true, null, false)));
yield break;
}
public Yield GetFiles(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ);
uint skip = context.GetParam <uint>("skip", 0);
uint numfiles = 100;
string numfilesStr = context.GetParam("numfiles", numfiles.ToString());
if (StringUtil.EqualsInvariantIgnoreCase(numfilesStr, "ALL"))
{
numfiles = uint.MaxValue;
}
else
{
if (!uint.TryParse(numfilesStr, out numfiles))
{
throw new AttachmentCannotParseNumFilesInvalidArgumentException();
}
}
IList <ResourceBE> files = AttachmentBL.Instance.RetrieveAttachments(skip, numfiles);
XDoc ret = AttachmentBL.Instance.GetFileXml(files, false, null, null, null);
response.Return(DreamMessage.Ok(ret));
yield break;
}
public Yield SubscribeToChange(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
var wikiId = GetWikiIdFromRequest(request);
var pageId = context.GetParam <uint>("pageid");
var depth = context.GetParam("depth", "0") == "0" ? false : true;
Result <PageSubscriptionUser> userResult;
yield return(userResult = Coroutine.Invoke(GetRequestUser, request, new Result <PageSubscriptionUser>()).Catch());
if (userResult.HasException)
{
ReturnUserError(userResult.Exception, response);
yield break;
}
var userInfo = userResult.Value;
DreamMessage pageAuth = null;
yield return(_deki
.At("pages", pageId.ToString(), "allowed")
.With("permissions", "read,subscribe")
.WithHeaders(request.Headers)
.Post(new XDoc("users").Start("user").Attr("id", userInfo.Id).End(), new Result <DreamMessage>())
.Set(x => pageAuth = x));
if (!pageAuth.IsSuccessful || pageAuth.ToDocument()["user/@id"].AsText != userInfo.Id.ToString())
{
throw new DreamForbiddenException("User not permitted to subscribe to page");
}
var dataSession = GetDataSession(wikiId);
dataSession.Subscribe(userInfo.Id, pageId, depth);
response.Return(DreamMessage.Ok());
yield break;
}
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 override DreamAccess DetermineAccess(DreamContext context, DreamMessage request)
{
if (context.Feature.Signature.StartsWith("subscribers/"))
{
string id = context.GetParam("id", null);
PubSubSubscriptionSet set = _dispatcher[id];
if (set != null)
{
string accessKey = context.GetParam("access-key", null);
if (string.IsNullOrEmpty(accessKey))
{
DreamCookie cookie = DreamCookie.GetCookie(request.Cookies, "access-key");
if (cookie != null)
{
accessKey = cookie.Value;
}
}
if (StringUtil.EqualsInvariant(set.AccessKey, accessKey))
{
return(DreamAccess.Private);
}
_log.DebugFormat("no matching access-key in query or cookie for location '{0}'", id);
}
else
{
_log.DebugFormat("no subscription set for location '{0}'", id);
}
}
return(base.DetermineAccess(context, request));
}
public Yield SubscribeToChange(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
var wikiId = GetWikiIdFromRequest(request);
var pageId = context.GetParam<uint>("pageid");
var depth = context.GetParam("depth", "0") == "0" ? false : true;
Result<PageSubscriptionUser> userResult;
yield return userResult = Coroutine.Invoke(GetRequestUser, request, new Result<PageSubscriptionUser>()).Catch();
if(userResult.HasException) {
ReturnUserError(userResult.Exception, response);
yield break;
}
var userInfo = userResult.Value;
DreamMessage pageAuth = null;
yield return _deki
.At("pages", pageId.ToString(), "allowed")
.With("permissions", "read,subscribe")
.WithHeaders(request.Headers)
.Post(new XDoc("users").Start("user").Attr("id", userInfo.Id).End(), new Result<DreamMessage>())
.Set(x => pageAuth = x);
if(!pageAuth.IsSuccessful || pageAuth.ToDocument()["user/@id"].AsText != userInfo.Id.ToString()) {
throw new DreamForbiddenException("User not permitted to subscribe to page");
}
var dataSession = GetDataSession(wikiId);
dataSession.Subscribe(userInfo.Id, pageId, depth);
response.Return(DreamMessage.Ok());
yield break;
}
public Yield ExpandFolder(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
if (_directoryInfo == null)
{
throw new DreamBadRequestException("folder is misconfigured");
}
// Extract the folder to expand
string foldername = context.GetParam("foldername", String.Empty);
foldername = XUri.Decode(foldername);
if (foldername.Contains(".."))
{
response.Return(DreamMessage.Forbidden("Relative paths are not allowed"));
yield break;
}
// Extract the search pattern
string pattern = context.GetParam("pattern", null);
DirectoryInfo currentDirectory = new DirectoryInfo(_directoryInfo.FullName + Path.DirectorySeparatorChar + foldername);
XDoc result = new XDoc("results");
// If specified, retrieve all the directories under the current directory
bool topDirectoryOnly = context.GetParam("topDirectoryOnly", false);
if (!topDirectoryOnly)
{
foreach (DirectoryInfo directory in currentDirectory.GetDirectories())
{
string encodedDirectoryName = XUri.DoubleEncodeSegment((foldername + Path.DirectorySeparatorChar + directory.Name).Replace("+", "%2b"));
XUri dynamicExpandUri = DreamContext.Current.AsPublicUri(Self.At("expand", encodedDirectoryName)).With("dream.out.format", "json");
if (null != pattern)
{
dynamicExpandUri = dynamicExpandUri.With("pattern", pattern);
}
result.Start("result").Elem("name", directory.Name).Elem("dynamicexpanduri", dynamicExpandUri.ToString()).End();
}
}
// Retrieve files according to the search pattern
FileInfo[] files;
if (null != pattern)
{
files = currentDirectory.GetFiles(pattern, SearchOption.TopDirectoryOnly);
}
else
{
files = currentDirectory.GetFiles();
}
foreach (FileInfo file in files)
{
string encodedFileName = XUri.DoubleEncodeSegment((foldername + Path.DirectorySeparatorChar + file.Name).Replace("+", "%2b"));
XUri href = DreamContext.Current.AsPublicUri(Self.At("doc", encodedFileName));
result.Start("result").Elem("name", file.Name).Elem("href", href.ToString()).Elem("labelstyle", "iconitext-16 ext-" + file.Extension.TrimStart('.').ToLowerInvariant()).End();
}
response.Return(DreamMessage.Ok(result));
yield break;
}
public Yield PostImport(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string uri = context.GetParam("uri", null);
string reltopath = context.GetParam("reltopatch", "/");
DreamMessage packageMessage = request;
if (!string.IsNullOrEmpty(uri))
{
Result <DreamMessage> packageResult;
yield return(packageResult = Plug.New(uri).InvokeEx("GET", DreamMessage.Ok(), new Result <DreamMessage>()));
packageMessage = packageResult.Value;
if (!packageMessage.IsSuccessful)
{
throw new DreamAbortException(DreamMessage.BadRequest(string.Format("Unable to retrieve package from Uri '{0}': {1}", uri, packageMessage.Status)));
}
}
string tempFile = Path.GetTempFileName();
Stream tempStream = File.Create(tempFile);
Result <long> copyResult;
// TODO (steveb): use WithCleanup() to dispose of resources in case of failure
yield return(copyResult = packageMessage.ToStream().CopyTo(tempStream, packageMessage.ContentLength, new Result <long>()).Catch());
tempStream.Dispose();
if (copyResult.HasException)
{
response.Throw(copyResult.Exception);
yield break;
}
ArchivePackageReader archivePackageReader = new ArchivePackageReader(File.OpenRead(tempFile));
Result <ImportManager> importerResult;
Plug authorizedDekiApi = _dekiApi.WithHeaders(request.Headers);
// TODO (steveb): use WithCleanup() to dispose of resources in case of failure
yield return(importerResult = ImportManager.CreateAsync(authorizedDekiApi, reltopath, archivePackageReader, new Result <ImportManager>()).Catch());
if (importerResult.HasException)
{
archivePackageReader.Dispose();
File.Delete(tempFile);
response.Throw(importerResult.Exception);
yield break;
}
ImportManager importManager = importerResult.Value;
Result importResult;
yield return(importResult = importManager.ImportAsync(new Result()).Catch());
archivePackageReader.Dispose();
File.Delete(tempFile);
if (importResult.HasException)
{
response.Throw(importResult.Exception);
yield break;
}
response.Return(DreamMessage.Ok());
yield break;
}
public Yield UpdateSource(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
ISource source = Context.Current.Instance.SourceController.FromJson(request.ToText());
Result<ISource> result = new Result<ISource>();
yield return Context.Current.Instance.SourceController.Update(context.GetParam("id"), context.GetParam("rev", null), source, result);
response.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.SourceController.ToJson(result.Value)));
}
public Yield UpdateUser(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
Result<IUser> result = new Result<IUser>();
yield return Context.Current.Instance.UserController.Update(context.GetParam("id"), context.GetParam("rev"), Context.Current.Instance.UserController.FromJson(request.ToText()), result);
response.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.UserController.ToJson(result.Value)));
}
public Yield GetSubscriptions(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
var wikiId = GetWikiIdFromRequest(request);
var user = context.GetParam("userid", string.Empty);
Result <PageSubscriptionUser> userResult;
if (!string.IsNullOrEmpty(user) && user != "current")
{
uint userId;
try {
userId = Convert.ToUInt32(user);
}
catch {
throw new DreamBadRequestException(string.Format("'{0}' is an invalid user id", user));
}
yield return(userResult = Coroutine.Invoke(GetUser, userId, wikiId, new Result <PageSubscriptionUser>())
.Catch());
}
else
{
yield return(userResult = Coroutine.Invoke(GetRequestUser, request, new Result <PageSubscriptionUser>())
.Catch());
}
if (userResult.HasException)
{
ReturnUserError(userResult.Exception, response);
yield break;
}
var userInfo = userResult.Value;
var pages = new List <uint>();
var pageList = context.GetParam("pages", "");
var subscribedPages = 0;
if (!string.IsNullOrEmpty(pageList))
{
foreach (var pageId in pageList.Split(','))
{
uint id;
if (uint.TryParse(pageId, out id))
{
subscribedPages++;
pages.Add(id);
}
}
}
_log.DebugFormat("found {0} subscribed pages for request hierarchy", subscribedPages);
var dataSession = GetDataSession(wikiId);
var subscriptions = dataSession.GetSubscriptionsForUser(userInfo.Id, pages);
var subscriptionDoc = new XDoc("subscriptions");
foreach (var tuple in subscriptions)
{
subscriptionDoc.Start("subscription.page").Attr("id", tuple.PageId).Attr("depth", tuple.IncludeChildPages ? "infinity" : "0").End();
}
response.Return(DreamMessage.Ok(subscriptionDoc));
yield break;
}
public Yield GetSources(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
Result<SearchResult<ISourceSearchResult>> result = new Result<SearchResult<ISourceSearchResult>>();
int limit = context.GetParam("max", 20);
int offset = context.GetParam("offset", 0);
yield return Context.Current.Instance.IndexController.GetAllSources(limit, offset, result);
response.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.IndexController.ToJson(result.Value)));
}
public Yield GetPlaysFromSource(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
Result<SearchResult<IPlay>> result = new Result<SearchResult<IPlay>>();
int limit = context.GetParam("max", 20);
int offset = context.GetParam("offset", 0);
string id = context.GetParam("id");
yield return Context.Current.Instance.PlayController.GetPlaysFromSource(offset, limit, id, result);
response.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.PlayController.ToJson(result.Value)));
}
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;
}
public Yield GetScores(DreamContext aContext, DreamMessage aRequest, Result<DreamMessage> aResponse)
{
theLogger.Info("GetScores");
Result<SearchResult<IScoreSearchResult>> result = new Result<SearchResult<IScoreSearchResult>>();
int limit = aContext.GetParam("max", 20);
int offset = aContext.GetParam("offset", 0);
yield return Context.Current.Instance.IndexController.GetAllScores(limit, offset, result);
aResponse.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.IndexController.ToJson(result.Value)));
}
public Yield GetScoresFromSource(DreamContext aContext, DreamMessage aRequest, Result<DreamMessage> aResponse)
{
theLogger.Info("GetScoresFromSource");
Result<SearchResult<IScore>> result = new Result<SearchResult<IScore>>();
int limit = aContext.GetParam("max", 20);
int offset = aContext.GetParam("offset", 0);
string id = aContext.GetParam("id");
yield return Context.Current.Instance.ScoreController.GetScoresFromSource(id, offset, limit, result);
aResponse.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.ScoreController.ToJson(result.Value)));
}
public Yield UpdatePlay(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
string playId = context.GetParam("id");
string playRev = context.GetParam("rev");
IPlay play = Context.Current.Instance.PlayController.FromJson(request.ToText());
Result<IPlay> result = new Result<IPlay>();
yield return Context.Current.Instance.PlayController.Update(playId,playRev, play, result);
response.Return(DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.PlayController.ToJson(result.Value)));
}
public Yield GetLocalizedString(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string resource = context.GetParam("resource");
string language = context.GetParam("lang", null);
CultureInfo culture = CultureUtil.GetNonNeutralCulture(language) ?? DreamContext.Current.Culture;
string value = ResourceManager.GetString(resource, culture, null);
if (value == null)
{
throw new SiteNoSuchLocalizationResourceNotFoundException(resource);
}
response.Return(DreamMessage.Ok(MimeType.TEXT_UTF8, value));
yield break;
}
public Yield thumb(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
var slide = context.GetParam<int>("slide");
var width = context.GetParam<int>("width");
var height = context.GetParam<int>("height");
var requestInfo = new RequestInfo {
slide=slide,
width=width,
height=height
};
var image = cache.ContainsKey(requestInfo) ?
cache[requestInfo] : createImage(requestInfo);
response.Return(DreamMessage.Ok(MimeType.JPEG, image));
yield break;
}
private static bool ShowXml(DreamContext context) {
switch(context.GetParam("format", null) ?? context.GetParam("output", "cooked")) {
case "raw":
case "debug":
return false;
case "seared":
case "xml":
return true;
case "cooked":
case "html":
return false;
default:
throw new DreamBadRequestException(DekiResources.OUTPUT_PARAM_INVALID);
}
}
private static bool ShowXml(DreamContext context) {
switch(context.GetParam("format", null) ?? context.GetParam("output", "cooked")) {
case "raw":
case "debug":
return false;
case "seared":
case "xml":
return true;
case "cooked":
case "html":
return false;
default:
throw new OutputParameterInvalidArgumentException();
}
}
public Yield GetUser(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
UserBE u = GetUserFromUrlMustExist();
//Perform permission check if not looking yourself up
if (u.ID != DekiContext.Current.User.ID)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ);
}
var showGroups = !context.GetParam("exclude", "").Contains("groups");
var showProperties = !context.GetParam("exclude", "").Contains("properties");
response.Return(DreamMessage.Ok(UserBL.GetUserXmlVerbose(u, null, Utils.ShowPrivateUserInfo(u), showGroups, showProperties)));
yield break;
}
/// <summary>
/// Returns a connected/authenticated ldapclient. Authentication info either comes from
/// the standard authentication header or from local configuration.
/// Default scope and domain controller IP/Host must be in service configuration.
/// </summary>
/// <param name="requireHeaderAuth">Will only accept authenticate from request header</param>
/// <returns></returns>
private LdapClient GetLdapClient(DreamContext context, DreamMessage request, bool requireAuth)
{
string authuser = string.Empty;
string authpassword = string.Empty;
HttpUtil.GetAuthentication(context.Uri.ToUri(), request.Headers, out authuser, out authpassword);
if (_config.VerboseLogging)
{
LogUtils.LogTrace(_log, context.Feature.VerbSignature, string.Format("Performing LDAP lookup uri: '{0}' username: '******' pw: '{2}'", context.Feature.VerbSignature, authuser, authpassword));
}
if (string.IsNullOrEmpty(authuser) && requireAuth)
{
throw new DreamAbortException(DreamMessage.AccessDenied(AuthenticationRealm, "Provide credentials to authenticate with ldap"));
}
LdapClient ldap = new LdapClient(_config, authuser, authpassword, _log);
ldap.TimeLimit = context.GetParam <int>("timelimit", _config.LdapTimeOut);
if (requireAuth)
{
bool authenticated = ldap.Authenticate();
if (!authenticated)
{
string msg = string.Format("Invalid LDAP username or password. Login DN used: '{0}'", ldap.BuildBindDn(authuser));
throw new DreamAbortException(DreamMessage.AccessDenied(AuthenticationRealm, msg));
}
}
return(ldap);
}
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;
}
public Yield GetServiceById(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
bool privateDetails = PermissionsBL.IsUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
//Private feature requires api-key
var identifier = context.GetParam("id");
uint serviceId = 0;
if (identifier.StartsWith("="))
{
var serviceInfo = DekiContext.Current.Instance.RunningServices[XUri.Decode(identifier.Substring(1))];
if (serviceInfo != null)
{
serviceId = serviceInfo.ServiceId;
}
}
else
{
if (!uint.TryParse(identifier, out serviceId))
{
throw new DreamBadRequestException(string.Format("Invalid id '{0}'", identifier));
}
}
ServiceBE service = ServiceBL.GetServiceById(serviceId);
if (service == null)
{
throw new ServiceNotFoundException(identifier);
}
response.Return(DreamMessage.Ok(ServiceBL.GetServiceXmlVerbose(DekiContext.Current.Instance, service, null, privateDetails)));
yield break;
}
public Yield Register(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
string servicePath = context.GetParam("service-path");
string location = StringUtil.CreateAlphaNumericKey(8);
// register the script
XDoc config = new XDoc("config")
.Elem("manifest", servicePath)
.Elem("debug", true);
//create the script service
Result<Plug> res;
yield return res = CreateService(location, "sid://mindtouch.com/2007/12/dekiscript", config, new Result<Plug>());
Plug service = res.Value;
// register script functions in environment
XDoc manifest = service.Get().ToDocument();
string ns = manifest["namespace"].AsText;
foreach(XDoc function in manifest["function"]) {
string name = function["name"].AsText;
if(string.IsNullOrEmpty(ns)) {
_env.Vars.AddNativeValueAt(name, function["uri"].AsUri);
} else {
_env.Vars.AddNativeValueAt(ns + "." + name, function["uri"].AsUri);
}
}
response.Return(DreamMessage.Ok(MimeType.XML, manifest));
}
internal Yield PostServicesId(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
ServiceBL.EnsureServiceAdministrationAllowed();
uint id = context.GetParam <uint>("id");
ServiceBE service = DbUtils.CurrentSession.Services_GetById(id);
if (service == null)
{
throw new ServiceNotFoundException(id);
}
if (context.Verb.EqualsInvariantIgnoreCase("PUT"))
{
//Modify a service (only with PUT)
service = ServiceBL.PostServiceFromXml(request.ToDocument(), service);
response.Return(DreamMessage.Ok(ServiceBL.GetServiceXmlVerbose(DekiContext.Current.Instance, service, null)));
}
else
{
//Backward compatibility: posting an empty document restarts the service
service = ServiceBL.StartService(service, true, true);
if (service.ServiceEnabled && (service.Uri == null))
{
throw new ServiceSettingsInvalidArgumentException();
}
response.Return(DreamMessage.Ok(ServiceBL.GetServiceXmlVerbose(DekiContext.Current.Instance, service, null)));
}
yield break;
}
public Yield GetEntry(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string id = context.GetParam("id");
XAtomEntry entry = null;
// get feed
XAtomFeed feed = _feed;
if (feed != null)
{
lock (feed) {
entry = new XAtomEntry(feed[string.Format("entry[id='{0}']", Self.At(id).Uri)]);
}
}
else
{
throw new DreamBadRequestException("not initialized");
}
if (entry.IsEmpty)
{
response.Return(DreamMessage.NotFound("entry not found"));
}
else
{
response.Return(DreamMessage.Ok(MimeType.ATOM, entry));
}
yield break;
}
public Yield GetSubscribedUsers(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
var wikiId = GetWikiIdFromRequest(request);
var pageId = context.GetParam <uint>("pageid");
DreamMessage pageMsg = null;
yield return(_deki.At("pages", pageId.ToString()).WithHeaders(request.Headers).Get(new Result <DreamMessage>())
.Set(x => pageMsg = x));
if (!pageMsg.IsSuccessful)
{
response.Return(pageMsg);
}
var pages = GetPageList(pageId, pageMsg.ToDocument()["page.parent"]);
var subscriptions = GetDataSession(wikiId).GetSubscriptionsForPages(pages);
var userIds =
(from sub in subscriptions.Where(x => x.PageId == pageId || x.IncludeChildPages) select sub.UserId).
Distinct();
var userDoc = new XDoc("subscribers");
foreach (var userId in userIds)
{
userDoc.Start("subscriber")
.Attr("id", userId)
.Attr("href", _deki.At("users", userId.ToString()).Uri)
.End();
}
response.Return(DreamMessage.Ok(userDoc));
yield break;
}
public Yield GetFile(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
if (_directoryInfo == null)
{
throw new DreamBadRequestException("folder is misconfigured");
}
// Extract the filename
string filename = context.GetParam("filename", String.Empty);
filename = XUri.Decode(filename);
if (filename.Contains(".."))
{
response.Return(DreamMessage.Forbidden("Relative paths are not allowed"));
yield break;
}
FileInfo currentFile = new FileInfo(_directoryInfo.FullName + Path.DirectorySeparatorChar + filename);
// Retrieve the file
DreamMessage message = GetFile(currentFile.FullName);
message.Headers.ContentDisposition = new ContentDisposition(true, currentFile.CreationTimeUtc, currentFile.LastWriteTimeUtc, null, currentFile.Name, currentFile.Length);
response.Return(message);
yield break;
}
public Yield GetFileHandler(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string suffixPath = string.Join("" + Path.DirectorySeparatorChar, context.GetSuffixes(UriPathFormat.Decoded));
string filename = Path.Combine(_path, suffixPath);
if (Directory.Exists(filename))
{
XDoc ret = new XDoc("files");
string pattern = context.GetParam("pattern", "");
AddDirectories(new DirectoryInfo(filename), pattern, ret);
AddFiles(new DirectoryInfo(filename), pattern, ret);
response.Return(DreamMessage.Ok(ret));
yield break;
}
DreamMessage message;
try {
message = DreamMessage.FromFile(filename, StringUtil.EqualsInvariant(context.Verb, "HEAD"));
} catch (FileNotFoundException) {
message = DreamMessage.NotFound("file not found");
} catch (Exception) {
message = DreamMessage.BadRequest("invalid path");
}
// open file and stream it to the requester
response.Return(message);
}
public Yield Register(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string servicePath = context.GetParam("service-path");
string location = StringUtil.CreateAlphaNumericKey(8);
// register the script
XDoc config = new XDoc("config")
.Elem("manifest", servicePath)
.Elem("debug", true);
//create the script service
Result <Plug> res;
yield return(res = CreateService(location, "sid://mindtouch.com/2007/12/dekiscript", config, new Result <Plug>()));
Plug service = res.Value;
// register script functions in environment
XDoc manifest = service.Get().ToDocument();
string ns = manifest["namespace"].AsText;
foreach (XDoc function in manifest["function"])
{
string name = function["name"].AsText;
if (string.IsNullOrEmpty(ns))
{
_env.Vars.AddNativeValueAt(name, function["uri"].AsUri);
}
else
{
_env.Vars.AddNativeValueAt(ns + "." + name, function["uri"].AsUri);
}
}
response.Return(DreamMessage.Ok(MimeType.XML, manifest));
}
public Yield ProxyToService(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.IsUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
//Private feature requires api-key
var identifier = context.GetParam("id");
ServiceRepository.IServiceInfo serviceInfo = null;
if (identifier.StartsWith("="))
{
serviceInfo = DekiContext.Current.Instance.RunningServices[XUri.Decode(identifier.Substring(1))];
}
else
{
uint serviceId;
if (uint.TryParse(identifier, out serviceId))
{
serviceInfo = DekiContext.Current.Instance.RunningServices[serviceId];
}
else
{
throw new DreamBadRequestException(string.Format("Invalid id '{0}'", identifier));
}
}
if (serviceInfo == null)
{
throw new ServiceNotFoundException(identifier);
}
var proxyUri = serviceInfo.ServiceUri.At(context.GetSuffixes(UriPathFormat.Original).Skip(1).ToArray());
yield return(context.Relay(Plug.New(proxyUri), request, response));
}
public static CommentBE PostNewComment(PageBE page, DreamMessage request, DreamContext context) {
ValidateCommentText(request.ContentType, request.AsText());
CommentBE comment = new CommentBE();
comment.Title = context.GetParam("title", string.Empty);
comment.PageId = page.ID;
comment.Content = request.AsText();
comment.ContentMimeType = request.ContentType.ToString();
comment.PosterUserId = DekiContext.Current.User.ID;
comment.CreateDate = DateTime.UtcNow;
//Note (MaxM): Replytoid/replies not yet exposed
//ulong replyToId = context.GetParam<ulong>("replyto", 0);
//if (replyToId == 0)
// newComment.ReplyToId = null;
//else
// newComment.ReplyToId = replyToId;
ushort commentNumber;
uint commentId = DbUtils.CurrentSession.Comments_Insert(comment, out commentNumber);
if (commentId == 0) {
return null;
} else {
comment.Id = commentId;
comment.Number = commentNumber;
PageBL.Touch(page, comment.CreateDate);
RecentChangeBL.AddCommentCreateRecentChange(comment.CreateDate, page, DekiContext.Current.User, string.Format(DekiResources.COMMENT_ADDED, comment.Number.ToString()), comment);
return comment;
}
}
public Yield GetServiceById(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
bool privateDetails = PermissionsBL.IsUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
//Private feature requires api-key
var identifier = context.GetParam("id");
uint serviceId = 0;
if(identifier.StartsWith("=")) {
var serviceInfo = DekiContext.Current.Instance.RunningServices[XUri.Decode(identifier.Substring(1))];
if(serviceInfo != null) {
serviceId = serviceInfo.ServiceId;
}
} else {
if(!uint.TryParse(identifier, out serviceId)) {
throw new DreamBadRequestException(string.Format("Invalid id '{0}'", identifier));
}
}
ServiceBE service = ServiceBL.GetServiceById(serviceId);
DreamMessage responseMsg = null;
if(service == null) {
responseMsg = DreamMessage.NotFound(string.Format(DekiResources.SERVICE_NOT_FOUND, identifier));
} else {
responseMsg = DreamMessage.Ok(ServiceBL.GetServiceXmlVerbose(DekiContext.Current.Instance, service, null, privateDetails));
}
response.Return(responseMsg);
yield break;
}
public Yield GetFileRevisions(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
CheckResponseCache(context, false);
//Default change filter is CONTENT changes to preserve backwards compat
string changeFilterStr = context.GetParam("changefilter", AttachmentBL.DEFAULT_REVISION_FILTER.ToString());
ResourceBE.ChangeOperations changeFilter = ResourceBE.ChangeOperations.UNDEFINED;
if (!string.IsNullOrEmpty(changeFilterStr))
{
if (StringUtil.EqualsInvariantIgnoreCase("all", changeFilterStr))
{
changeFilter = ResourceBE.ChangeOperations.UNDEFINED;
}
else if (!SysUtil.TryParseEnum(changeFilterStr, out changeFilter))
{
throw new DreamBadRequestException("changefilter value is invalid. Possible values are ALL, " + string.Join(",", Enum.GetNames(typeof(ResourceBE.ChangeOperations))));
}
}
PageBE parentPage = null;
ResourceBE fileRevision = GetAttachment(context, request, Permissions.READ, false, false, out parentPage);
XUri listUri = AttachmentBL.Instance.GetUri(fileRevision).At("revisions").With("changefilter", changeFilterStr.ToLowerInvariant());
XDoc ret = AttachmentBL.Instance.GetFileRevisionsXml(fileRevision, changeFilter, listUri, fileRevision.Revision);
response.Return(DreamMessage.Ok(ret));
yield break;
}
public Yield GetFileHandler(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
string suffixPath = string.Join("" + Path.DirectorySeparatorChar, context.GetSuffixes(UriPathFormat.Decoded));
string filename = Path.Combine(_path, suffixPath);
if(Directory.Exists(filename)) {
XDoc ret = new XDoc("files");
string pattern = context.GetParam("pattern", "");
AddDirectories(new DirectoryInfo(filename), pattern, ret);
AddFiles(new DirectoryInfo(filename), pattern, ret);
response.Return(DreamMessage.Ok(ret));
yield break;
}
DreamMessage message;
try {
message = DreamMessage.FromFile(filename, StringUtil.EqualsInvariant(context.Verb, "HEAD"));
} catch(FileNotFoundException) {
message = DreamMessage.NotFound("file not found");
} catch(Exception) {
message = DreamMessage.BadRequest("invalid path");
}
// open file and stream it to the requester
response.Return(message);
}
protected override DreamAccess DetermineAccess(DreamContext context, string key)
{
if (!string.IsNullOrEmpty(key))
{
// Grant internal access for proper apikey
if (!string.IsNullOrEmpty(_emailApikey) && _emailApikey == key)
{
return(DreamAccess.Internal);
}
// Check whether we can test an apikey from the targeted configuration
var configuration = context.GetParam("configuration", null);
if (string.IsNullOrEmpty(configuration) && context.Request.HasDocument)
{
configuration = context.Request.ToDocument()["@configuration"].AsText;
}
if (!string.IsNullOrEmpty(configuration))
{
SmtpSettings settings;
lock (_smtpSettings) {
_smtpSettings.TryGetValue(configuration, out settings);
}
if (settings != null && !string.IsNullOrEmpty(settings.Apikey) && settings.Apikey == key)
{
return(DreamAccess.Internal);
}
}
}
return(base.DetermineAccess(context, key));
}
public Yield PostArchiveFilesRestore(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
// parameter parsing
PageBE destPage = null;
string to = context.GetParam("to", string.Empty);
if (to != string.Empty)
{
destPage = PageBL_GetPageFromPathSegment(false, to);
}
PageBE parentPage;
ResourceBE removedFile = GetAttachment(context, request, Permissions.NONE, true, true, out parentPage);
if (!removedFile.ResourceIsDeleted)
{
throw new AttachmentArchiveFileNotDeletedNotFoundException();
}
//Optionally move the restored file to the given page
if (null == destPage)
{
destPage = parentPage;
}
AttachmentBL.Instance.RestoreAttachment(removedFile, destPage, DateTime.UtcNow, 0);
response.Return(DreamMessage.Ok());
yield break;
}
public Yield PostPageRating(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
UserBE user = DekiContext.Current.User;
if (UserBL.IsAnonymous(user))
{
throw new RatingForAnonymousDeniedException(AUTHREALM, string.Empty);
}
PageBE page = PageBL_AuthorizePage(context, user, Permissions.READ, false);
string scoreStr = context.GetParam("score");
float? score = null;
if (!string.IsNullOrEmpty(scoreStr))
{
float tempScore;
if (!float.TryParse(scoreStr, out tempScore))
{
throw new RatingInvalidArgumentException();
}
score = tempScore;
}
RatingBL.SetRating(page, user, score);
XDoc ret = RatingBL.GetRatingXml(page, user);
response.Return(DreamMessage.Ok(ret));
yield break;
}
public Yield PostImport(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
string uri = context.GetParam("uri", null);
string reltopath = context.GetParam("reltopatch", "/");
DreamMessage packageMessage = request;
if(!string.IsNullOrEmpty(uri)) {
Result<DreamMessage> packageResult;
yield return packageResult = Plug.New(uri).InvokeEx("GET", DreamMessage.Ok(), new Result<DreamMessage>());
packageMessage = packageResult.Value;
if(!packageMessage.IsSuccessful) {
throw new DreamAbortException(DreamMessage.BadRequest(string.Format("Unable to retrieve package from Uri '{0}': {1}", uri, packageMessage.Status)));
}
}
string tempFile = Path.GetTempFileName();
Stream tempStream = File.Create(tempFile);
Result<long> copyResult;
// TODO (steveb): use WithCleanup() to dispose of resources in case of failure
yield return copyResult = packageMessage.ToStream().CopyTo(tempStream, packageMessage.ContentLength, new Result<long>()).Catch();
tempStream.Dispose();
if(copyResult.HasException) {
response.Throw(copyResult.Exception);
yield break;
}
ArchivePackageReader archivePackageReader = new ArchivePackageReader(File.OpenRead(tempFile));
Result<ImportManager> importerResult;
Plug authorizedDekiApi = _dekiApi.WithHeaders(request.Headers);
// TODO (steveb): use WithCleanup() to dispose of resources in case of failure
yield return importerResult = ImportManager.CreateAsync(authorizedDekiApi, reltopath, archivePackageReader, new Result<ImportManager>()).Catch();
if(importerResult.HasException) {
archivePackageReader.Dispose();
File.Delete(tempFile);
response.Throw(importerResult.Exception);
yield break;
}
ImportManager importManager = importerResult.Value;
Result importResult;
yield return importResult = importManager.ImportAsync(new Result()).Catch();
archivePackageReader.Dispose();
File.Delete(tempFile);
if(importResult.HasException) {
response.Throw(importResult.Exception);
yield break;
}
response.Return(DreamMessage.Ok());
yield break;
}
internal Yield GetQueueSize(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
var name = context.GetParam("queuename");
var queue = GetQueue(name);
response.Return(DreamMessage.Ok(new XDoc("queue").Elem("name", name).Elem("size", queue.Count)));
yield break;
}
public Yield GetArchivePageContents(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
DreamMessage ret = PageArchiveBL.BuildDeletedPageContents(context.GetParam <uint>("pageid"));
response.Return(ret);
yield break;
}
public Yield DeleteBan(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
BanBE ban = GetBanFromRequest(context, context.GetParam<uint>("banid"));
BanningBL.DeleteBan(ban);
DekiContext.Current.Instance.EventSink.BanRemoved(context.StartTime, ban);
response.Return(DreamMessage.Ok());
yield break;
}
//--- Class Methods ---
private static PageBE PageBL_GetPageFromUrl(DreamContext context, bool mustExist) {
// TODO (steveb): replace all PageBL_GetPageFromUrl() calls
var pageid = context.GetParam(PARAM_PAGEID);
var redirects = DreamContext.Current.GetParam(PARAM_REDIRECTS, int.MaxValue);
return PageBL_GetPage(pageid, redirects, mustExist);
}
internal IEnumerator<IYield> GetImportStatus(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
var wikiId = context.GetParam("wikiid");
_log.DebugFormat("checking status on instance '{0}'", wikiId);
var instance = GetInstance(wikiId, false);
var status = instance == null ? "none" : instance.Status.ToString().ToLower();
response.Return(DreamMessage.Ok(new XDoc("package-updater").Attr("wikiid", wikiId).Attr("status", status)));
yield break;
}
public new Yield GetFiles(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.READ);
uint skip = context.GetParam<uint>("skip", 0);
uint numfiles = 100;
string numfilesStr = context.GetParam("numfiles", numfiles.ToString());
if (StringUtil.EqualsInvariantIgnoreCase(numfilesStr, "ALL")) {
numfiles = uint.MaxValue;
} else {
if (!uint.TryParse(numfilesStr, out numfiles))
throw new DreamBadRequestException(DekiResources.CANNOT_PARSE_NUMFILES);
}
IList<AttachmentBE> files = AttachmentBL.Instance.RetrieveAttachments(skip, numfiles);
XDoc ret = AttachmentBL.Instance.GetFileXml(files, false, null, null, null);
response.Return(DreamMessage.Ok(ret));
yield break;
}
public Yield PostArchivePagesPageIdRestore(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
uint pageid = context.GetParam <uint>("pageid");
string targetPathStr = context.GetParam("to", string.Empty);
string reason = context.GetParam("reason", string.Empty);
Title targetPath = null;
if (!string.IsNullOrEmpty(targetPathStr))
{
targetPath = Title.FromUIUri(null, context.GetParam("to"), false);
}
XDoc responseXml = PageArchiveBL.RestoreDeletedPage(pageid, targetPath, reason);
response.Return(DreamMessage.Ok(responseXml));
yield break;
}
public Yield GetArchivePageSubpages(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
XDoc responseXml = PageArchiveBL.GetArchivedSubPagesXml(context.GetParam <uint>("pageid"));
response.Return(DreamMessage.Ok(responseXml));
yield break;
}
public Yield GetGroupInfo(DreamContext context, DreamMessage request, Result <DreamMessage> response)
{
string groupname = context.GetParam("groupname", null);
string output = context.GetParam("output", "brief").Trim();
LdapClient ldap = GetLdapClient(context, request, false);
XDoc groupXml = ldap.GetGroupInfo(StringUtil.EqualsInvariant(output, "verbose"), 3, groupname);
if (groupXml == null)
{
response.Return(DreamMessage.NotFound(string.Format("Group '{0}' not found", groupname)));
}
else
{
response.Return(DreamMessage.Ok(groupXml));
}
yield break;
}
public static IList<GroupBE> GetGroupsByQuery(DreamContext context, out uint totalCount, out uint queryCount) {
uint limit, offset;
SortDirection sortDir;
string sortFieldString;
Utils.GetOffsetAndCountFromRequest(context, 100, out limit, out offset, out sortDir, out sortFieldString);
// Attempt to read the sort field. If a parsing error occurs, default to undefined.
GroupsSortField sortField = GroupsSortField.UNDEFINED;
if(!String.IsNullOrEmpty(sortFieldString)) {
try { sortField = SysUtil.ChangeType<GroupsSortField>(sortFieldString); } catch { }
}
string groupnamefilter = context.GetParam("groupnamefilter", null);
uint? serviceid = context.GetParam<uint>("authprovider", 0);
if((serviceid ?? 0) == 0) {
serviceid = null;
}
return DbUtils.CurrentSession.Groups_GetByQuery(groupnamefilter, serviceid, sortDir, sortField, offset, limit, out totalCount, out queryCount);
}
public Yield GetUser(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
string id = context.GetParam("id");
Result<IUser> result = new Result<IUser>();
yield return Context.Current.Instance.UserController.Retrieve(id, result);
response.Return(result.Value == null
? DreamMessage.NotFound("No User found for id " + id)
: DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.UserController.ToJson((result.Value))));
}
internal DreamMessage PostHostInstanceStopByWikiId(DreamContext context, DreamMessage request) {
var wikiId = context.GetParam("wikiid", null);
if(!string.IsNullOrEmpty(wikiId)) {
if(Instancemanager.ShutdownInstance(wikiId)) {
return DreamMessage.Ok(new XDoc("tenant").Attr("wikiid", wikiId).Attr("status", "stopped"));
}
return new DreamMessage(DreamStatus.ServiceUnavailable, null);
}
return DreamMessage.Ok(new XDoc("tenant").Attr("wikiid", wikiId).Attr("status", "notrunning"));
}
public Yield Execute(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
string expression = context.GetParam("expression");
DekiScriptExpression expr = DekiScriptParser.Parse(new Location("POST:execute"), expression);
DekiScriptLiteral result = _runtime.Evaluate(expr, DekiScriptEvalMode.Evaluate, _env);
if(result.ScriptType == DekiScriptType.XML) {
response.Return(DreamMessage.Ok(MimeType.XML, (XDoc)result.NativeValue));
} else {
response.Return(DreamMessage.Ok(MimeType.TEXT, result.ToString()));
}
yield break;
}
public Yield GetSource(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
Result<ISource> result = new Result<ISource>();
string id = context.GetParam<string>("id");
yield return Context.Current.Instance.SourceController.Retrieve(id, result);
response.Return(result.Value == null
? DreamMessage.NotFound("No Source found for id " + id)
: DreamMessage.Ok(MimeType.JSON, Context.Current.Instance.SourceController.ToJson(result.Value)));
}
public Yield GetComment(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PageBE page = null;
CommentBE comment = null;
var commentId = context.GetParam<uint>("commentid", 0);
if(commentId > 0) {
comment = CommentBL.GetComment(commentId);
} else {
GetCommentFromRequest(context, Permissions.READ, out page, out comment);
}
response.Return(DreamMessage.Ok(CommentBL.GetCommentXml(comment, null)));
yield break;
}
public Yield GetScore(DreamContext aContext, DreamMessage aRequest, Result<DreamMessage> aResponse)
{
theLogger.Info("GetScore");
string id = aContext.GetParam("id");
string fileName = aContext.GetParam("fileName", ".json").ToLower();
string fileType = Path.GetExtension(fileName);
switch (fileType)
{
case ".json":
Result<IScore> resultJson = new Result<IScore>();
yield return Context.Current.Instance.ScoreController.Retrieve(id, resultJson);
aResponse.Return(resultJson.Value == null
? DreamMessage.NotFound("No Score found for id " + id)
: DreamMessage.Ok(MimeType.JSON,
Context.Current.Instance.ScoreController.ToJson(resultJson.Value)));
break;
case ".pdf":
Result<Stream> resultPdf = new Result<Stream>();
yield return Context.Current.Instance.ScoreController.GetConvertedScore(MimeType.PDF, id, resultPdf);
Stream streamPdf = resultPdf.Value;
aResponse.Return(DreamMessage.Ok(MimeType.PDF, streamPdf.Length, streamPdf));
break;
case ".xml":
Result<Stream> resultXml = new Result<Stream>();
yield return Context.Current.Instance.ScoreController.GetAttachment(id, "$musicxml.xml", resultXml);
Stream streamXml = resultXml.Value;
aResponse.Return(DreamMessage.Ok(MimeType.XML, streamXml.Length, streamXml));
break;
case ".mid":
Result<Stream> resultMidi = new Result<Stream>();
yield return Context.Current.Instance.ScoreController.GetConvertedScore(Constants.Midi, id, resultMidi);
Stream streamMidi = resultMidi.Value;
aResponse.Return(DreamMessage.Ok(Constants.Midi, streamMidi.Length, streamMidi));
break;
}
yield break;
}
