private void JsonOption(MvcNewtonsoftJsonOptions options)
{
options.SerializerSettings.Formatting = Formatting.Indented;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
private static string SerializeToJson(MvcNewtonsoftJsonOptions options, object value)
{
return(JsonConvert.SerializeObject(
value: value,
formatting: Formatting.None,
settings: options.SerializerSettings));
}
// NOTE: This method was created to make sure to create a different instance of contract resolver as by default
// MvcJsonOptions uses a static shared instance of resolver which when changed causes other tests to fail.
private MvcNewtonsoftJsonOptions CreateDefaultMvcJsonOptions()
{
var options = new MvcNewtonsoftJsonOptions();
options.SerializerSettings.ContractResolver = JsonSerializerSettingsProvider.CreateContractResolver();
return(options);
}
/// <summary>
/// Creates a new <see cref="NewtonsoftJsonResultExecutor"/>.
/// </summary>
/// <param name="writerFactory">The <see cref="IHttpResponseStreamWriterFactory"/>.</param>
/// <param name="logger">The <see cref="ILogger{NewtonsoftJsonResultExecutor}"/>.</param>
/// <param name="mvcOptions">Accessor to <see cref="MvcOptions"/>.</param>
/// <param name="jsonOptions">Accessor to <see cref="MvcNewtonsoftJsonOptions"/>.</param>
/// <param name="charPool">The <see cref="ArrayPool{Char}"/> for creating <see cref="T:char[]"/> buffers.</param>
public NewtonsoftJsonResultExecutor(
IHttpResponseStreamWriterFactory writerFactory,
ILogger <NewtonsoftJsonResultExecutor> logger,
IOptions <MvcOptions> mvcOptions,
IOptions <MvcNewtonsoftJsonOptions> jsonOptions,
ArrayPool <char> charPool)
{
if (writerFactory == null)
{
throw new ArgumentNullException(nameof(writerFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (jsonOptions == null)
{
throw new ArgumentNullException(nameof(jsonOptions));
}
if (charPool == null)
{
throw new ArgumentNullException(nameof(charPool));
}
_writerFactory = writerFactory;
_logger = logger;
_mvcOptions = mvcOptions?.Value ?? throw new ArgumentNullException(nameof(mvcOptions));
_jsonOptions = jsonOptions.Value;
_charPool = new JsonArrayPool <char>(charPool);
_asyncEnumerableReaderFactory = new AsyncEnumerableReader(_mvcOptions);
}
public NewtonsoftJsonMvcOptionsSetup(
ILoggerFactory loggerFactory,
IOptions <MvcNewtonsoftJsonOptions> jsonOptions,
ArrayPool <char> charPool,
ObjectPoolProvider objectPoolProvider)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (jsonOptions == null)
{
throw new ArgumentNullException(nameof(jsonOptions));
}
if (charPool == null)
{
throw new ArgumentNullException(nameof(charPool));
}
if (objectPoolProvider == null)
{
throw new ArgumentNullException(nameof(objectPoolProvider));
}
_loggerFactory = loggerFactory;
_jsonOptions = jsonOptions.Value;
_charPool = charPool;
_objectPoolProvider = objectPoolProvider;
}
public void Serialize_MaintainsSettingsAndEscapesHtml()
{
// Arrange
var options = new MvcNewtonsoftJsonOptions();
options.SerializerSettings.ContractResolver = new DefaultContractResolver
{
NamingStrategy = new DefaultNamingStrategy(),
};
var helper = new NewtonsoftJsonHelper(
Options.Create(options),
ArrayPool <char> .Shared);
var obj = new
{
FullHtml = "<b>John Doe</b>"
};
var expectedOutput = "{\"FullHtml\":\"\\u003cb\\u003eJohn Doe\\u003c/b\\u003e\"}";
// Act
var result = helper.Serialize(obj);
// Assert
var htmlString = Assert.IsType <HtmlString>(result);
Assert.Equal(expectedOutput, htmlString.ToString());
}
/// <summary>
/// Creates a new <see cref="JsonResultExecutor"/>.
/// </summary>
/// <param name="writerFactory">The <see cref="IHttpResponseStreamWriterFactory"/>.</param>
/// <param name="logger">The <see cref="ILogger{JsonResultExecutor}"/>.</param>
/// <param name="options">The <see cref="IOptions{MvcJsonOptions}"/>.</param>
/// <param name="charPool">The <see cref="ArrayPool{Char}"/> for creating <see cref="T:char[]"/> buffers.</param>
public JsonResultExecutor(
IHttpResponseStreamWriterFactory writerFactory,
ILogger <JsonResultExecutor> logger,
IOptions <MvcNewtonsoftJsonOptions> options,
ArrayPool <char> charPool)
{
if (writerFactory == null)
{
throw new ArgumentNullException(nameof(writerFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (charPool == null)
{
throw new ArgumentNullException(nameof(charPool));
}
_writerFactory = writerFactory;
_logger = logger;
_options = options.Value;
_charPool = new JsonArrayPool <char>(charPool);
}
/// <summary>
/// Configures the casing behavior of JSON serialization to use the member's casing for property names,
/// properties of dynamic types, and dictionary keys.
/// </summary>
/// <remarks>
/// This method modifies <see cref="JsonSerializerSettings.ContractResolver"/>.
/// </remarks>
/// <param name="options"><see cref="MvcNewtonsoftJsonOptions"/></param>
/// <returns><see cref="MvcNewtonsoftJsonOptions"/> with member casing settings.</returns>
public static MvcNewtonsoftJsonOptions UseMemberCasing(this MvcNewtonsoftJsonOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.SerializerSettings.ContractResolver is DefaultContractResolver resolver)
{
resolver.NamingStrategy = new DefaultNamingStrategy();
}
else
{
if (options.SerializerSettings.ContractResolver == null)
{
throw new InvalidOperationException(Resources.FormatContractResolverCannotBeNull(nameof(JsonSerializerSettings.ContractResolver)));
}
var contractResolverName = options.SerializerSettings.ContractResolver.GetType().Name;
throw new InvalidOperationException(
Resources.FormatInvalidContractResolverForJsonCasingConfiguration(contractResolverName, nameof(DefaultContractResolver)));
}
return(options);
}
public WalletsController(StoreRepository repo,
WalletRepository walletRepository,
CurrencyNameTable currencyTable,
BTCPayNetworkProvider networkProvider,
UserManager <ApplicationUser> userManager,
MvcNewtonsoftJsonOptions mvcJsonOptions,
NBXplorerDashboard dashboard,
RateFetcher rateProvider,
IAuthorizationService authorizationService,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
BTCPayWalletProvider walletProvider)
{
_currencyTable = currencyTable;
Repository = repo;
WalletRepository = walletRepository;
RateFetcher = rateProvider;
_authorizationService = authorizationService;
NetworkProvider = networkProvider;
_userManager = userManager;
_serializerSettings = mvcJsonOptions.SerializerSettings;
_dashboard = dashboard;
ExplorerClientProvider = explorerProvider;
_feeRateProvider = feeRateProvider;
_walletProvider = walletProvider;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
#pragma warning disable CS0618 // Type or member is obsolete
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
#pragma warning restore CS0618 // Type or member is obsolete
ILoggerFactory loggerFactory,
IServiceProvider serviceProvider,
RpcSettings rpcSettings)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var fullNode = serviceProvider.GetService <FullNode>();
var authorizedAccess = new RPCAuthorization();
string cookieStr = "__cookie__:" + new uint256(RandomUtils.GetBytes(32));
File.WriteAllText(fullNode.DataFolder.RpcCookieFile, cookieStr);
authorizedAccess.Authorized.Add(cookieStr);
if (rpcSettings.RpcPassword != null)
{
authorizedAccess.Authorized.Add(rpcSettings.RpcUser + ":" + rpcSettings.RpcPassword);
}
authorizedAccess.AllowIp.AddRange(rpcSettings.AllowIp);
MvcNewtonsoftJsonOptions options = GetMVCOptions(serviceProvider);
Serializer.RegisterFrontConverters(options.SerializerSettings, fullNode.Network);
app.UseMiddleware(typeof(RPCMiddleware), authorizedAccess);
app.UseRPC();
}
private void JsonSerializer(MvcNewtonsoftJsonOptions options)
{
JsonSerializerSettings settings = options.SerializerSettings;
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
settings.Formatting = Formatting.None;
}
public JsonPatchInputFormatter(
ILogger logger,
JsonSerializerSettings serializerSettings,
ArrayPool <char> charPool,
ObjectPoolProvider objectPoolProvider,
MvcOptions options,
MvcNewtonsoftJsonOptions jsonOptions
) : base(logger, serializerSettings, charPool, objectPoolProvider, options, jsonOptions) =>
/// <summary>Initializes a new instance of the <see cref="MvcHalJsonMvcOptionsSetup"/> class.</summary>
/// <param name="jsonOptions">The application's MVC JSON configuration.</param>
/// <param name="charPool">A pool of <see cref="char"/>.</param>
/// <param name="halRepository">The application's HAL+JSON repository.</param>
public MvcHalJsonMvcOptionsSetup(
IOptions <MvcNewtonsoftJsonOptions> jsonOptions,
ArrayPool <char> charPool,
IHalRepository halRepository)
{
_jsonOptions = jsonOptions.Value;
_charPool = charPool;
_halRepository = halRepository;
}
protected override IJsonHelper GetJsonHelper()
{
var options = new MvcNewtonsoftJsonOptions();
var helper = new NewtonsoftJsonHelper(
Options.Create(options),
ArrayPool <char> .Shared);
return(helper);
}
public CatalogModuleIndexedSearchController(
IProductIndexedSearchService productIndexedSearchService
, ICategoryIndexedSearchService categoryIndexedSearchService
, IOptions <MvcNewtonsoftJsonOptions> jsonOptions)
{
_productIndexedSearchService = productIndexedSearchService;
_categoryIndexedSearchService = categoryIndexedSearchService;
_jsonOptions = jsonOptions.Value;
}
public AssociationAuthorizationHandler(
IOptions <MvcNewtonsoftJsonOptions> jsonOptions,
IStoreService storeService,
ICategoryService categoryService)
{
_jsonOptions = jsonOptions.Value;
_storeService = storeService;
_categoryService = categoryService;
}
private static void SetSerializerSettings(MvcNewtonsoftJsonOptions o, JsonSerializerSettings jsonSettings)
{
o.SerializerSettings.DefaultValueHandling = jsonSettings.DefaultValueHandling;
o.SerializerSettings.NullValueHandling = jsonSettings.NullValueHandling;
o.SerializerSettings.ReferenceLoopHandling = jsonSettings.ReferenceLoopHandling;
o.SerializerSettings.ContractResolver = jsonSettings.ContractResolver;
o.SerializerSettings.TypeNameHandling = jsonSettings.TypeNameHandling;
o.SerializerSettings.Converters = jsonSettings.Converters;
}
public void Create_ReturnsMvcNewtonsoftJsonOptions(MvcNewtonsoftJsonOptions options)
{
var action = MvcNewtonsoftJsonOptionsFactory.Create();
action.Invoke(options);
// Asserts
options.SerializerSettings.Converters.OfType <StringEnumConverter>().Should().NotBeEmpty();
options.SerializerSettings.NullValueHandling.Should().Be(NullValueHandling.Ignore);
}
public GreenFieldWebhookManager(EventAggregator eventAggregator, IHttpClientFactory httpClientFactory,
IBackgroundJobClient backgroundJobClient, StoreRepository storeRepository,
MvcNewtonsoftJsonOptions jsonOptions) : base(
eventAggregator)
{
_httpClientFactory = httpClientFactory;
_backgroundJobClient = backgroundJobClient;
_storeRepository = storeRepository;
_jsonOptions = jsonOptions;
_eventAggregator = eventAggregator;
}
public static void SetMvcNewtonsoftJsonOptions(MvcNewtonsoftJsonOptions options)
{
var settings = options.SerializerSettings;
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
settings.NullValueHandling = NullValueHandling.Ignore;
settings.Converters.Add(new StringEnumConverter());
}
/// <summary>
/// Inserts <see cref="NewtonsoftDateTimeConverter"/> as serialization converter.
/// </summary>
/// <param name="options">The <see cref="MvcNewtonsoftJsonOptions"/>.</param>
/// <returns>The <see cref="MvcNewtonsoftJsonOptions"/>.</returns>
public static MvcNewtonsoftJsonOptions AddDateTimeConverter(this MvcNewtonsoftJsonOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options.SerializerSettings.Converters
.Add(new NewtonsoftDateTimeConverter(() => new RequestTimeZone(DateTimeInfo.TimeZone.Value)));
return(options);
}
public NewtonsoftNdjsonWriterFactory(IHttpResponseStreamWriterFactory httpResponseStreamWriterFactory, IOptions <MvcNewtonsoftJsonOptions> options, ArrayPool <char> innerJsonArrayPool)
{
_httpResponseStreamWriterFactory = httpResponseStreamWriterFactory ?? throw new ArgumentNullException(nameof(httpResponseStreamWriterFactory));
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
if (innerJsonArrayPool == null)
{
throw new ArgumentNullException(nameof(innerJsonArrayPool));
}
_jsonArrayPool = new NewtonsoftNdjsonArrayPool(innerJsonArrayPool);
}
public DevelopersFilter(
IHttpContextAccessor httpContextAccessor,
Func <IUserNameResolver> userNameResolverFactory,
Func <UserManager <ApplicationUser> > userManagerFactory,
IOptions <MvcNewtonsoftJsonOptions> jsonOptions
)
{
_httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
_userNameResolverFactory = userNameResolverFactory;
_userManagerFactory = userManagerFactory;
_jsonOptions = jsonOptions.Value;
}
private void ConfigureApiExceptions(IApplicationBuilder app)
{
app.Run(
async ctx =>
{
var result = new ApiError("An error occured.");
MvcNewtonsoftJsonOptions jsonOptions =
ctx.RequestServices.GetRequiredService <IOptions <MvcNewtonsoftJsonOptions> >().Value;
string output = JsonConvert.SerializeObject(result, jsonOptions.SerializerSettings);
ctx.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
await ctx.Response.WriteAsync(output, Encoding.UTF8);
});
}
/// <summary>
/// Initializes a new <see cref="NewtonsoftJsonPatchInputFormatter"/> instance.
/// </summary>
/// <param name="logger">The <see cref="ILogger"/>.</param>
/// <param name="serializerSettings">
/// The <see cref="JsonSerializerSettings"/>. Should be either the application-wide settings
/// (<see cref="MvcNewtonsoftJsonOptions.SerializerSettings"/>) or an instance
/// <see cref="JsonSerializerSettingsProvider.CreateSerializerSettings"/> initially returned.
/// </param>
/// <param name="charPool">The <see cref="ArrayPool{Char}"/>.</param>
/// <param name="objectPoolProvider">The <see cref="ObjectPoolProvider"/>.</param>
/// <param name="options">The <see cref="MvcOptions"/>.</param>
/// <param name="jsonOptions">The <see cref="MvcNewtonsoftJsonOptions"/>.</param>
public NewtonsoftJsonPatchInputFormatter(
ILogger logger,
JsonSerializerSettings serializerSettings,
ArrayPool <char> charPool,
ObjectPoolProvider objectPoolProvider,
MvcOptions options,
MvcNewtonsoftJsonOptions jsonOptions)
: base(logger, serializerSettings, charPool, objectPoolProvider, options, jsonOptions)
{
// Clear all values and only include json-patch+json value.
SupportedMediaTypes.Clear();
SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationJsonPatch);
}
public void UseMemberCasing_WillThrow_IfContractResolver_IsNot_DefaultContractResolver()
{
// Arrange
var options = new MvcNewtonsoftJsonOptions();
options.SerializerSettings.ContractResolver = new FooContractResolver();
var expectedMessage = Resources.FormatInvalidContractResolverForJsonCasingConfiguration(nameof(FooContractResolver), nameof(DefaultContractResolver));
// Act & Assert
var exception = Assert.Throws <InvalidOperationException>(
() => options.UseMemberCasing());
Assert.Equal(expectedMessage, actual: exception.Message);
}
private void loadJsonOptions(MvcNewtonsoftJsonOptions options)
{
//options.SerializerSettings.TraceWriter = new memoryTraceWriter();
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
options.SerializerSettings.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
options.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
options.SerializerSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None;
options.SerializerSettings.TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple;
options.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.None;
//needed for geojson serializer
foreach (var converter in GeoJsonSerializer.Create(new GeometryFactory(new PrecisionModel(), 4326)).Converters)
{
options.SerializerSettings.Converters.Add(converter);
}
}
public JsonHateoasOptionsSetup(IOptions <MvcNewtonsoftJsonOptions> jsonOptions, ArrayPool <char> charPool, IOptions <HateosOptions> hateoasOptions)
{
if (jsonOptions == null)
{
throw new ArgumentNullException(nameof(jsonOptions));
}
if (hateoasOptions == null)
{
throw new ArgumentNullException(nameof(hateoasOptions));
}
_jsonOptions = jsonOptions.Value;
_charPool = charPool ?? throw new ArgumentNullException(nameof(charPool));
_hateoasOptions = hateoasOptions.Value;
}
public NewtonsoftJsonMergePatchInputFormatter(
ILogger logger,
JsonSerializerSettings serializerSettings,
ArrayPool <char> charPool,
ObjectPoolProvider objectPoolProvider,
MvcOptions mvcOptions,
MvcNewtonsoftJsonOptions jsonOptions,
Lazy <IModelMetadataProvider> lazyModelMetadataProvider,
JsonMergePatchOptions jsonMergePatchOptions)
: base(logger, serializerSettings, charPool, objectPoolProvider, mvcOptions, jsonOptions)
{
SupportedMediaTypes.Clear();
SupportedMediaTypes.Add(JsonMergePatchMediaType);
_modelMetadata = new Lazy <ModelMetadata>(() => lazyModelMetadataProvider.Value.GetMetadataForType(typeof(JContainer)));
_jsonMergePatchOptions = jsonMergePatchOptions;
}
public CustomRoleManager(
IPermissionsRegistrar knownPermissions
, IPlatformMemoryCache memoryCache
, IRoleStore <Role> store
, IEnumerable <IRoleValidator <Role> > roleValidators
, ILookupNormalizer keyNormalizer
, IdentityErrorDescriber errors
, ILogger <RoleManager <Role> > logger
, IHttpContextAccessor contextAccessor
, IOptions <MvcNewtonsoftJsonOptions> jsonOptions)
: base(store, roleValidators, keyNormalizer, errors, logger, contextAccessor)
{
_knownPermissions = knownPermissions;
_memoryCache = memoryCache;
_jsonOptions = jsonOptions.Value;
}
