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