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);
}
//--- Methods ---
private void CallbackHandler(Plug plug, string verb, XUri uri, DreamMessage request, Result<DreamMessage> response) {
if(uri.Segments.Length == 0) {
response.Return(DreamMessage.Ok());
return;
}
var segments = uri.Segments;
var wikiId = segments[0];
if(wikiId.StartsWith("=")) {
var id = (HostLookupOverride == null) ? DefaultWikiId : HostLookupOverride(wikiId.Substring(1));
response.Return(DreamMessage.Ok(new XDoc("wiki").Attr("id", id)));
return;
}
if(segments.Length == 2 && segments[1] == "license") {
XDoc license;
if(LicenseOverride == null) {
_log.Debug("returning license from disk");
license = XDocFactory.LoadFrom(Utils.Settings.LicensePath, MimeType.TEXT_XML);
} else {
_log.Debug("returning license from override callback");
license = LicenseOverride(wikiId);
}
response.Return(DreamMessage.Ok(license));
return;
}
var config = (ConfigOverride == null) ? DefaultConfig : ConfigOverride(wikiId);
response.Return(DreamMessage.Ok(config));
}
public Yield GetPageTags(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PageBE page = PageBL.AuthorizePage(DekiContext.Current.User, Permissions.READ, false);
XUri href = DekiContext.Current.ApiUri.At("pages", page.ID.ToString(), "tags");
XDoc doc = TagBL.GetTagListXml(TagBL.GetTagsForPage(page), "tags", href, false);
response.Return(DreamMessage.Ok(doc));
yield break;
}
public Yield GetPageRating(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
UserBE user = DekiContext.Current.User;
PageBE page = PageBL.AuthorizePage(user, Permissions.READ, false);
XDoc ret = RatingBL.GetRatingXml(page, user);
response.Return(DreamMessage.Ok(ret));
yield break;
}
public Yield DeleteRecord(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
string name = context.GetSuffix(0, UriPathFormat.Normalized);
DeleteRecord(name);
response.Return(DreamMessage.Ok());
yield break;
}
public Yield GetArchiveFiles(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
IList<AttachmentBE> removedFiles = AttachmentBL.Instance.GetResources(DeletionFilter.DELETEDONLY, null, null);
XDoc responseXml = AttachmentBL.Instance.GetFileXml(removedFiles, true, "archive", null, null);
response.Return(DreamMessage.Ok(responseXml));
yield break;
}
public Yield GetPage(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
CheckResponseCache(context, false);
PageBE page = PageBL.GetPageFromUrl(true);
page = PageBL.AuthorizePage(DekiContext.Current.User, Permissions.READ, page, false);
response.Return(DreamMessage.Ok(PageBL.GetPageXmlVerbose(page, null)));
yield break;
}
public Result Dispatch(UpdateRecord updateRecord, Result result) {
_log.DebugFormat("got dispatch");
Dispatches.Add(new Tuplet<DateTime, UpdateRecord>(DateTime.Now, updateRecord));
result.Return();
ResetEvent.Set();
return result;
}
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 GetSiteStatus(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.UPDATE);
var status = new XDoc("status")
.Elem("state", DekiContext.Current.Instance.Status);
response.Return(DreamMessage.Ok(status));
yield break;
}
/// <summary>
/// <para>Deletes a single configuration value from a given section in the
/// CouchDB server configuration.</para>
/// <para>(This method is asynchronous.)</para>
/// </summary>
/// <param name="section">The configuration section.</param>
/// <param name="keyName">The name of the configuration key.</param>
/// <param name="result"></param>
/// <returns></returns>
public Result DeleteConfigValue(
string section,
string keyName,
Result result)
{
if (String.IsNullOrEmpty(section))
throw new ArgumentException("section cannot be null nor empty");
if (String.IsNullOrEmpty(keyName))
throw new ArgumentException("keyName cannot be null nor empty");
if (result == null)
throw new ArgumentNullException("result");
BasePlug
.At(Constants._CONFIG, XUri.EncodeFragment(section),
XUri.EncodeFragment(keyName))
.Delete(DreamMessage.Ok(), new Result<DreamMessage>())
.WhenDone(
a =>
{
if (a.Status == DreamStatus.Ok)
result.Return(); // remove " and "\n
else
result.Throw(new CouchException(a));
},
result.Throw
);
return result;
}
public Yield GetSearchDescription(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
XDoc description = new XDoc("OpenSearchDescription", "http://a9.com/-/spec/opensearch/1.1/");
description.Elem("ShortName", string.Format(DekiResources.OPENSEARCH_SHORTNAME, DekiContext.Current.Instance.SiteName))
.Elem("Description", DekiResources.OPENSEARCH_DESCRIPTION)
.Start("Query")
.Attr("role", "example")
.Attr("searchTerms", "Wiki")
.End();
// HACK HACK HACK: we can't use XUri because it encodes the "{}" characters
string uri = DekiContext.Current.ApiUri.At("site", "opensearch").ToString();
uri += "?q={searchTerms}&offset={startIndex}&limit={count?}&";
description.Start("Url")
.Attr("type", "text/html")
.Attr("indexOffset", 0)
.Attr("template", DekiContext.Current.UiUri.At("Special:Search").ToString() + "?search={searchTerms}&offset=0&limit={count?}&format=html")
.End()
.Start("Url")
.Attr("type", "application/atom+xml")
.Attr("indexOffset", 0)
.Attr("template", uri + "format=atom")
.End()
.Start("Url")
.Attr("type", "application/rss+xml")
.Attr("indexOffset", 0)
.Attr("template", uri + "format=rss")
.End()
.Start("Url")
.Attr("type", "application/x-suggestions+json")
.Attr("template", DekiContext.Current.ApiUri.At("site", "opensearch", "suggestions").ToString() + "?q={searchTerms}")
.End();
response.Return(DreamMessage.Ok(description));
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 GetInfo(DreamContext aContext, DreamMessage aRequest, Result<DreamMessage> aResponse)
{
XDoc xmlInfo = new XDoc("info");
xmlInfo.Elem("User", Context.Current.User);
xmlInfo.Elem("About", "Foiremuses web service (c) 2011 Vincent DARON / Danny WILLEM");
aResponse.Return(DreamMessage.Ok(MimeType.XML, xmlInfo));
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)));
}
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;
}
protected override Yield Start(XDoc config, Result result) {
yield return Coroutine.Invoke(base.Start, config, new Result());
// init environment for script execution
_runtime = new DekiScriptRuntime();
_env = _runtime.CreateEnv();
result.Return();
}
public Yield GetArchive(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PermissionsBL.CheckUserAllowed(DekiContext.Current.User, Permissions.ADMIN);
XDoc ret = new XDoc("archive");
ret.Start("pages.archive").Attr("href", DekiContext.Current.ApiUri.At("archive", "pages")).End();
ret.Start("files.archive").Attr("href", DekiContext.Current.ApiUri.At("archive", "files")).End();
response.Return(DreamMessage.Ok(ret));
yield break;
}
private Yield PrologueMediaWikiConverterContext(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
MediaWikiConverterContext mwContext = new MediaWikiConverterContext(Config);
DreamContext.Current.SetState<MediaWikiConverterContext>(mwContext);
// continue processing
response.Return(request);
yield break;
}
//--- Methods ---
protected override Yield Start(XDoc config, Result result)
{
yield return Coroutine.Invoke(base.Start, config, new Result());
_redirect = Plug.New(config["proxy"].AsUri ?? config["redirect"].AsUri, TimeSpan.FromSeconds(config["timeout"].AsInt ?? (int)Plug.DEFAULT_TIMEOUT.TotalSeconds));
if(_redirect == null) {
throw new ArgumentException("redirect URI missing or invalid");
}
result.Return();
}
//--- Methods ---
protected override Yield Start(XDoc config, Result result) {
yield return Coroutine.Invoke(base.Start, config, new Result());
// set up a Plug to deki for the eventual trusted authentication
Plug.New(config["uri.deki"].AsUri);
_validIdPattern = config["valid-id-pattern"].AsText;
result.Return();
}
public Yield SetPageTags(DreamContext context, DreamMessage request, Result<DreamMessage> response) {
PageBE page = PageBL_AuthorizePage(context, null, Permissions.UPDATE, false);
XUri href = DekiContext.Current.ApiUri.At("pages", page.ID.ToString(), "tags");
var tagBL = new TagBL();
tagBL.PutTagsFromXml(page, request.ToDocument());
XDoc doc = tagBL.GetTagListXml(tagBL.GetTagsForPage(page), "tags", href, false);
response.Return(DreamMessage.Ok(doc));
yield break;
}
protected override Yield Start(XDoc aConfig, IContainer aContainer, Result aResult)
{
Result res;
yield return res = Coroutine.Invoke(base.Start, aConfig, new Result());
res.Confirm();
theFactory = new InstanceFactory(aContainer, aConfig);
aResult.Return();
}
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))));
}
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 Result<IEnumerable<Tweet>> GetRecentTweets(string search, Result<IEnumerable<Tweet>> result) {
// asynchronously make and http request
Plug.New("http://search.twitter.com").At("search.atom").With("q", search)
.Get(new Result<XDoc>())
.WhenDone(r => result.Return(r.Value.ToTweets()));
// immediately return the result that can be used to await the call to complete
return result;
}
private static Yield Create_Helper(Plug dekiApi, XDoc exports, int relto, string reltopath, IPackageWriter packager, Result<ExportManager> result) {
Result<Exporter> exporterResult;
if(string.IsNullOrEmpty(reltopath)) {
yield return exporterResult = Exporter.CreateAsync(dekiApi, exports, relto, new Result<Exporter>());
} else {
yield return exporterResult = Exporter.CreateAsync(dekiApi, exports, reltopath, new Result<Exporter>());
}
result.Return(new ExportManager(exporterResult.Value, packager));
yield break;
}
public Yield Xml(
[DekiExtParam("name of Dapp to invoke")] string name,
[DekiExtParam("input uri (default: as defined by the Dapp)", true)] XUri input,
[DekiExtParam("dapp arguments (default: none)", true)] Hashtable args,
Result<XDoc> response
) {
Result<XDoc> res;
yield return res = Coroutine.Invoke(FetchResult, name, input, args, new Result<XDoc>());
response.Return(res.Value);
}
public Yield GetEntries(DreamContext context, DreamMessage request, Result<DreamMessage> response)
{
XAtomFeed feed = _feed;
if(feed != null) {
response.Return(DreamMessage.Ok(MimeType.ATOM, _feed));
} else {
throw new DreamBadRequestException("not initialized");
}
yield break;
}
