protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
var store = container.Resolve<IDocumentStore>();
container.Register<IDocumentSession>(store.OpenSession());
}
/// <summary>
/// Gets all matches for a given requested route
/// Overridden to handle greedy capturing
/// </summary>
/// <param name="segments">Requested route segments</param>
/// <param name="currentIndex">Current index in the route segments</param>
/// <param name="capturedParameters">Currently captured parameters</param>
/// <param name="context">Current Nancy context</param>
/// <returns>A collection of <see cref="MatchResult"/> objects</returns>
public override IEnumerable<MatchResult> GetMatches(string[] segments, int currentIndex, IDictionary<string, object> capturedParameters, NancyContext context)
{
var fullGreedy = this.GetFullGreedy(segments, currentIndex, capturedParameters);
if (!this.Children.Any())
{
return fullGreedy;
}
var sb = new StringBuilder(segments[currentIndex]);
var results = new List<MatchResult>();
currentIndex++;
while (!this.NoMoreSegments(segments, currentIndex - 1))
{
var currentSegment = segments[currentIndex];
TrieNode matchingChild;
if (this.Children.TryGetValue(currentSegment, out matchingChild))
{
var parameters = new Dictionary<string, object>(capturedParameters);
parameters[this.parameterName] = sb.ToString();
results.AddRange(matchingChild.GetMatches(segments, currentIndex, parameters, context));
}
sb.AppendFormat("/{0}", currentSegment);
currentIndex++;
}
if (!results.Any())
{
results.AddRange(fullGreedy);
}
return results;
}
public void Should_add_negotiated_headers_to_response()
{
// Given
var module = new ConfigurableNancyModule(with =>
{
with.Get("/headers", x =>
{
var context =
new NancyContext { NegotiationContext = new NegotiationContext() };
var negotiator =
new Negotiator(context);
negotiator.WithHeader("foo", "bar");
return negotiator;
});
});
var brower = new Browser(with =>
{
with.ResponseProcessor<TestProcessor>();
with.Module(module);
});
// When
var response = brower.Get("/headers");
// Then
Assert.True(response.Headers.ContainsKey("foo"));
Assert.Equal("bar", response.Headers["foo"]);
}
/// <summary>
/// Applies a filter to the provided list of routes. Routes that do not pass the filter will be places in the second item of the returned tuple
/// along with the provided <paramref name="rejectReason"/>.
/// </summary>
/// <param name="routes">The routes that the filter should be applied to.</param>
/// <param name="context">The context of the current request.</param>
/// <param name="rejectReason">The message that should be attached to rejected routes.</param>
/// <param name="condition">The condition that routes need to fulfill.</param>
/// <returns>A tuple of valid and rejected routes.</returns>
public static Tuple<List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>, Dictionary<string, List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>>> Filter(this Tuple<List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>, Dictionary<string, List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>>> routes, NancyContext context, string rejectReason, Func<NancyContext, Tuple<string, int, RouteDescription, IRoutePatternMatchResult>, Tuple<bool, Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>> condition)
{
var result = new Tuple<List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>, Dictionary<string, List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>>>(
new List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>(),
routes.Item2
);
foreach (var conditionResult in routes.Item1.Select(route => condition.Invoke(context, route)))
{
if (conditionResult.Item1)
{
result.Item1.Add(conditionResult.Item2);
}
else
{
if (!result.Item2.ContainsKey(rejectReason))
{
result.Item2.Add(rejectReason, new List<Tuple<string, int, RouteDescription, IRoutePatternMatchResult>>());
}
result.Item2[rejectReason].Add(conditionResult.Item2);
}
}
return result;
}
public void Should_apply_default_accept_when_no_accept_header_sent()
{
// Given
var browser = new Browser(with =>
{
with.ResponseProcessor<TestProcessor>();
with.Module(new ConfigurableNancyModule(x =>
{
x.Get("/", parameters =>
{
var context =
new NancyContext { NegotiationContext = new NegotiationContext() };
var negotiator =
new Negotiator(context);
return negotiator;
});
}));
});
// When
var response = browser.Get("/");
// Then
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Handle the error code
/// </summary>
/// <param name="statusCode">Status code</param>
/// <param name="context">The <see cref="NancyContext"/> instance of the current request.</param>
/// <returns>Nancy Response</returns>
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
if (context.Response != null && context.Response.Contents != null && !ReferenceEquals(context.Response.Contents, Response.NoBody))
{
return;
}
string errorPage;
if (!this.errorPages.TryGetValue(statusCode, out errorPage))
{
return;
}
if (String.IsNullOrEmpty(errorPage))
{
return;
}
Func<HttpStatusCode, NancyContext, string, string> expansionDelegate;
if (this.expansionDelegates.TryGetValue(statusCode, out expansionDelegate))
{
errorPage = expansionDelegate.Invoke(statusCode, context, errorPage);
}
ModifyResponse(statusCode, context, errorPage);
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig" /> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration,
params string[] blackList)
{
Type genericType = null;
if (modelType.IsArray() || modelType.IsCollection() || modelType.IsEnumerable())
{
//make sure it has a generic type
if (modelType.IsGenericType())
{
genericType = modelType.GetGenericArguments().FirstOrDefault();
}
else
{
var implementingIEnumerableType =
modelType.GetInterfaces().Where(i => i.IsGenericType()).FirstOrDefault(
i => i.GetGenericTypeDefinition() == typeof (IEnumerable<>));
genericType = implementingIEnumerableType == null ? null : implementingIEnumerableType.GetGenericArguments().FirstOrDefault();
}
if (genericType == null)
{
throw new ArgumentException("When modelType is an enumerable it must specify the type", "modelType");
}
}
var bindingContext =
CreateBindingContext(context, modelType, instance, configuration, blackList, genericType);
var bodyDeserializedModel = DeserializeRequestBody(bindingContext);
return (instance as IEnumerable<string>) ?? bodyDeserializedModel;
}
public Response Process(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
return new JsonResponse(BuildHypermedia(model, context), serializer)
{
ContentType = "application/hal+json"
};
}
private dynamic BuildHypermedia(object model, NancyContext context)
{
if (model == null) return null;
if (model is IEnumerable)
{
//how to handle a collection at the root resource level?
return ((IEnumerable)model).Cast<object>().Select(x => BuildHypermedia(x, context));
}
IDictionary<string, object> halModel = model.ToDynamic();
var typeConfig = configuration.GetTypeConfiguration(model.GetType());
if (typeConfig == null) return halModel;
var links = typeConfig.LinksFor(model, context).ToArray();
if (links.Any())
halModel["_links"] = links.GroupBy(l => l.Rel).ToDictionary(grp => grp.Key, grp => BuildDynamicLinksOrLink(grp));
var embeddedResources = typeConfig.Embedded().ToArray();
if (embeddedResources.Any())
{
// Remove original objects from the model (if they exist)
foreach (var embedded in embeddedResources)
halModel.Remove(embedded.OriginalPropertyName);
halModel["_embedded"] = embeddedResources.ToDictionary(info => info.Rel, info => BuildHypermedia(info.GetEmbeddedResource(model), context));
}
var ignoredProperties = typeConfig.Ignored().ToArray();
if (ignoredProperties.Any())
{
//remove ignored properties from the output
foreach (var ignored in ignoredProperties) halModel.Remove(ignored);
}
return halModel;
}
public void ModifyResponseToRedirectToSessionAwareUrl(NancyContext context, SessionIdentificationData sessionIdentificationData, string parameterName) {
if (context == null) throw new ArgumentNullException("context");
if (sessionIdentificationData == null) throw new ArgumentNullException("sessionIdentificationData");
if (string.IsNullOrWhiteSpace(parameterName)) throw new ArgumentNullException("parameterName");
if (context.Request == null) throw new ArgumentException("The specified context does not contain a request", "context");
if (context.Response == null) throw new ArgumentException("The specified context does not contain a response", "context");
var originalUri = (Uri) context.Request.Url;
var uriBuilder = new UriBuilder(originalUri);
var queryParameters = HttpUtility.ParseQueryString(uriBuilder.Query);
queryParameters.Set(parameterName, sessionIdentificationData.ToString());
var newQueryString = string.Empty;
if (queryParameters.Count > 0) {
var newQueryBuilder = new StringBuilder();
foreach (var paramName in queryParameters.AllKeys) {
newQueryBuilder.Append(string.Format("{0}={1}&", paramName, HttpUtility.UrlEncode(queryParameters[paramName])));
}
newQueryString = newQueryBuilder.ToString().TrimEnd('&');
}
uriBuilder.Query = newQueryString;
var redirectUrl = uriBuilder.ToString();
context.Response.StatusCode = HttpStatusCode.Found;
context.Response.Headers["Location"] = redirectUrl;
}
/// <summary>
/// Gets the route, and the corresponding parameter dictionary from the URL
/// </summary>
/// <param name="context">Current context</param>
/// <param name="routeCache">Route cache</param>
/// <returns>Tuple - Item1 being the Route, Item2 being the parameters dictionary, Item3 being the prereq, Item4 being the postreq</returns>
public ResolveResult Resolve(NancyContext context, IRouteCache routeCache)
{
if (routeCache.IsEmpty())
{
return new ResolveResult(new NotFoundRoute(context.Request.Method, context.Request.Uri), DynamicDictionary.Empty, null, null);
}
var routesThatMatchRequestedPath = this.GetRoutesThatMatchRequestedPath(routeCache, context);
if (NoRoutesWereAbleToBeMatchedInRouteCache(routesThatMatchRequestedPath))
{
return new ResolveResult(new NotFoundRoute(context.Request.Method, context.Request.Uri), DynamicDictionary.Empty, null, null);
}
var routesWithCorrectRequestMethod =
GetRoutesWithCorrectRequestMethod(context.Request, routesThatMatchRequestedPath);
if (NoRoutesWereForTheRequestedMethod(routesWithCorrectRequestMethod))
{
return new ResolveResult(new MethodNotAllowedRoute(context.Request.Uri, context.Request.Method), DynamicDictionary.Empty, null, null);
}
var routeMatchesWithMostParameterCaptures =
GetRouteMatchesWithMostParameterCaptures(routesWithCorrectRequestMethod);
var routeMatchToReturn =
GetSingleRouteToReturn(routeMatchesWithMostParameterCaptures);
return this.CreateRouteAndParametersFromMatch(context, routeMatchToReturn);
}
private object ResolveMethodParameter(ParameterInfo methodParameterInfo, IDictionary<string, object> queryParameters, NancyContext context)
{
if (IsQueryParameter(methodParameterInfo, queryParameters))
return GetValueFromQueryParameters(methodParameterInfo, queryParameters);
return GetValueFromRequestBody(methodParameterInfo, context);
}
public ProcessorMatch CanProcess(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
if (IsExactSirenContentType(requestedMediaRange))
{
return new ProcessorMatch
{
ModelResult = MatchResult.DontCare,
RequestedContentTypeResult = MatchResult.ExactMatch
};
}
if (IsWildcardSirenContentType(requestedMediaRange))
{
return new ProcessorMatch
{
ModelResult = MatchResult.DontCare,
RequestedContentTypeResult = MatchResult.NonExactMatch
};
}
return new ProcessorMatch
{
ModelResult = MatchResult.DontCare,
RequestedContentTypeResult = MatchResult.NoMatch
};
}
private static RollbarRequest GetRollbarRequest(NancyContext context) {
var rr = new RollbarRequest {
Url = context.Request.Url.ToString(),
Method = context.Request.Method,
Headers = context.Request.Headers.ToDictionary(x => x.Key, x => string.Join(",", x.Value)),
Params = ((IDictionary<string, object>)context.Parameters).ToDictionary(x => x.Key, x => x.Value),
UserIp = context.Request.UserHostAddress,
};
if (rr.Params.Count == 0) {
rr.Params = null;
}
if (rr.Method == "GET") {
rr.GetParams = ((IDictionary<string, object>) context.Request.Query).ToDictionary(x => x.Key, x => x.Value);
if (rr.GetParams.Count == 0) {
rr.GetParams = null;
}
}
if (rr.Method == "POST") {
rr.PostParams = ((IDictionary<string, object>) context.Request.Form)
.Concat((IDictionary<string, object>) context.Parameters)
.ToDictionary(x => x.Key, x => x.Value);
if (rr.PostParams.Count == 0) {
rr.PostParams = null;
}
rr.PostBody = context.Request.Body.AsString();
}
return rr;
}
public NancyEngineFixture()
{
this.resolver = A.Fake<IRouteResolver>();
this.response = new Response();
this.route = new FakeRoute(response);
this.context = new NancyContext();
this.errorHandler = A.Fake<IErrorHandler>();
this.requestDispatcher = A.Fake<IRequestDispatcher>();
A.CallTo(() => this.requestDispatcher.Dispatch(A<NancyContext>._)).Invokes(x => this.context.Response = new Response());
A.CallTo(() => errorHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored, A<NancyContext>.Ignored)).Returns(false);
contextFactory = A.Fake<INancyContextFactory>();
A.CallTo(() => contextFactory.Create()).Returns(context);
A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null, null));
var applicationPipelines = new Pipelines();
this.routeInvoker = A.Fake<IRouteInvoker>();
A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<DynamicDictionary>._, A<NancyContext>._)).ReturnsLazily(arg =>
{
return (Response)((Route)arg.Arguments[0]).Action.Invoke((DynamicDictionary)arg.Arguments[1]);
});
this.engine =
new NancyEngine(this.requestDispatcher, contextFactory, new[] { this.errorHandler }, A.Fake<IRequestTracing>())
{
RequestPipelinesFactory = ctx => applicationPipelines
};
}
public FormsAuthenticationFixture()
{
this.cryptographyConfiguration = new CryptographyConfiguration(
new RijndaelEncryptionProvider(new PassphraseKeyGenerator("SuperSecretPass", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 1000)),
new DefaultHmacProvider(new PassphraseKeyGenerator("UberSuperSecure", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 1000)));
this.config = new FormsAuthenticationConfiguration()
{
CryptographyConfiguration = this.cryptographyConfiguration,
RedirectUrl = "/login",
UserMapper = A.Fake<IUserMapper>(),
RequiresSSL = false
};
this.secureConfig = new FormsAuthenticationConfiguration()
{
CryptographyConfiguration = this.cryptographyConfiguration,
RedirectUrl = "/login",
UserMapper = A.Fake<IUserMapper>(),
RequiresSSL = true
};
this.context = new NancyContext
{
Request = new Request(
"GET",
new Url { Scheme = "http", BasePath = "/testing", HostName = "test.com", Path = "test" })
};
this.userGuid = new Guid("3D97EB33-824A-4173-A2C1-633AC16C1010");
}
public void Should_fail_to_create_xdocument_from_non_xml_body()
{
var context = new NancyContext() { Response = "hello" };
sut = new BrowserResponse(context, A.Fake<Browser>());
Assert.Throws<XmlException>(() => sut.BodyAsXml());
}
private static string GetEmbeddedStaticContent(string virtualDirectory, string requestedFilename, string root = null)
{
var resource =
string.Format("/{0}/{1}", virtualDirectory, requestedFilename);
var context =
new NancyContext
{
Request = new Request("GET", resource, "http")
};
var assembly =
Assembly.GetExecutingAssembly();
var resolver =
EmbeddedStaticContentConventionBuilder.AddDirectory(virtualDirectory, assembly, "Resources");
var response =
resolver.Invoke(context, null) as EmbeddedFileResponse;
if (response != null)
{
using (var stream = new MemoryStream())
{
response.Contents(stream);
return Encoding.UTF8.GetString(stream.GetBuffer(), 0, (int)stream.Length);
}
}
return null;
}
public void Should_fail_to_return_xml_body_on_non_xml_response()
{
var response = new JsonResponse<Model>(new Model() { Dummy = "Data" });
var context = new NancyContext() { Response = response };
Assert.Throws<InvalidOperationException>(() => context.XmlBody<Model>());
}
private static void AddLinkHeaders(NancyContext context, IEnumerable<Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>> compatibleHeaders, Response response)
{
var linkProcessors = new Dictionary<string, MediaRange>();
var compatibleHeaderMappings =
compatibleHeaders.SelectMany(m => m.Item2).SelectMany(p => p.Item1.ExtensionMappings);
foreach (var compatibleHeaderMapping in compatibleHeaderMappings)
{
if (!compatibleHeaderMapping.Item2.Matches(response.ContentType))
{
linkProcessors[compatibleHeaderMapping.Item1] = compatibleHeaderMapping.Item2;
}
}
if (!linkProcessors.Any())
{
return;
}
var baseUrl =
context.Request.Url.BasePath + "/" + Path.GetFileNameWithoutExtension(context.Request.Url.Path);
var links = linkProcessors.Keys
.Select(lp => string.Format("<{0}.{1}>; rel=\"{2}\"", baseUrl, lp, linkProcessors[lp]))
.Aggregate((lp1, lp2) => lp1 + "," + lp2);
response.Headers["Link"] = links;
}
/// <summary>
/// Negotiates the response based on the given result and context.
/// </summary>
/// <param name="routeResult">The route result.</param>
/// <param name="context">The context.</param>
/// <returns>A <see cref="Response" />.</returns>
public Response NegotiateResponse(dynamic routeResult, NancyContext context)
{
Response response;
if (TryCastResultToResponse(routeResult, out response))
{
context.WriteTraceLog(sb =>
sb.AppendLine("[DefaultResponseNegotiator] Processing as real response"));
return response;
}
context.WriteTraceLog(sb =>
sb.AppendLine("[DefaultResponseNegotiator] Processing as negotiation"));
NegotiationContext negotiationContext = GetNegotiationContext(routeResult, context);
var coercedAcceptHeaders = this.GetCoercedAcceptHeaders(context).ToArray();
context.WriteTraceLog(sb => GetAccepHeaderTraceLog(context, negotiationContext, coercedAcceptHeaders, sb));
var compatibleHeaders = this.GetCompatibleHeaders(coercedAcceptHeaders, negotiationContext, context).ToArray();
if (!compatibleHeaders.Any())
{
context.WriteTraceLog(sb =>
sb.AppendLine("[DefaultResponseNegotiator] Unable to negotiate response - no headers compatible"));
return new NotAcceptableResponse();
}
return CreateResponse(compatibleHeaders, negotiationContext, context);
}
/// <summary>
/// Handle the error code
/// </summary>
/// <param name="statusCode">Status code</param>
/// <param name="context">The <see cref="NancyContext"/> instance of the current request.</param>
/// <returns>Nancy Response</returns>
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
if (context.Response != null && context.Response.Contents != null && !ReferenceEquals(context.Response.Contents, Response.NoBody))
{
return;
}
if (!this.errorMessages.ContainsKey(statusCode) || !this.errorPages.ContainsKey(statusCode))
{
return;
}
var result = new DefaultStatusCodeHandlerResult(statusCode, this.errorMessages[statusCode], StaticConfiguration.DisableErrorTraces ? DisableErrorTracesTrueMessage : context.GetExceptionDetails());
try
{
context.Response = this.responseNegotiator.NegotiateResponse(result, context);
context.Response.StatusCode = statusCode;
return;
}
catch (ViewNotFoundException)
{
// No view will be found for `DefaultStatusCodeHandlerResult`
// because it is rendered from embedded resources below
}
this.ModifyResponse(statusCode, context, result);
}
public ResponseManipulatorForSessionFixture() {
_responseManipulatorForSession = new ResponseManipulatorForSession();
_context = new NancyContext {Response = new Response(), Request = new Request("GET", "http://www.google.be")};
_sessionIdentificationData = new SessionIdentificationData {SessionId = "01SessionId", Hmac = new byte[] {211, 81, 204, 0, 47, 124}};
_parameterName = "SID";
}
/// <summary>
/// Creates a token from a <see cref="IUserIdentity"/>.
/// </summary>
/// <param name="userIdentity">The user identity from which to create a token.</param>
/// <param name="context">Current <see cref="NancyContext"/>.</param>
/// <returns>The generated token.</returns>
public string Tokenize(IUserIdentity userIdentity, NancyContext context)
{
var items = new List<string>
{
userIdentity.UserName,
string.Join(this.claimsDelimiter, userIdentity.Claims),
this.tokenStamp().Ticks.ToString(CultureInfo.InvariantCulture)
};
if (this.additionalItems != null)
{
foreach (var item in this.additionalItems.Select(additionalItem => additionalItem(context)))
{
if (string.IsNullOrWhiteSpace(item))
{
throw new RouteExecutionEarlyExitException(new Response { StatusCode = HttpStatusCode.Unauthorized });
}
items.Add(item);
}
}
var message = string.Join(this.itemDelimiter, items);
var token = CreateToken(message);
return token;
}
public void Should_add_negotiated_content_headers_to_response()
{
// Given
var module = new ConfigurableNancyModule(with =>
{
with.Get("/headers", (x, m) =>
{
var context =
new NancyContext { NegotiationContext = new NegotiationContext() };
var negotiator =
new Negotiator(context);
negotiator.WithContentType("text/xml");
return negotiator;
});
});
var brower = new Browser(with =>
{
with.ResponseProcessor<TestProcessor>();
with.Module(module);
});
// When
var response = brower.Get("/headers");
// Then
Assert.Equal("text/xml", response.Context.Response.ContentType);
}
/// <summary>
/// Invokes the specified <paramref name="route"/> with the provided <paramref name="parameters"/>.
/// </summary>
/// <param name="route">The route that should be invoked.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <param name="parameters">The parameters that the route should be invoked with.</param>
/// <param name="context">The context of the route that is being invoked.</param>
/// <returns>A <see cref="Response"/> instance that represents the result of the invoked route.</returns>
public async Task<Response> Invoke(Route route, CancellationToken cancellationToken, DynamicDictionary parameters, NancyContext context)
{
object result;
try
{
result = await route.Invoke(parameters, cancellationToken).ConfigureAwait(false);
}
catch(RouteExecutionEarlyExitException earlyExitException)
{
context.WriteTraceLog(
sb => sb.AppendFormat(
"[DefaultRouteInvoker] Caught RouteExecutionEarlyExitException - reason {0}",
earlyExitException.Reason));
return earlyExitException.Response;
}
if (!(result is ValueType) && result == null)
{
context.WriteTraceLog(
sb => sb.AppendLine("[DefaultRouteInvoker] Invocation of route returned null"));
result = new Response();
}
return this.negotiator.NegotiateResponse(result, context);
}
private static ResolveResult BuildMethodNotAllowedResult(NancyContext context, IEnumerable<string> allowedMethods)
{
var route =
new MethodNotAllowedRoute(context.Request.Path, context.Request.Method, allowedMethods);
return new ResolveResult(route, new DynamicDictionary(), null, null, null);
}
/// <summary>
/// Creates a response that sets the authentication cookie and redirects
/// the user back to where they came from.
/// </summary>
/// <param name="context">Current context</param>
/// <param name="userIdentifier">User identifier guid</param>
/// <param name="cookieExpiry">Optional expiry date for the cookie (for 'Remember me')</param>
/// <param name="fallbackRedirectUrl">Url to redirect to if none in the querystring</param>
/// <returns>Nancy response with redirect.</returns>
public static Response UserLoggedInRedirectResponse(NancyContext context, Guid userIdentifier, DateTime? cookieExpiry = null, string fallbackRedirectUrl = null)
{
var redirectUrl = fallbackRedirectUrl;
if (string.IsNullOrEmpty(redirectUrl))
{
redirectUrl = context.Request.Url.BasePath;
}
if (string.IsNullOrEmpty(redirectUrl))
{
redirectUrl = "/";
}
string redirectQuerystringKey = GetRedirectQuerystringKey(currentConfiguration);
if (context.Request.Query[redirectQuerystringKey].HasValue)
{
var queryUrl = (string)context.Request.Query[redirectQuerystringKey];
if (context.IsLocalUrl(queryUrl))
{
redirectUrl = queryUrl;
}
}
var response = context.GetRedirect(redirectUrl);
var authenticationCookie = BuildCookie(userIdentifier, cookieExpiry, currentConfiguration);
response.AddCookie(authenticationCookie);
return response;
}
private static void SaveSession(NancyContext ctx, IKeyValueStore store)
{
if (ctx.Request == null || ctx.Request.Session == null || !ctx.Request.Session.HasChanged)
return;
string id;
if (ctx.Request.Cookies.ContainsKey(GetCookieName()))
{
id = ctx.Request.Cookies[GetCookieName()];
}
else
{
// TODO: Should we give a way to override how the id is generated?
// TODO: Should we encrypt / hash the id so people can not just try out other values?
id = Guid.NewGuid().ToString();
ctx.Response.AddCookie(GetCookieName(), id);
}
IDictionary<string, object> items = new Dictionary<string, object>();
foreach (var item in ctx.Request.Session)
{
items.Add(item.Key, item.Value);
}
store.Save(id, items);
}
/// <summary>
/// Adds the current response to the cache if required
/// Only stores by Path and stores the response in a dictionary.
/// Do not use this as an actual cache :-)
/// </summary>
/// <param name="context">Current context</param>
public void SetCache(NancyContext context)
{
if (context.Response.StatusCode != HttpStatusCode.OK)
{
return;
}
object cacheSecondsObject;
if (!context.Items.TryGetValue(ContextExtensions.OUTPUT_CACHE_TIME_KEY, out cacheSecondsObject))
{
return;
}
int cacheSeconds;
if (!int.TryParse(cacheSecondsObject.ToString(), out cacheSeconds))
{
return;
}
var cachedResponse = new CachedResponse(context.Response);
this.cachedResponses[context.Request.Path] = new Tuple<DateTime, Response, int>(DateTime.Now, cachedResponse, cacheSeconds);
context.Response = cachedResponse;
}
/// <summary>
/// Determines whether the processor can handle a given content type and model.
/// </summary>
/// <param name="requestedMediaRange">Content type requested by the client.</param>
/// <param name="model">The model for the given media range.</param>
/// <param name="context">The nancy context.</param>
/// <returns>
/// A <see cref="T:Nancy.Responses.Negotiation.ProcessorMatch" /> result that determines the priority of the processor.
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
public ProcessorMatch CanProcess(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
// Tells Nancy that this processor can handle accept header values that end with "yaml"
return(requestedMediaRange.Subtype.ToString().EndsWith("yaml")
? new ProcessorMatch {
ModelResult = MatchResult.DontCare, RequestedContentTypeResult = MatchResult.NonExactMatch
}
: ProcessorMatch.None);
}
public CultureInfo DetermineCurrentCulture(NancyContext context)
{
return(System.Threading.Thread.CurrentThread.CurrentCulture);
}
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
//container.Register<IRequestUrl>((cContainer, overloads) => new RequestUrl(context));
container.Register <NancyContext>((cContainer, overloads) => context);
container.Register <IRequestUrl, RequestUrl>();
container.Register <IGreeter, Greeter>();
container.Register <IGreetingMessageService, GreetingMessageService>();
}
public static void DisableOutputCache(this NancyContext context)
{
context.Items.Remove(OUTPUT_CACHE_TIME_KEY);
}
/// <summary>
/// Enable output caching for this route
/// </summary>
/// <param name="context">Current context</param>
/// <param name="seconds">Seconds to cache for</param>
public static void EnableOutputCache(this NancyContext context, int seconds)
{
context.Items[OUTPUT_CACHE_TIME_KEY] = seconds;
}
private Response SetViewBagWithSettings(NancyContext arg)
{
ViewBag.Settings = AppConfiguration.Current;
ViewBag.Pages = BlogPosts.Where(p => p.Status == PostStatus.Publish && p.Type == PostType.Page).ToList();
return(null);
}
public IUserIdentity GetUserFromIdentifier(Guid identifier, NancyContext context)
{
throw new NotImplementedException();
}
/// <summary>
/// Initialise the request - can be used for adding pre/post hooks and
/// any other per-request initialisation tasks that aren't specifically container setup
/// related
/// </summary>
/// <param name="container">Container</param>
/// <param name="pipelines">Current pipelines</param>
/// <param name="context">Current context</param>
protected virtual void RequestStartup(TContainer container, IPipelines pipelines, NancyContext context)
{
}
/// <summary>
/// Get all NancyModule implementation instances
/// </summary>
/// <param name="context">The current context</param>
/// <returns>An <see cref="IEnumerable{T}"/> instance containing <see cref="INancyModule"/> instances.</returns>
public abstract IEnumerable <INancyModule> GetAllModules(NancyContext context);
// The bootstrapper enables you to reconfigure the composition of the framework,
// by overriding the various methods and properties.
// For more information https://github.com/NancyFx/Nancy/wiki/Bootstrapper
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
container.Register <ITeamRepository, TeamRepository>();
container.Register <IMatchRepository, MatchRepository>();
}
public bool HandlesStatusCode(HttpStatusCode statusCode, NancyContext context)
{
return(true);
}
/// <summary> /// Retrieves a specific <see cref="INancyModule"/> implementation - should be per-request lifetime /// </summary> /// <param name="moduleType">Module type</param> /// <param name="context">The current context</param> /// <returns>The <see cref="INancyModule"/> instance</returns> public abstract INancyModule GetModule(Type moduleType, NancyContext context);
public bool HandlesStatusCode(HttpStatusCode statusCode, NancyContext context)
{
return(statusCode == HttpStatusCode.NotFound);
}
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
//I have nothing to add
}
/// <summary>
/// Determines whether the the processor can handle a given content type and model.
/// </summary>
/// <param name="requestedMediaRange">Content type requested by the client.</param>
/// <param name="model">The model for the given media range.</param>
/// <param name="context">The nancy context.</param>
/// <returns>A <see cref="ProcessorMatch"/> result that determines the priority of the processor.</returns>
public ProcessorMatch CanProcess(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
if (IsWildcardProtobufContentType(requestedMediaRange) || requestedMediaRange.Matches(Constants.ProtoBufContentType))
{
return(new ProcessorMatch
{
ModelResult = MatchResult.DontCare,
RequestedContentTypeResult = MatchResult.ExactMatch
});
}
return(new ProcessorMatch
{
ModelResult = MatchResult.DontCare,
RequestedContentTypeResult = MatchResult.NoMatch
});
}
/// <summary>
/// Log context and exception
/// </summary>
/// <param name="context"></param>
/// <param name="exception"></param>
public void LogData(NancyContext context, Exception exception)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var statusCode = context.GetStatusCode(exception);
string exceptionMessage = null;
string exceptionStackTrace = null;
if (exception != null)
{
exceptionMessage = HandleFieldSize(exception.Message, ExceptionMaxLenghtExtension.ErrorMessageLenght);
exceptionStackTrace = HandleFieldSize(exception.StackTrace, ExceptionMaxLenghtExtension.ErrorExceptionLenght);
}
object controller = "Unknow";
object action = "Unknow";
if (context.Items != null)
{
context.Items.TryGetValue("Controller", out controller);
context.Items.TryGetValue("Action", out action);
}
LogContext.PushProperty("RequestBody", context.GetRequestBody(this.NancySerilogConfiguration.Blacklist));
LogContext.PushProperty("Method", context.Request.Method);
LogContext.PushProperty("Path", context.Request.Path);
LogContext.PushProperty("Host", context.Request.Url.HostName);
LogContext.PushProperty("Port", context.Request.Url.Port);
LogContext.PushProperty("Url", context.Request.Url);
LogContext.PushProperty("QueryString", context.Request.Url.Query);
LogContext.PushProperty("Query", context.GetQueryString());
LogContext.PushProperty("RequestHeaders", context.GetRequestHeaders());
LogContext.PushProperty("Ip", context.GetIp());
LogContext.PushProperty("IsSuccessful", statusCode < 400);
LogContext.PushProperty("StatusCode", statusCode);
LogContext.PushProperty("StatusDescription", ((HttpStatusCode)statusCode).ToString());
LogContext.PushProperty("StatusCodeFamily", context.GetStatusCodeFamily(exception));
LogContext.PushProperty("ProtocolVersion", context.Request.ProtocolVersion);
LogContext.PushProperty("ErrorException", exceptionStackTrace);
LogContext.PushProperty("ErrorMessage", exceptionMessage);
LogContext.PushProperty("ResponseContent", context.GetResponseContent());
LogContext.PushProperty("ContentType", context.Response.ContentType);
LogContext.PushProperty("ContentLength", context.GetResponseLength());
LogContext.PushProperty("ResponseHeaders", context.GetResponseHeaders());
LogContext.PushProperty("ElapsedMilliseconds", context.GetExecutionTime());
LogContext.PushProperty("Version", this.NancySerilogConfiguration.Version);
LogContext.PushProperty("RequestKey", context.GetRequestKey());
LogContext.PushProperty("Controller", controller?.ToString());
LogContext.PushProperty("Operation", action?.ToString());
LogContext.PushProperty("Environment", Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));
if (context.Items.ContainsKey("NancySerilogAdditionalInfo"))
{
var additionalInfo = (AdditionalInfo)context.Items["NancySerilogAdditionalInfo"];
if (additionalInfo?.Data != null)
{
foreach (var item in additionalInfo.Data)
{
LogContext.PushProperty(item.Key, item.Value);
}
}
}
if (exception != null || statusCode >= 500)
{
var errorTitle = this.NancySerilogConfiguration.ErrorTitle ?? DefaultErrorTitle;
this.NancySerilogConfiguration.Logger.Error(errorTitle);
}
else
{
var informationTitle = this.NancySerilogConfiguration.InformationTitle ?? DefaultInformationTitle;
this.NancySerilogConfiguration.Logger.Information(informationTitle);
}
}
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
// Here we register our user mapper as a per-request singleton.
// As this is now per-request we could inject a request scoped
// database "context" or other request scoped services.
container.Register <IUserMapper, UserDatabase>();
}
/// <summary>
/// Process the response.
/// </summary>
/// <param name="requestedMediaRange">Content type requested by the client.</param>
/// <param name="model">The model for the given media range.</param>
/// <param name="context">The nancy context.</param>
/// <returns>A <see cref="Response"/> instance.</returns>
public Response Process(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
return(new ProtoBufResponse(model));
}
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
var error = new { StatusCode = statusCode, Message = "Not Found" };
context.Response = _negotiator.NegotiateResponse(error, context);
}
protected override void RequestStartup(TinyIoCContainer requestContainer, IPipelines pipelines, NancyContext context)
{
// At request startup we modify the request pipelines to
// include forms authentication - passing in our now request
// scoped user name mapper.
//
// The pipelines passed in here are specific to this request,
// so we can add/remove/update items in them as we please.
var formsAuthConfiguration =
new FormsAuthenticationConfiguration()
{
RedirectUrl = "~/login",
UserMapper = requestContainer.Resolve <IUserMapper>(),
};
FormsAuthentication.Enable(pipelines, formsAuthConfiguration);
}
private static Func <ResponseFactoryCacheKey, Func <NancyContext, Response> > BuildContentDelegate(NancyContext context, string applicationRootPath, string requestedPath, string contentPath, string[] allowedExtensions)
{
return(pathAndRootPair =>
{
context.Trace.TraceLog.WriteLog(x => x.AppendLine(string.Concat("[StaticContentConventionBuilder] Attempting to resolve static content '", pathAndRootPair, "'")));
var extension =
Path.GetExtension(pathAndRootPair.Path);
if (!string.IsNullOrEmpty(extension))
{
extension = extension.Substring(1);
}
if (allowedExtensions.Length != 0 && !allowedExtensions.Any(e => string.Equals(e.TrimStart(new [] { '.' }), extension, StringComparison.OrdinalIgnoreCase)))
{
context.Trace.TraceLog.WriteLog(x => x.AppendLine(string.Concat("[StaticContentConventionBuilder] The requested extension '", extension, "' does not match any of the valid extensions for the convention '", string.Join(",", allowedExtensions), "'")));
return ctx => null;
}
var transformedRequestPath =
GetSafeRequestPath(pathAndRootPair.Path, requestedPath, contentPath);
transformedRequestPath =
GetEncodedPath(transformedRequestPath);
var fileName =
Path.GetFullPath(Path.Combine(applicationRootPath, transformedRequestPath));
var contentRootPath =
Path.GetFullPath(Path.Combine(applicationRootPath, GetEncodedPath(contentPath)));
if (!IsWithinContentFolder(contentRootPath, fileName))
{
context.Trace.TraceLog.WriteLog(x => x.AppendLine(string.Concat("[StaticContentConventionBuilder] The request '", fileName, "' is trying to access a path outside the content folder '", contentPath, "'")));
return ctx => null;
}
if (!File.Exists(fileName))
{
context.Trace.TraceLog.WriteLog(x => x.AppendLine(string.Concat("[StaticContentConventionBuilder] The requested file '", fileName, "' does not exist")));
return ctx => null;
}
context.Trace.TraceLog.WriteLog(x => x.AppendLine(string.Concat("[StaticContentConventionBuilder] Returning file '", fileName, "'")));
return ctx => new GenericFileResponse(fileName, ctx);
});
}
protected override void RequestStartup(Nancy.TinyIoc.TinyIoCContainer container, Nancy.Bootstrapper.IPipelines pipelines, NancyContext context)
{
base.RequestStartup(container, pipelines, context);
}
protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context)
{
pipelines.OnError.AddItemToEndOfPipeline(
(nancyContext, exception) =>
new JsonResponse(
new
{
error = exception.Message
},
new DefaultJsonSerializer()));
base.RequestStartup(container, pipelines, context);
}
protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context)
{
pipelines.BeforeRequest += (x) =>
{
return(null);
};
pipelines.AfterRequest += (x) =>
{
if (x.Request.Url.Path.ToLower() == "/api" || x.Request.Url.Path.ToLower() == "/doc")
{
x.Response.WithContentType("application/pdf");
}
bool isView = false; //判断返回数据是否为 view text/html 否则 转换 application/json
if (x.Response.Contents.Target.ToString() == "Nancy.Responses.MaterialisingResponse")
{
var r = (Nancy.Responses.MaterialisingResponse)x.Response.Contents.Target;
if (r.ContentType == "text/html")
{
isView = true;
}
}
if (!isView)
{
x.Response.WithContentType("application/json;charset=UTF-8");
}
x.Response.WithHeader("Access-Control-Allow-Origin", "*");
x.Response.WithHeader("Access-Control-Allow-Methods", "GET");
};
pipelines.OnError += Error;
base.RequestStartup(container, pipelines, context);
}
public ProcessorMatch CanProcess(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
return(new ProcessorMatch
{
RequestedContentTypeResult = MatchResult.DontCare,
ModelResult = MatchResult.DontCare
});
}
/// <summary> /// Retrieves a specific <see cref="NancyModule"/> implementation based on its key /// </summary> /// <param name="moduleKey">Module key</param> /// <param name="context">The current context</param> /// <returns>The <see cref="NancyModule"/> instance that was retrived by the <paramref name="moduleKey"/> parameter.</returns> public abstract NancyModule GetModuleByKey(string moduleKey, NancyContext context);
/// <summary>
/// 自定义请求启动函数
/// </summary>
/// <param name="container"></param>
/// <param name="pipelines"></param>
/// <param name="context"></param>
protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context)
{
//CORS Enable
pipelines.AfterRequest.AddItemToEndOfPipeline((ctx) =>
{
var originlist = ctx.Request.Headers["Origin"];
foreach (var origin in originlist)
{
ctx.Response.WithHeader("Access-Control-Allow-Origin", origin);
}
ctx.Response.WithHeader("Access-Control-Allow-Methods", "POST,GET")
.WithHeader("Access-Control-Allow-Credentials", "true")
.WithHeader("Access-Control-Allow-Headers", "Accept, Origin, Content-type");
});
}
public Response Process(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
return((string)model);
}
public Response Process(MediaRange mediaRange, dynamic model, NancyContext context) => new JsonResponse((object)model, serializer, environment);
public Response Process(MediaRange requestedMediaRange, dynamic model, NancyContext context)
{
return(string.Format(ResponseTemplate, requestedMediaRange, model == null ? "None" : model.GetType()));
}
