//--- Class Methods ---
public void RequestLog_Insert(XUri requestUri, string requestVerb, string requestHostHeader, string origin, string serviceHost, string serviceFeature, DreamStatus responseStatus, string username, uint executionTime, string response) {
string host = requestUri.HostPort;
if( !host.Contains(":"))
host = host + ":80";
//Schema for request log in "trunk/product/deki/web/maintenance/apirequestlog.sql"
Catalog.NewQuery(@" /* RequestLog_Insert */
insert delayed into requestlog (
`rl_requesthost`, `rl_requesthostheader`, `rl_requestpath`, `rl_requestparams`, `rl_requestverb`,
`rl_dekiuser`, `rl_origin`, `rl_servicehost`, `rl_servicefeature`, `rl_responsestatus`, `rl_executiontime`,
`rl_response`
) values (
?REQUESTHOST, ?REQUESTHOSTHEADER, ?REQUESTPATH, ?REQUESTPARAMS, ?REQUESTVERB,
?DEKIUSER, ?ORIGIN, ?SERVICEHOST, ?SERVICEFEATURE, ?RESPONSESTATUS, ?EXECUTIONTIME,
?RESPONSE
);")
.With("REQUESTHOST", host)
.With("REQUESTHOSTHEADER", requestHostHeader)
.With("REQUESTPATH", requestUri.Path)
.With("REQUESTPARAMS", requestUri.Query)
.With("REQUESTVERB", requestVerb)
.With("DEKIUSER", username)
.With("ORIGIN", origin == null ? String.Empty : origin.ToLowerInvariant())
.With("SERVICEHOST", serviceHost)
.With("SERVICEFEATURE", serviceFeature)
.With("RESPONSESTATUS", (int)responseStatus)
.With("EXECUTIONTIME", executionTime)
.With("RESPONSE", response)
.Execute();
}
//--- Constructors ---
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers)
{
this.Status = status;
this.Headers = new DreamHeaders(headers);
_bytes = new byte[0];
_noContent = true;
}
public DreamMessage SyncMixedPathArg(
[Path] int x,
[Path] bool y,
[Path] DreamStatus z
)
{
return(Response(new XDoc("r").Elem("x", x).Elem("y", y).Elem("z", z)));
}
public DreamMessage SyncQueryargsMixedPathArgNoAttr(
int x,
bool y,
DreamStatus z
)
{
return(Response(new XDoc("r").Elem("x", x).Elem("y", y).Elem("z", z)));
}
public DreamMessage SyncMixedArgs(
int x,
bool y,
[Path] DreamStatus z,
[Query] Decimal v
)
{
return(Response(new XDoc("r").Elem("x", x).Elem("y", y).Elem("z", z).Elem("v", v)));
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status)
{
if(response.Status == status) {
return;
}
Assert.Fail(
string.Format("Request status was {0} instead of {1} failed:\r\n{2}",
response.Status,
status,
(response.HasDocument
? string.Format("{0}: {1}", response.Status, response.ToDocument()["message"].AsText)
: response.Status.ToString())));
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type</param>
/// <param name="contentLength">Content byte langth</param>
/// <param name="stream">Stream to uas as the source for the message's content.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, long contentLength, Stream stream)
{
this.Status = status;
this.Headers = new DreamHeaders(headers);
if (contentLength != -1)
{
this.Headers.ContentLength = contentLength;
}
this.Headers.ContentType = contentType ?? MimeType.DefaultMimeType;
// set stream
_stream = stream ?? Stream.Null;
_streamOpen = !_stream.IsStreamMemorized();
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="bytes">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, byte[] bytes)
{
if (bytes == null)
{
throw new ArgumentNullException("bytes");
}
this.Status = status;
this.Headers = new DreamHeaders(headers);
this.Headers.ContentLength = bytes.LongLength;
this.Headers.ContentType = contentType ?? MimeType.DefaultMimeType;
// set bytes
_bytes = bytes;
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status)
{
if (response.Status == status)
{
return;
}
Assert.Fail(
string.Format("Request status was {0} instead of {1} failed:\r\n{2}",
response.Status,
status,
(response.HasDocument
? string.Format("{0}: {1}", response.Status, response.ToDocument()["message"].AsText)
: response.Status.ToString())));
}
private static XDoc GetDefaultErrorResponse(DreamStatus status, string title, string message)
{
XDoc result = new XDoc("error");
DreamContext context = DreamContext.CurrentOrNull;
if ((context != null) && (context.Env.Self != null))
{
result.WithXslTransform(context.AsPublicUri(context.Env.Self).At("resources", "error.xslt").Path);
}
result.Elem("status", (int)status).Elem("title", title).Elem("message", message);
if (context != null)
{
result.Elem("uri", context.Uri);
}
return(result);
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
/// <param name="failureMessage">Failure message.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status, string failureMessage)
{
if(response.Status == status) {
return;
}
if(!string.IsNullOrEmpty(failureMessage)) {
failureMessage = failureMessage + "\r\n";
}
Assert.Fail(
string.Format("{0}Request status was {1} instead of {2}:\r\n{3}",
failureMessage,
response.Status,
status,
(response.HasDocument
? string.Format("{0}: {1}", response.Status, response.ToDocument()["message"].AsText)
: response.Status.ToString())));
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
/// <param name="failureMessage">Failure message.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status, string failureMessage)
{
if (response.Status == status)
{
return;
}
if (!string.IsNullOrEmpty(failureMessage))
{
failureMessage = failureMessage + "\r\n";
}
Assert.Fail(
string.Format("{0}Request status was {1} instead of {2}:\r\n{3}",
failureMessage,
response.Status,
status,
(response.HasDocument
? string.Format("{0}: {1}", response.Status, response.ToDocument()["message"].AsText)
: response.Status.ToString())));
}
private static XDoc GetFeatureOverview(XDoc feature)
{
// generate a document containing the overview information for a feature
XDoc overviewDoc = new XDoc("html");
overviewDoc.Start("h2").Value("Overview").End();
overviewDoc.Add(GetWarning());
overviewDoc.Start("p").Start("strong").Value(feature["access"].Contents + ". ").End().Value(feature["description"].Contents).End();
XDoc uriParams = new XDoc("uriParams");
XDoc queryParams = new XDoc("queryParams");
foreach (XDoc param in feature["param"])
{
string paramName = param["name"].Contents;
if (paramName.StartsWith("{"))
{
if (feature["pattern"].Contents.Contains(paramName))
{
param["name"].ReplaceValue(paramName.Trim(new char[] { '{', '}' }));
uriParams.Add(param);
}
}
else
{
queryParams.Add(param);
}
}
overviewDoc.Start("h5").Value("Uri Parameters").End();
overviewDoc.Add(GetTable(new string[] { "Name", "Type", "Description" }, uriParams["param"]));
overviewDoc.Start("h5").Value("Query Parameters").End();
overviewDoc.Add(GetTable(new string[] { "Name", "Type", "Description" }, queryParams["param"]));
overviewDoc.Start("h5").Value("Return Codes").End();
XDoc statusesDoc = new XDoc("statuses");
foreach (XDoc statusDoc in feature["status"])
{
DreamStatus status = (DreamStatus)statusDoc["@value"].AsInt;
statusesDoc.Start("status").Elem("name", status.ToString()).Elem("value", (int)status).Elem("description", statusDoc.Contents).End();
}
overviewDoc.Add(GetTable(new string[] { "Name", "Value", "Description" }, statusesDoc["status"]));
return(overviewDoc);
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="doc">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, XDoc doc)
{
if (doc == null)
{
throw new ArgumentNullException("doc");
}
this.Status = status;
this.Headers = new DreamHeaders(headers);
// check if document is empty
if (doc.IsEmpty)
{
// we store empty XML documents as text content; it causes less confusion for browsers
this.Headers.ContentType = MimeType.TEXT;
this.Headers.ContentLength = 0L;
_doc = doc;
_bytes = new byte[0];
}
else
{
this.Headers.ContentType = contentType ?? MimeType.XML;
_doc = doc.Clone();
}
}
public DreamMessage SyncQueryargsEnumPathArgNoAttr(
DreamStatus x
)
{
return Response(new XDoc("r").Elem("x", x));
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="bytes">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, byte[] bytes) {
if(bytes == null) {
throw new ArgumentNullException("bytes");
}
this.Status = status;
this.Headers = new DreamHeaders(headers);
this.Headers.ContentLength = bytes.LongLength;
this.Headers.ContentType = contentType ?? MimeType.DefaultMimeType;
// set bytes
_bytes = bytes;
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="text">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, string text)
: this(status, headers, contentType, contentType.CharSet.GetBytes(text)) { }
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="doc">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, XDoc doc) : this(status, headers, MimeType.XML, doc) { }
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type</param>
/// <param name="contentLength">Content byte langth</param>
/// <param name="stream">Stream to uas as the source for the message's content.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, long contentLength, Stream stream) {
this.Status = status;
this.Headers = new DreamHeaders(headers);
if(contentLength != -1) {
this.Headers.ContentLength = contentLength;
}
this.Headers.ContentType = contentType ?? MimeType.DefaultMimeType;
// set stream
_stream = stream ?? Stream.Null;
_streamOpen = !_stream.IsStreamMemorized();
}
//--- Constructors ---
/// <summary>
/// Create new attribute.
/// </summary>
/// <param name="status">Status message for Feature.</param>
/// <param name="description">Description of scenario under which Status is returned.</param>
public DreamFeatureStatusAttribute(DreamStatus status, string description)
{
_status = status;
_description = description;
}
public DreamMessage SyncEnumPathArg(
[Path] DreamStatus x
)
{
return(Response(new XDoc("r").Elem("x", x)));
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="text">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, string text)
: this(status, headers, contentType, contentType.CharSet.GetBytes(text))
{
}
private static XDoc GetDefaultErrorResponse(DreamStatus status, string title, string message) {
XDoc result = new XDoc("error");
DreamContext context = DreamContext.CurrentOrNull;
if((context != null) && (context.Env.Self != null)) {
result.WithXslTransform(context.AsPublicUri(context.Env.Self).At("resources", "error.xslt").Path);
}
result.Elem("status", (int)status).Elem("title", title).Elem("message", message);
if(context != null) {
result.Elem("uri", context.Uri);
}
return result;
}
//--- Constructors ---
/// <summary>
/// Create new attribute.
/// </summary>
/// <param name="status">Status message for Feature.</param>
/// <param name="description">Description of scenario under which Status is returned.</param>
public DreamFeatureStatusAttribute(DreamStatus status, string description)
{
_status = status;
_description = description;
}
public void RequestLog_Insert(XUri requestUri, string requestVerb, string requestHostHeader, string origin, string serviceHost, string serviceFeature, DreamStatus responseStatus, string username, uint executionTime, string response) {
_next.RequestLog_Insert(requestUri, requestVerb, requestHostHeader, origin, serviceHost, serviceFeature, responseStatus, username, executionTime, response);
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="doc">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, XDoc doc) : this(status, headers, MimeType.XML, doc)
{
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status)
{
AssertStatus(response, status, null);
}
//--- Class Methods ---
public void RequestLog_Insert(XUri requestUri, string requestVerb, string requestHostHeader, string origin, string serviceHost, string serviceFeature, DreamStatus responseStatus, string username, uint executionTime, string response)
{
string host = requestUri.HostPort;
if (!host.Contains(":"))
{
host = host + ":80";
}
//Schema for request log in "trunk/product/deki/web/maintenance/apirequestlog.sql"
Catalog.NewQuery(@" /* RequestLog_Insert */
insert delayed into requestlog (
`rl_requesthost`, `rl_requesthostheader`, `rl_requestpath`, `rl_requestparams`, `rl_requestverb`,
`rl_dekiuser`, `rl_origin`, `rl_servicehost`, `rl_servicefeature`, `rl_responsestatus`, `rl_executiontime`,
`rl_response`
) values (
?REQUESTHOST, ?REQUESTHOSTHEADER, ?REQUESTPATH, ?REQUESTPARAMS, ?REQUESTVERB,
?DEKIUSER, ?ORIGIN, ?SERVICEHOST, ?SERVICEFEATURE, ?RESPONSESTATUS, ?EXECUTIONTIME,
?RESPONSE
);")
.With("REQUESTHOST", host)
.With("REQUESTHOSTHEADER", requestHostHeader)
.With("REQUESTPATH", requestUri.Path)
.With("REQUESTPARAMS", requestUri.Query)
.With("REQUESTVERB", requestVerb)
.With("DEKIUSER", username)
.With("ORIGIN", origin == null ? String.Empty : origin.ToLowerInvariant())
.With("SERVICEHOST", serviceHost)
.With("SERVICEFEATURE", serviceFeature)
.With("RESPONSESTATUS", (int)responseStatus)
.With("EXECUTIONTIME", executionTime)
.With("RESPONSE", response)
.Execute();
}
public DreamMessage SyncQueryargsMixedPathArgNoAttr(
int x,
bool y,
DreamStatus z
)
{
return Response(new XDoc("r").Elem("x", x).Elem("y", y).Elem("z", z));
}
//--- Constructors ---
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers) {
this.Status = status;
this.Headers = new DreamHeaders(headers);
_bytes = new byte[0];
_noContent = true;
}
public DreamMessage SyncQueryargsNullableEnumPathArgNoAttr(
DreamStatus? x
)
{
var v = x.HasValue ? x.ToString() : "null";
return Response(new XDoc("r").Elem("x", v));
}
/// <summary>
/// Create a new message.
/// </summary>
/// <param name="status">Http status.</param>
/// <param name="headers">Header collection.</param>
/// <param name="contentType">Content Mime-Type.</param>
/// <param name="doc">Message body.</param>
public DreamMessage(DreamStatus status, DreamHeaders headers, MimeType contentType, XDoc doc) {
if(doc == null) {
throw new ArgumentNullException("doc");
}
this.Status = status;
this.Headers = new DreamHeaders(headers);
// check if document is empty
if(doc.IsEmpty) {
// we store empty XML documents as text content; it causes less confusion for browsers
this.Headers.ContentType = MimeType.TEXT;
this.Headers.ContentLength = 0L;
_doc = doc;
_bytes = new byte[0];
} else {
this.Headers.ContentType = contentType ?? MimeType.XML;
_doc = doc.Clone();
}
}
/// <summary>
/// Assert that the status of the message is equal to an expected value.
/// </summary>
/// <param name="response">Response message.</param>
/// <param name="status">Status to assert.</param>
public static void AssertStatus(this DreamMessage response, DreamStatus status)
{
AssertStatus(response, status, null);
}
public DreamMessage SyncQueryargsEnumPathArgNoAttr(
DreamStatus x
)
{
return(Response(new XDoc("r").Elem("x", x)));
}
