public JsonFormatterExtensionsFixtures()
{
this.formatter = A.Fake<IResponseFormatter>();
this.model = new Person { FirstName = "Andy", LastName = "Pike" };
DefaultSerializersStartup.JsonSerializer = new DefaultJsonSerializer();
this.response = this.formatter.AsJson(model);
}
public JsonFormatterExtensionsFixtures()
{
this.formatter = A.Fake<IResponseFormatter>();
A.CallTo(() => this.formatter.Serializers).Returns(new[] { new DefaultJsonSerializer() });
this.model = new Person { FirstName = "Andy", LastName = "Pike" };
this.response = this.formatter.AsJson(model);
}
public static Response CreateResponse(this Exception e, ResponseFormat format, IResponseFormatter formatter)
{
// dumb ugliness b/c MSFT's xml serializer can't handle anonymous objects
var exception = new FormattedException
{
name = e.GetType().Name,
message = e.Message,
callStack = e.StackTrace
};
Response r;
switch (format)
{
case ResponseFormat.Json:
r = formatter.AsJson(exception, HttpStatusCode.InternalServerError);
break;
case ResponseFormat.Xml:
r = formatter.AsXml(exception);
break;
default:
r = null;
break;
}
if (r != null)
{
r.StatusCode = HttpStatusCode.InternalServerError;
}
return r;
}
private static Response CreateResponse(IResponseFormatter formatter, string id)
{
var url = formatter.Context.Request.Url.ToString();
var response = new Response {StatusCode = HttpStatusCode.Created, Headers = {{"Location", url + "/" + id}}};
return response;
}
public void Setup()
{
_testCommand = A.Fake<ICommand>();
_publisher = A.Fake<IPublisher>();
_compositeApp = A.Fake<ICompositeApp>();
_registry = A.Fake<ICommandRegistry>();
_formatter = A.Fake<IResponseFormatter>();
_publicationRecord = A.Fake<ICommandPublicationRecord>();
_jsonSerializer = new DefaultJsonSerializer();
_xmlSerializer = new DefaultXmlSerializer();
A.CallTo(() => _testCommand.Created).Returns(DateTime.MaxValue);
A.CallTo(() => _testCommand.CreatedBy).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _testCommand.Identifier).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _formatter.Serializers).Returns(new List<ISerializer> { _jsonSerializer, _xmlSerializer });
A.CallTo(() => _publicationRecord.Dispatched).Returns(true);
A.CallTo(() => _publicationRecord.Error).Returns(false);
A.CallTo(() => _publicationRecord.Completed).Returns(true);
A.CallTo(() => _publicationRecord.Created).Returns(DateTime.MinValue);
A.CallTo(() => _publicationRecord.MessageLocation).Returns(new Uri("http://localhost/fake/message"));
A.CallTo(() => _publicationRecord.MessageType).Returns(typeof(IPublicationRecord));
A.CallTo(() => _publicationRecord.CreatedBy).Returns(Guid.Empty);
A.CallTo(() => _compositeApp.GetCommandForInputModel(A.Dummy<IInputModel>())).Returns(_testCommand);
A.CallTo(() => _publisher.PublishMessage(A.Fake<ICommand>())).Returns(_publicationId);
A.CallTo(() => _registry.GetPublicationRecord(_publicationId)).Returns(_publicationRecord);
_euclidApi = new ApiModule(_compositeApp, _registry, _publisher);
}
public RavenSessionModule(IViewFactory viewFactory, IResponseFormatter responseFormatter,
IModelBinderLocator modelBinderLocator,
IRavenSessionManager ravenSessionProvider)
{
this.viewFactory = viewFactory;
this.responseFormatter = responseFormatter;
this.modelBinderLocator = modelBinderLocator;
_ravenSessionProvider = ravenSessionProvider;
}
public static Response GetThumbnailImage(Guid id, int page, IResponseFormatter response)
{
var bitmap = Image.FromStream(new MemoryStream(GetPageImageBytes(id, page)), false, false);
double ratio = 200D / (double)bitmap.Height;
int width = (int)(bitmap.Width * ratio);
var callback = new Image.GetThumbnailImageAbort(() => true);
var thumbnail = bitmap.GetThumbnailImage(width, 200, callback, IntPtr.Zero);
MemoryStream stream = GetBytesFromImage(thumbnail);
return response.FromStream(stream, MimeTypes.GetMimeType(".jpg"));
}
public Response Generate(IResponseFormatter response, ErrorCode code)
{
var error = Errors[code];
return response.AsJson(new
{
ErrorCode = (int)code,
ErrorMessage = error.Message
})
.WithStatusCode(error.StatusCode);
}
public EventStreamWriterResponse(IResponseFormatter formatter, string id, dynamic body)
{
_serializer = formatter.Serializers.FirstOrDefault(s => s.CanSerialize("application/json"));
ContentType = "text/event-stream";
Contents = s =>
{
_responseStream = s;
Write(body);
};
}
public JsonFormatterExtensionsFixtures()
{
var environment = GetTestingEnvironment();
var serializerFactory =
new DefaultSerializerFactory(new ISerializer[] { new DefaultJsonSerializer(environment) });
this.formatter = A.Fake<IResponseFormatter>();
A.CallTo(() => this.formatter.Environment).Returns(environment);
A.CallTo(() => this.formatter.SerializerFactory).Returns(serializerFactory);
this.model = new Person { FirstName = "Andy", LastName = "Pike" };
this.response = this.formatter.AsJson(model);
}
public static Response WriteTo(this IMetadataFormatter formatter, IResponseFormatter response)
{
var format = response.Context.GetResponseFormat();
if (format == ResponseFormat.Html)
{
return HttpStatusCode.NoContent;
}
var representation = format == ResponseFormat.Json ? "json" : "xml";
var encodedString = formatter.GetRepresentation(representation);
var stream = new MemoryStream(Encoding.UTF8.GetBytes(encodedString));
return response.FromStream(stream, Euclid.Common.Extensions.MimeTypes.GetByExtension(representation));
}
public Response MissingParameters(IResponseFormatter response)
{
return Generate(response, ErrorCode.MissingParameters);
}
public static Response GetIcon(string key, IResponseFormatter response)
{
var image = ComicBook.PublisherIcons.GetImage(key);
if (image == null)
{
return response.AsRedirect("/original/Views/spacer.png");
}
return response.FromStream(GetBytesFromImage(image), MimeTypes.GetMimeType(".jpg"));
}
private static Response OnRequestFallback(NancyContext context, Request request, IResponseFormatter formatter, ICollection<JsonSchemaMessage> violations)
{
return HttpStatusCode.BadRequest;
}
public static Response InvalidToken(this IResponseFormatter response)
{
return(response.AsJsonError($"Missing or invalid {Config.AuthHeaderName} header.", HttpStatusCode.Unauthorized));
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultNancyModuleBuilder"/> class.
/// </summary>
/// <param name="viewFactory">The <see cref="IViewFactory"/> instance that should be assigned to the module.</param>
/// <param name="responseFormatter">An <see cref="DefaultResponseFormatter"/> instance that should be assigned to the module.</param>
/// <param name="modelBinderLocator">A <see cref="IModelBinderLocator"/> instance that should be assigned to the module.</param>
public DefaultNancyModuleBuilder(IViewFactory viewFactory, IResponseFormatter responseFormatter, IModelBinderLocator modelBinderLocator)
{
this.viewFactory = viewFactory;
this.responseFormatter = responseFormatter;
this.modelBinderLocator = modelBinderLocator;
}
public Response OnBrokerResponse(NancyContext context, Request request, Response response, IResponseFormatter formatter, ICollection<JsonSchemaMessage> violations)
{
return HttpStatusCode.InternalServerError;
}
public static Response AsXml <TModel>(this IResponseFormatter formatter, TModel model)
{
var serializer = xmlSerializer ?? (xmlSerializer = formatter.Serializers.FirstOrDefault(s => s.CanSerialize("application/xml")));
return(new XmlResponse <TModel>(model, "application/xml", serializer));
}
// Commented out to move the dependency on IResponseFormatter FROM the constructor TO the EndPoint method - so a new service object will be received for every request
//private IResponseFormatter formatter;
//public WeatherEndpoint(IResponseFormatter responseFormatter)
//{
// formatter = responseFormatter;
//}
public async Task Endpoint(HttpContext httpContext, IResponseFormatter formatter)
{
Console.WriteLine(formatter.GetType().CustomAttributes.ToString());
await formatter.Format(httpContext, "WeatherEndpoint class no longer static. \nDependency on IResponseFormatter service through WeatherEndpoint.Endpoint() method \n(not via constructor injection): it's cloudy in Milan");
}
public static Response asJsonNet <T>(this IResponseFormatter formatter, T instance)
{
var responseData = JsonConvert.SerializeObject(instance);
return(formatter.AsText(responseData, "application/json"));
}
public static Response AsJs(this IResponseFormatter formatter, string applicationRelativeFilePath)
{
return(AsFile(formatter, applicationRelativeFilePath));
}
/// <summary>
/// Configures the bootstrapper to use the provided instance of <see cref="IResponseFormatter"/>.
/// </summary>
/// <param name="responseFormatter">The <see cref="IResponseFormatter"/> instance that should be used by the bootstrapper.</param>
/// <returns>An instance to the current <see cref="FakeNancyBootstrapperConfigurator"/>.</returns>
public FakeNancyBootstrapperConfigurator ResponseFormatter(IResponseFormatter responseFormatter)
{
this.bootstrapper.configuredInstances[typeof(IResponseFormatter)] = responseFormatter;
return(this);
}
public static Response AsStream(this IResponseFormatter formatter, Func <Stream> readStream, string contentType)
{
return(new StreamResponse(readStream, contentType));
}
public static Response ShopifyAuthenticationRequired(this IResponseFormatter response)
{
return(response.AsJsonError("Shopify OAuth integration required.", HttpStatusCode.PreconditionFailed));
}
public Response NoUserForEmail(IResponseFormatter response)
{
return Generate(response, ErrorCode.NoUserForEmail);
}
public static Response AutomapJson <T>(this IResponseFormatter response, object model)
{
return(response.AsJson(Mapper.Map <T>(model)));
}
public Response PermissionDenied(IResponseFormatter response)
{
return Generate(response, ErrorCode.PermissionDenied);
}
/// <summary>
/// AsError
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="response"></param>
/// <param name="data"></param>
/// <param name="message"></param>
/// <returns></returns>
public static Response AsErrorJson <T>(this IResponseFormatter response, T data, string message) where T : class
{
var serverResponse = ResponseProvider.Error(data, message);
return(response.AsJson(serverResponse));
}
public Response InvalidParameters(IResponseFormatter response)
{
return Generate(response, ErrorCode.InvalidParameters);
}
/// <summary>
/// AsSuccess
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="response"></param>
/// <param name="data"></param>
/// <returns></returns>
public static Response AsSuccessJson <T>(this IResponseFormatter response, T data) where T : class
{
var serverResponse = ResponseProvider.Success(data);
return(response.AsJson(serverResponse));
}
public static Response ThenRedirectTo(this IResponseFormatter response, string viewName)
{
return(response.AsRedirect(viewName));
}
public CsvFormatterExtensionsFixtures()
{
this.formatter = A.Fake<IResponseFormatter>();
this.model = new Person { FirstName = "Emmanuel", LastName = "Morales" };
this.response = this.formatter.AsCsv(model);
}
public static Response FromByteArray(this IResponseFormatter formatter, byte[] body, string contentType = null)
{
return(new ByteArrayResponse(body, contentType));
}
/// <summary>
/// Takes a Nancy response + error message and turns it into a JSON error message.
/// </summary>
public static Response AsJsonError(this IResponseFormatter response, string message, HttpStatusCode statusCode, object details = null)
{
return(response.AsJson(new { message = message, details }, statusCode));
}
public FormatterExtensionsFixture()
{
this.context = new NancyContext();
this.formatter = new DefaultResponseFormatter(A.Fake<IRootPathProvider>(), context, new DefaultSerializerFactory(null), A.Fake<INancyEnvironment>());
}
/// <summary>
/// Returns a redirect response to the agent.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="location">The location to redirect to.</param>
/// <param name="type">The redirect type. See <see cref="RedirectResponse.RedirectType"/>.</param>
public static Response AsRedirect(this IResponseFormatter formatter, string location, RedirectResponse.RedirectType type = RedirectResponse.RedirectType.SeeOther)
{
return(new RedirectResponse(formatter.Context.ToFullPath(location), type));
}
//private IResponseFormatter formatter;
//public WeatherEndpoint(IResponseFormatter responseFormatter)
//{
// formatter = responseFormatter;
//}
//public async Task Endpoint(HttpContext context)
public async Task Endpoint(HttpContext context, IResponseFormatter formatter)
{
await formatter.Format(context, "Endpoint Class: It is cloudy in Milan");
}
/// <summary>
/// Serializes the <paramref name="model"/> to XML and returns it to the
/// agent, optionally using the <paramref name="statusCode"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <param name="formatter">The formatter.</param>
/// <param name="model">The model to serialize.</param>
/// <param name="statusCode">The HTTP status code. Defaults to <see cref="HttpStatusCode.OK"/>.</param>
public static Response AsXml <TModel>(this IResponseFormatter formatter, TModel model, HttpStatusCode statusCode = HttpStatusCode.OK)
{
var serializer = xmlSerializer ?? (xmlSerializer = formatter.SerializerFactory.GetSerializer("application/xml"));
return(new XmlResponse <TModel>(model, serializer, formatter.Environment));
}
public static Response GetPageImage(Guid id, int page, int width, int height, IResponseFormatter response)
{
// Restrict access to the FreeImage library to one thread at a time.
lock(lockThis)
{
int max_width = 0;
int max_height = 0;
bool thumbnail = !(width == -1 && height == -1);
bool processed = false;
string filename = string.Format("{0}-p{1}-w{2}-h{3}.jpg", id, page, width, height);
if (thumbnail)
{
MemoryStream cachestream = ImageCache.Instance.LoadFromCache(filename, true);
// Cached thumbnails are assumed to be in the correct format and adhere to the size/format restrictions of the ipad.
if (cachestream != null)
return response.FromStream(cachestream, MimeTypes.GetMimeType(".jpg"));
}
else
{
// Check if a processed (rescaled and/or progressive) image is cached.
string processed_filename = string.Format("{0}-p{1}-processed.jpg", id, page);
MemoryStream cachestream = ImageCache.Instance.LoadFromCache(processed_filename, false);
if (cachestream != null)
return response.FromStream(cachestream, MimeTypes.GetMimeType(".jpg"));
}
MemoryStream stream = null;
// Check if original image is in the cache.
string org_filename = string.Format("{0}-p{1}.jpg", id, page);
stream = ImageCache.Instance.LoadFromCache(org_filename, false);
if (stream == null)
{
// Image is not in the cache, get it via ComicRack.
var bytes = GetPageImageBytes(id, page);
if (bytes == null)
{
return HttpStatusCode.NotFound;
}
stream = new MemoryStream(bytes);
// Always save the original page to the cache
ImageCache.Instance.SaveToCache(org_filename, stream, false);
}
stream.Seek(0, SeekOrigin.Begin);
#if USE_GDI
Bitmap bitmap = new Bitmap(stream, false);
int bitmap_width = (int)bitmap.Width;
int bitmap_height = (int)bitmap.Height;
#elif USE_DIB
FIBITMAP dib = FreeImage.LoadFromStream(stream);
if (dib == null)
{
Console.WriteLine("Loading bitmap failed. Aborting.");
// Check whether there was an error message.
return HttpStatusCode.InternalServerError;
}
int bitmap_width = (int)FreeImage.GetWidth(dib);
int bitmap_height = (int)FreeImage.GetHeight(dib);
#elif USE_FIB
FreeImageBitmap fib = FreeImageBitmap.FromStream(stream, false);
if (fib == null)
{
Console.WriteLine("Loading bitmap failed. Aborting.");
// Check whether there was an error message.
return HttpStatusCode.InternalServerError;
}
int bitmap_width = (int)fib.Width;
int bitmap_height = (int)fib.Height;
#endif
if (ImageCache.Instance.use_max_dimension)
{
int mw, mh;
if (bitmap_width >= bitmap_height)
{
mw = ImageCache.Instance.max_dimension_long;
mh = ImageCache.Instance.max_dimension_short;
}
else
{
mw = ImageCache.Instance.max_dimension_short;
mh = ImageCache.Instance.max_dimension_long;
}
if (bitmap_width > mw || bitmap_height > mh)
{
double scaleW = (double)mw / (double)bitmap_width;
double scaleH = (double)mh / (double)bitmap_height;
double scale = Math.Min(scaleW, scaleH);
max_width = (int)Math.Floor(scale * bitmap_width);
max_height = (int)Math.Floor(scale * bitmap_height);
}
else
{
max_width = bitmap_width;
max_height = bitmap_height;
}
}
else
// Check if the image dimensions exceeds the maximum image dimensions
if ((bitmap_width * bitmap_height) > ImageCache.Instance.maximum_imagesize)
{
max_width = (int)Math.Floor(Math.Sqrt((double)bitmap_width / (double)bitmap_height * (double)ImageCache.Instance.maximum_imagesize));
max_height = (int)Math.Floor((double)max_width * (double)bitmap_height / (double)bitmap_width);
}
else
{
max_width = bitmap_width;
max_height = bitmap_height;
}
// Calculate the dimensions of the returned image.
int result_width = width;
int result_height = height;
if (result_width == -1 && result_height == -1)
{
result_width = max_width;
result_height = max_height;
}
else
{
if (result_width == -1)
{
result_height = Math.Min(max_height, result_height);
double ratio = (double)result_height / (double)max_height;
result_width = (int)Math.Floor(((double)max_width * ratio));
}
else
if (result_height == -1)
{
result_width = Math.Min(max_width, result_width);
double ratio = (double)result_width / (double)max_width;
result_height = (int)Math.Floor(((double)max_height * ratio));
}
}
// TODO: do this per requesting target device instead of using one global setting.
// Resize ?
if (result_width != bitmap_width || result_height != bitmap_height)
{
processed = true;
#if USE_DIB || USE_FIB
//FREE_IMAGE_FILTER resizer = FREE_IMAGE_FILTER.FILTER_BICUBIC;
FREE_IMAGE_FILTER resizer = FREE_IMAGE_FILTER.FILTER_LANCZOS3;
#if USE_FIB
fib.Rescale(result_width, result_height, resizer);
#else
FIBITMAP newdib = FreeImage.Rescale(dib, result_width, result_height, resizer);
if (!newdib.IsNull)
{
FreeImage.Unload(dib);
dib.SetNull();
dib = newdib;
}
#endif
#elif USE_GDI
Bitmap resizedBitmap = Resize(bitmap, result_width, result_height);
bitmap.Dispose();
bitmap = resizedBitmap;
resizedBitmap = null;
#endif
}
// Check if the image must be converted to progressive jpeg
if (ImageCache.Instance.use_progressive_jpeg && (result_width * result_height) >= ImageCache.Instance.progressive_jpeg_size_threshold)
{
processed = true;
// Convert image to progressive jpeg
// FreeImage source code reveals that lower 7 bits of the FREE_IMAGE_SAVE_FLAGS enum are used for low-level quality control.
FREE_IMAGE_SAVE_FLAGS quality = (FREE_IMAGE_SAVE_FLAGS)ImageCache.Instance.progressive_jpeg_quality;
FREE_IMAGE_SAVE_FLAGS flags = FREE_IMAGE_SAVE_FLAGS.JPEG_SUBSAMPLING_444 | FREE_IMAGE_SAVE_FLAGS.JPEG_PROGRESSIVE | quality;
#if USE_DIB || USE_FIB
stream.Dispose();
stream = new MemoryStream();
#if USE_FIB
fib.Save(stream, FREE_IMAGE_FORMAT.FIF_JPEG, flags);
fib.Dispose();
#else
FreeImage.SaveToStream(dib, stream, FREE_IMAGE_FORMAT.FIF_JPEG, flags);
FreeImage.Unload(dib);
dib.SetNull();
#endif
#else
FIBITMAP dib = FreeImage.CreateFromBitmap(bitmap);
bitmap.Dispose();
bitmap = null;
stream.Dispose();
stream = new MemoryStream();
FreeImage.SaveToStream(dib, stream, FREE_IMAGE_FORMAT.FIF_JPEG, flags);
FreeImage.Unload(dib);
dib.SetNull();
#endif
}
else
if (processed)
{
// image was rescaled, make new stream with rescaled bitmap
#if USE_DIB || USE_FIB
FREE_IMAGE_SAVE_FLAGS flags = FREE_IMAGE_SAVE_FLAGS.JPEG_SUBSAMPLING_444 | FREE_IMAGE_SAVE_FLAGS.JPEG_OPTIMIZE | FREE_IMAGE_SAVE_FLAGS.JPEG_QUALITYNORMAL;
stream.Dispose();
stream = new MemoryStream();
#if USE_FIB
fib.Save(stream, FREE_IMAGE_FORMAT.FIF_JPEG, flags);
fib.Dispose();
#else
FreeImage.SaveToStream(dib, stream, FREE_IMAGE_FORMAT.FIF_JPEG, flags);
FreeImage.Unload(dib);
dib.SetNull();
#endif
#else
stream = GetBytesFromImage(bitmap);
#endif
// For now, images that were resized because they exceeded the maximum dimensions are not saved to the cache.
}
#if USE_DIB
FreeImage.Unload(dib);
dib.SetNull();
#elif USE_FIB
fib.Dispose();
#elif USE_GDI
if (bitmap != null)
{
bitmap.Dispose();
bitmap = null;
}
#endif
// Always save thumbnails to the cache
if (thumbnail)
{
ImageCache.Instance.SaveToCache(filename, stream, true);
}
else
if (processed)
{
// Store rescaled and/or progressive jpegs in the cache for now.
string processed_filename = string.Format("{0}-p{1}-processed.jpg", id, page);
ImageCache.Instance.SaveToCache(processed_filename, stream, false);
}
stream.Seek(0, SeekOrigin.Begin);
return response.FromStream(stream, MimeTypes.GetMimeType(".jpg"));
}
}
/// <summary>
/// Writes the data from the given <paramref name="stream"/> to the
/// agent, using <paramref name="contentType"/> for the <c>Content-Type</c> header.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="stream">The stream to copy from.</param>
/// <param name="contentType">Value for the <c>Content-Type</c> header.</param>
public static Response FromStream(this IResponseFormatter formatter, Stream stream, string contentType)
{
return(new StreamResponse(() => stream, contentType));
}
public TextFormatterFixture()
{
this.formatter = A.Fake<IResponseFormatter>();
this.response = this.formatter.AsText("sample text");
}
/// <summary>
/// Invokes the given <paramref name="streamDelegate"/> to write the stream data to the
/// agent, using <paramref name="contentType"/> for the <c>Content-Type</c> header.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="streamDelegate">A delegate returning a stream to copy from.</param>
/// <param name="contentType">Value for the <c>Content-Type</c> header.</param>
public static Response FromStream(this IResponseFormatter formatter, Func <Stream> streamDelegate, string contentType)
{
return(new StreamResponse(streamDelegate, contentType));
}
public JsonFormatterExtensionsFixtures()
{
this.formatter = A.Fake<IResponseFormatter>();
this.model = new Person { FirstName = "Andy", LastName = "Pike" };
this.response = this.formatter.AsJson(model);
}
/// <summary>
/// Sends the file at <paramref name="applicationRelativeFilePath"/> to the
/// agent, using the file extension and <see cref="MimeTypes.GetMimeType"/>
/// to determine the <c>Content-Type</c> header.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="applicationRelativeFilePath">The application relative file path.</param>
public static Response AsFile(this IResponseFormatter formatter, string applicationRelativeFilePath)
{
return(new GenericFileResponse(applicationRelativeFilePath));
}
public Response NoUserForCredentials(IResponseFormatter response)
{
return Generate(response, ErrorCode.NoUserForCredentials);
}
/// <summary>
/// Returns the <paramref name="contents"/> string to the
/// agent, using <c>text/plain</c> and <paramref name="encoding"/>
/// for the <c>Content-Type</c> header.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="contents">The contents of the response.</param>
/// <param name="encoding">The encoding to use.</param>
public static Response AsText(this IResponseFormatter formatter, string contents, Encoding encoding)
{
return(new TextResponse(contents, encoding: encoding));
}
public Response NoUserForThumbkey(IResponseFormatter response)
{
return Generate(response, ErrorCode.NoUserForThumbkey);
}
/// <summary>
/// Returns the <paramref name="contents"/> string as a <c>text/plain</c> response to the agent.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="contents">The contents of the response.</param>
public static Response AsText(this IResponseFormatter formatter, string contents)
{
return(new TextResponse(contents));
}
public Response UserNameTaken(IResponseFormatter response)
{
return Generate(response, ErrorCode.UserNameTaken);
}
public FormatterExtensionsFixture()
{
this.context = new NancyContext();
this.formatter = new DefaultResponseFormatter(A.Fake<IRootPathProvider>(), context, new ISerializer[] { });
}
public Response InvalidForgotPasswordToken(IResponseFormatter response)
{
return Generate(response, ErrorCode.InvalidForgotPasswordToken);
}
// private IResponseFormatter formatter;
// public WeatherEndpoint(IResponseFormatter responseFormatter)
// {
// formatter = responseFormatter;
// }
public async Task Endpoint(HttpContext context, IResponseFormatter formatter)
{
// await context.Response.WriteAsync("Endpoint Class: It is cloudy in Milan");
// change to DI - fetches the requisite service
await formatter.Format(context, "Endpoint Class: It is cloudy in Milan");
}
public Response OnBrokenRequest(NancyContext context, Request request, IResponseFormatter formatter, ICollection<JsonSchemaMessage> violations)
{
return formatter.AsJson(new { }, HttpStatusCode.BadRequest);
}
public CharacterController(IResponseFormatter responseFormatter, DndRepository repository, CharacterLoginHandler characterLoginHandler, IRequestHandler requestHandler) : base(responseFormatter, repository)
{
_requestHandler = requestHandler;
_characterLoginHandler = characterLoginHandler;
}
public SubscriptionRunner(ISubscriptionRepository subscriptionRepository, IQueryPerformer queryPerformer, IResponseFormatter responseFormatter)
{
_subscriptionRepository = subscriptionRepository;
_queryPerformer = queryPerformer;
_responseFormatter = responseFormatter;
}
/// <summary>
/// AsError
/// </summary>
/// <param name="response"></param>
/// <param name="message"></param>
/// <returns></returns>
public static Response AsErrorJson(this IResponseFormatter response, string message)
{
var serverResponse = ResponseProvider.Error(default(BaseResponseEmpty), message);
return(response.AsJson(serverResponse));
}
public SearchArtistByNameFunction(IMediator mediator, IResponseFormatter <SearchArtistByNameResponseDto> artistResponseFormatter)
{
_mediator = mediator;
_artistResponseFormatter = artistResponseFormatter;
}
public RequestHandler(ILogger <RequestHandler> logger, IResponseFormatter responseFormatter)
{
_logger = logger;
_responseFormatter = responseFormatter;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultNancyModuleBuilder"/> class.
/// </summary>
/// <param name="viewFactory">The <see cref="IViewFactory"/> instance that should be assigned to the module.</param>
/// <param name="responseFormatter">An <see cref="DefaultResponseFormatter"/> instance that should be assigned to the module.</param>
/// <param name="modelBinderLocator">A <see cref="IModelBinderLocator"/> instance that should be assigned to the module.</param>
public DefaultNancyModuleBuilder(IViewFactory viewFactory, IResponseFormatter responseFormatter, IModelBinderLocator modelBinderLocator)
{
this.viewFactory = viewFactory;
this.responseFormatter = responseFormatter;
this.modelBinderLocator = modelBinderLocator;
}
public static Response Created(this IResponseFormatter formatter, string location)
{
Response response = HttpStatusCode.Created;
return(response.WithHeader("Location", location));
}
