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; }