public static IMvcBuilder AddArcaneNsJson
(this IMvcBuilder mvcBuilder,
JsonSerializerSetup serializerSetup,
IContractResolver contractResolver,
MvcJsonOptions options,
JsonSerializerConfig?config = null) =>
mvcBuilder.AddNewtonsoftJson(
nsOptions => {
nsOptions.AllowInputFormatterExceptionMessages = options.allowInputFormatterExceptionMessages;
var settings = nsOptions.SerializerSettings;
serializerSetup.SetUpNsSerializerSettings(settings, config);
settings.ContractResolver = contractResolver;
});
public static IMvcBuilder AddCustomNewtonSoftJson(this IMvcBuilder builder)
{
builder.AddNewtonsoftJson(configure => {
configure.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
configure.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
configure.SerializerSettings.DateParseHandling = DateParseHandling.DateTimeOffset;
configure.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
configure.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
configure.SerializerSettings.Formatting = Formatting.Indented;
configure.SerializerSettings.Converters.Add(new StringEnumConverter());
});
return(builder);
}
public static IMvcBuilder AddJsonDateFormatter(this IMvcBuilder builder)
{
#if NETCOREAPP2_1
builder.AddJsonOptions(options =>
{
options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
});
#endif
#if NETCOREAPP3_1
builder.AddNewtonsoftJson(opt => opt.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss");
#endif
return(builder);
}
public static IMvcBuilder AddJsonOptions(IMvcBuilder mvcBuilder)
{
mvcBuilder.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
//options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
});
return(mvcBuilder);
}
public static IMvcBuilder BootstrapNewtonsoftJson(this IMvcBuilder builder)
{
return(builder.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver {
NamingStrategy = new CamelCaseNamingStrategy()
};
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
options.SerializerSettings.NullValueHandling = NullValueHandling.Include;
options.SerializerSettings.Formatting = Formatting.Indented;
options.SerializerSettings.Converters.Add(new StringEnumConverter());
}));
}
public static IMvcBuilder AddJson(this IMvcBuilder builder)
{
builder
.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.Formatting = Formatting.Indented;
});
return(builder);
}
public static IMvcBuilder AddControllersInfrastructure(this IMvcBuilder builder)
{
return(builder
.AddNewtonsoftJson(options =>
{
options.SerializerSettings.TypeNameHandling = TypeNameHandling.Objects;
options.SerializerSettings.DateFormatString = SystemFormats.ShortDatePattern;
options.SerializerSettings.Converters.Add(new IsoDateTimeConverter()
{
DateTimeFormat = SystemFormats.LongDatePattern
});
})
.AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <IApplicationDbContext>()));
}
/// <summary>
/// AddJsonSerializerSettings
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IMvcBuilder AddJsonSerializerSettings(this IMvcBuilder builder)
{
builder.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
options.SerializerSettings.Formatting = Formatting.Indented;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.Culture = CultureInfo.GetCultureInfo("es-ES");
options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local;
options.UseCamelCasing(true);
});
return(builder);
}
/// <summary>
/// 配置Json序列化规则
/// </summary>
/// <param name="builder"></param>
public static void AddNewtonsoftJsonService(this IMvcBuilder builder)
{
builder.AddNewtonsoftJson(options =>
{
//忽略Json序列化循环引用
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
// 不使用驼峰
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
// 设置时间格式
options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
// 如字段为null值，该字段不会返回到前端
// options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
});
}
public static IMvcBuilder WithJsonFormattersBasedOnJsonNet(
this IMvcBuilder builder,
Action <JsonSerializerSettings> settingsConfigurator)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (settingsConfigurator == null)
{
throw new ArgumentNullException(nameof(settingsConfigurator));
}
builder.AddNewtonsoftJson(x => settingsConfigurator(x.SerializerSettings));
return(builder);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages().AddRazorRuntimeCompilation();
services.AddSession();
services.Configure <ForwardedHeadersOptions>(options => options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto);
services.AddResponseCompression();
IMvcBuilder mvc = services.AddControllersWithViews().AddRazorRuntimeCompilation();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson(
options => {
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
options.SerializerSettings.Formatting = Formatting.Indented;
}
);
}
public void ConfigureServices(IServiceCollection serviceCollection)
{
PrintEnvironment();
ConfigureServiceHttps(serviceCollection);
ConfigureServicesControllers(serviceCollection);
serviceCollection.AddLogging();
serviceCollection.AddRouting();
IMvcBuilder mvcBuilder = serviceCollection.AddMvc((x) => { x.EnableEndpointRouting = true; });
mvcBuilder.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvcBuilder.AddNewtonsoftJson();
CommonConfigureServices(serviceCollection);
SpecificConfigureServices(serviceCollection);
}
public static IMvcBuilder SetJsonOptions(this IMvcBuilder builder)
{
builder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.WriteIndented = false;
options.JsonSerializerOptions.IgnoreNullValues = true;
options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
options.JsonSerializerOptions.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals | JsonNumberHandling.AllowReadingFromString;
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase, false));
options.JsonSerializerOptions.Converters.Add(new NetTopologySuite.IO.Converters.GeoJsonConverterFactory());
});
var serializationSettings = new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None,
Converters = new List <Newtonsoft.Json.JsonConverter>
{
new Newtonsoft.Json.Converters.StringEnumConverter(),
new GeoPointJsonConverter()
}
};
foreach (var converter in GeoJsonSerializer.Create(serializationSettings, new GeometryFactory(new PrecisionModel(), 4326)).Converters)
{
serializationSettings.Converters.Add(converter);
}
builder.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ReferenceLoopHandling = serializationSettings.ReferenceLoopHandling;
options.SerializerSettings.NullValueHandling = serializationSettings.NullValueHandling;
options.SerializerSettings.ContractResolver = serializationSettings.ContractResolver;
options.SerializerSettings.Formatting = serializationSettings.Formatting;
options.SerializerSettings.Converters = serializationSettings.Converters;
});
JsonConvert.DefaultSettings = () => serializationSettings;
return(builder);
}
/// <summary>
/// Configures logging
/// </summary>
/// <param name="mvcBuilder">MVC builder</param>
protected virtual void ConfigureJsonOptions(IMvcBuilder mvcBuilder)
{
mvcBuilder
.AddNewtonsoftJson(options =>
{
// Ignore null values by default
options.SerializerSettings.NullValueHandling = NullValueHandling;
options.SerializerSettings.ContractResolver = ContractResolver;
if (JsonConverters != null)
{
foreach (var jsonConverter in JsonConverters)
{
options.SerializerSettings.Converters.Add(jsonConverter);
}
}
});
}
public static IMvcBuilder AddCustomJsonOptions(
this IMvcBuilder builder,
IWebHostEnvironment webHostEnvironment) =>
builder.AddNewtonsoftJson(
options =>
{
if (webHostEnvironment.IsDevelopment())
{
// Pretty print the JSON in development for easier debugging.
options.SerializerSettings.Formatting = Formatting.Indented;
}
// Parse dates as DateTimeOffset values by default. You should prefer using DateTimeOffset over
// DateTime everywhere. Not doing so can cause problems with time-zones.
options.SerializerSettings.DateParseHandling = DateParseHandling.DateTimeOffset;
// Output enumeration values as strings in JSON.
options.SerializerSettings.Converters.Add(new StringEnumConverter());
});
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <ForwardedHeadersOptions>(options => options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto);
services.AddResponseCompression();
services.AddCors(builder => builder.AddDefaultPolicy(policyBuilder => policyBuilder.AllowAnyOrigin()));
services.AddLogging(builder => {
builder.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("System", LogLevel.Warning)
.AddFilter("NToastNotify", LogLevel.Warning)
.AddConsole();
});
IMvcBuilder mvc = services.AddControllers();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson(
options => {
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
options.SerializerSettings.Formatting = Formatting.Indented;
}
);
}
/// <summary>
/// 配置json序列化
/// </summary>
/// <param name="builder"></param>
public static void ConfigJsonOptions(this IMvcBuilder builder)
{
builder.AddNewtonsoftJson(options =>
{
var settings = options.SerializerSettings;
//日期类型默认格式化处理
// //setting.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
settings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
//// 空值处理
//setting.NullValueHandling = NullValueHandling.Ignore;
// 最大序列化深度，包括请求传参的序列化深度，不可设置太小了
settings.MaxDepth = 5;
// 忽略循环引用
settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
// 全局设置要排除的字段
settings.ContractResolver = new LimitPropsContractResolver(new[] { "password", "extends" }, false);
});
}
/// <summary>
/// Predefined setup for the used Newtonsoft JSON serializer
/// </summary>
/// <param name="mvc">The MVC builder the serializer attaches to</param>
public static void AddJsonSerializer(this IMvcBuilder mvc)
{
mvc.AddNewtonsoftJson(options =>
{
// Setup parser default settings
var namingStrategy = new CamelCaseNamingStrategy(false, true);
options.SerializerSettings.Formatting = Formatting.Indented;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver
{
NamingStrategy = namingStrategy
};
// Add custom converters
var camelCaseStrategy = namingStrategy;
var stringToEnumConverter = new StringEnumConverter(camelCaseStrategy);
options.SerializerSettings.Converters.Add(stringToEnumConverter);
// Register settings for the parser as default settings
JsonConvert.DefaultSettings = () => options.SerializerSettings;
});
}
private void AddJsonOptions(IMvcBuilder mvcBuilder)
{
if (Module.UseSystemJson)
{
mvcBuilder.AddJsonOptions(options =>
{
options.JsonSerializerOptions.IgnoreNullValues = true;
options.JsonSerializerOptions.WriteIndented = false;
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
options.JsonSerializerOptions.Converters.Add(new PolymorphicWriteOnlyJsonConverter <FieldMetadata>());
// options.JsonSerializerOptions.Converters.Add(new DataFieldJsonConverter());
});
}
else
{
mvcBuilder.AddNewtonsoftJson(options =>
{
// options.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore; // do not use - zeros in numbers ignored also
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
});
}
}
/// <summary>
/// Add json serializer
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
internal static IMvcBuilder AddJsonSerializer(this IMvcBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder = builder.AddNewtonsoftJson();
// Configure json serializer settings transiently to pick up all converters
builder.Services.AddTransient <IConfigureOptions <MvcNewtonsoftJsonOptions> >(services =>
new ConfigureNamedOptions <MvcNewtonsoftJsonOptions>(Options.DefaultName, options => {
var provider = services.GetService <IJsonSerializerSettingsProvider>();
var settings = provider?.Settings;
if (settings == null)
{
return;
}
options.SerializerSettings.Formatting = settings.Formatting;
options.SerializerSettings.NullValueHandling = settings.NullValueHandling;
options.SerializerSettings.DefaultValueHandling = settings.DefaultValueHandling;
options.SerializerSettings.ContractResolver = settings.ContractResolver;
options.SerializerSettings.DateFormatHandling = settings.DateFormatHandling;
options.SerializerSettings.MaxDepth = settings.MaxDepth;
options.SerializerSettings.Context = settings.Context;
var set = new HashSet <JsonConverter>(options.SerializerSettings.Converters);
if (!set.IsProperSupersetOf(settings.Converters))
{
options.SerializerSettings.Converters =
set.MergeWith(settings.Converters).ToList();
}
}));
return(builder);
}
public static IMvcBuilder AddCustomNewtonsoftJson(this IMvcBuilder builder)
{
return(builder.AddNewtonsoftJson(options => options.SerializerSettings.IncludeCustomConverters()));
}
public static IMvcBuilder ConfigureNewtonsoftJson(this IMvcBuilder builder)
{
builder.AddNewtonsoftJson(o => o.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore);
return(builder);
}
public static IServiceCollection AddNewtonJsonServices(this IMvcBuilder builder) => builder.AddNewtonsoftJson(ConfigureJson).Services;
public static IMvcBuilder AddApiProvider <TModule>(this IMvcBuilder mvcBuilder, Action <ApiProviderOptions> options) where TModule : WebModule
{
var services = mvcBuilder.Services;
services.AddOptions <ApiProviderOptions>();
services.Configure(options);
mvcBuilder.AddNewtonsoftJson();
mvcBuilder.AddApplicationPart(typeof(VersionedMetadataController).Assembly);
services.AddApiVersioning(options =>
{
options.ReportApiVersions = true;
options.AssumeDefaultVersionWhenUnspecified = false;
});
services.AddOData().EnableApiVersioning();
services.Configure <MvcOptions>(op =>
{
op.EnableEndpointRouting = false;
op.OutputFormatters.Insert(0, new CustomODataOutputFormatter());
});
services.AddODataApiExplorer(
options =>
{
// add the versioned api explorer, which also adds IApiVersionDescriptionProvider service
// note: the specified format code will format the version as "'v'major[.minor][-status]"
options.GroupNameFormat = "'v'VVV";
// note: this option is only necessary when versioning by url segment. the SubstitutionFormat
// can also be used to control the format of the API version in route templates
options.SubstituteApiVersionInUrl = true;
});
services.AddTransient <IConfigureOptions <SwaggerGenOptions>, ConfigureSwaggerOptions>();
services.AddSwaggerGen(
options =>
{
// add a custom operation filter which sets default values
options.OperationFilter <SwaggerDefaultValues>();
options.OperationFilter <ODataErrorOperationFilter>();
options.SchemaFilter <ODataErrorSchemaFilter>();
options.OperationFilter <ODataQueryOperationFilter>();
// integrate xml comments
var xmlFile = $"{typeof(TModule).Assembly.GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
if (File.Exists(xmlPath))
{
options.IncludeXmlComments(xmlPath);
}
//disable until openapi 3.0 is supported for autorest (including ruby)
//options.AddSecurityDefinition("bearer", new OpenApiSecurityScheme
//{
// Description = "JWT Authorization header using the Bearer scheme (Example: 'Bearer 12345abcdef')",
// Name = "Authorization",
// In = ParameterLocation.Header,
// Type = SecuritySchemeType.Http,
// Scheme = "bearer",
//});
//options.AddSecurityRequirement(new OpenApiSecurityRequirement
//{
// {
// new OpenApiSecurityScheme
// {
// Reference = new OpenApiReference
// {
// Type = ReferenceType.SecurityScheme,
// Id = "bearer"
// }
// },
// Array.Empty<string>()
// }
//});
options.ResolveConflictingActions(app => app.First());
options.EnableAnnotations();
options.CustomSchemaIds((type) =>
{
var defaultName = DefaultSchemaIdSelector(type);
return(defaultName.EndsWith("IEnumerableODataValue")
? defaultName.Replace("IEnumerableODataValue", "List")
: defaultName);
});
});
services.AddSwaggerGenNewtonsoftSupport();
services.AddSingleton <IAuthorizationHandler, HasScopeHandler>();
return(mvcBuilder);
}
public static IMvcBuilder AddBotSerializer(this IMvcBuilder builder) => builder.AddNewtonsoftJson(options => Serializer.Modify(options.SerializerSettings));
public static IMvcBuilder AddNewtonsoftJsonWithStringEnumConverter(
this IMvcBuilder mvcBuilder)
{
return(mvcBuilder.AddNewtonsoftJson(options =>
options.SerializerSettings.Converters.Add(new StringEnumConverter())));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// set up the connection WITHOUT actually connecting to the database
string connectionString = Configuration.GetConnectionString(WebServiceConstants.DB_CONTEXT_NAME);
services.AddDbContext <BookDbContext>(option =>
{
option.UseSqlServer(connectionString, option =>
option.MigrationsAssembly(WebServiceConstants.MIGRATIONS_ASSEMBLY_NAME));
});
AddIdentityService(services);
// ==== Add Authentication ====
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
//options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
//options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
//options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddCookie(options =>
{
options.LoginPath = "/user/Users/Login";
options.AccessDeniedPath = "/user/Forbidden";
options.SlidingExpiration = true;
});
//Assembly ControllerAssembly = typeof(UsersController).Assembly;
IMvcBuilder mvcBuilder = services.AddControllersWithViews(options =>
{
//AuthorizationPolicy policy = new AuthorizationPolicyBuilder()
// .RequireAuthenticatedUser()
// .Build();
if (!Program.SkipSecurityChecks)
{
options.Filters.Add(new AuthorizeFilter()); // gloabal filter // TODO: SECURITY - JAGAN
}
});
//x.AddJsonOptions(SetupTextJsonOptions);
mvcBuilder.AddNewtonsoftJson(SetupNewtonsoftJsonOptions);
mvcBuilder.AddJsonOptions(opt => opt.JsonSerializerOptions.PropertyNamingPolicy = null);
#if DEBUG
mvcBuilder.AddRazorRuntimeCompilation();
#endif
// make sure that all emails are unique, otherwise UserManager.FindByEmail
// will throw.
services.Configure <IdentityOptions>(options =>
{
options.User.RequireUniqueEmail = true;
});
SetupPryzeboxServices(services, Configuration);
services.AddSwaggerGen(swagger =>
{
swagger.SwaggerDoc("v1", new OpenApiInfo {
Title = "BookRental API"
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
#region HttpClientFactory
services.AddHttpClient();
#endregion
#region Compression
services.AddResponseCompression();
#endregion
#region Authentication
// Add Authentication later
#endregion
#region Authorization
// Add Authorization later
#endregion
#region Hub
services.AddSignalR(o => { o.EnableDetailedErrors = true; });
#endregion
#region MVC
IMvcBuilder mvcBuilder = services.AddControllers(options => { options.Filters.Add <ContextFilter>(); });
mvcBuilder.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvcBuilder.AddNewtonsoftJson(options =>
{
options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
});
#endregion
#region MVC
IList <string> controllerAssemblyNames = new List <string>
{
"Module.UserState.Impl",
"Module.Waiting.Action",
"Module.Room.Action",
"Module.Game.Action",
};
foreach (string controllerAssemblyName in controllerAssemblyNames)
{
Assembly assembly = Assembly.Load(controllerAssemblyName);
mvcBuilder.AddApplicationPart(assembly);
}
#endregion
}
public void Execute(IMvcBuilder mvcBuilder, IServiceProvider serviceProvider)
{
mvcBuilder.AddNewtonsoftJson();
}
public static void ConfigureJsonSettings(
this IMvcBuilder mvc,
IServiceCollection services,
JsonSerializerEnum jsonSerializerMode,
string timezoneHeaderName,
TimeZoneInfo defaultTimeZone)
{
CaseUtility.JsonSerializerMode = jsonSerializerMode;
JsonSerializerSettings = null;
JsonSerializer = null;
EnumWithContractJsonConverter.IgnoreEnumCase = Api.ApiSettings.UseOriginalEnumValue;
switch (jsonSerializerMode)
{
case JsonSerializerEnum.Camelcase:
JsonSerializer = JsonUtility.CamelCaseJsonSerializer;
JsonSerializerSettings = JsonUtility.CamelCaseJsonSerializerSettings;
break;
case JsonSerializerEnum.Lowercase:
JsonSerializer = JsonUtility.LowerCaseJsonSerializer;
JsonSerializerSettings = JsonUtility.LowerCaseJsonSerializerSettings;
break;
case JsonSerializerEnum.Snakecase:
JsonSerializer = JsonUtility.SnakeCaseJsonSerializer;
JsonSerializerSettings = JsonUtility.SnakeCaseJsonSerializerSettings;
break;
default:
break;
}
// for fluent validation in cqrs extensions
PropertyName.Resolver = (propertyName) =>
{
var parts = propertyName.Split('.');
return(string.Join(".", parts.Select(r => r.ToCase(jsonSerializerMode.ToString()))));
};
JsonConvert.DefaultSettings = () => JsonSerializerSettings;
services.AddScoped((provider) => JsonSerializer);
services.AddScoped((provider) => JsonSerializerSettings);
DateTimeConverter.DefaultTimeZone = defaultTimeZone;
mvc.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = JsonSerializerSettings.ContractResolver;
options.SerializerSettings.NullValueHandling = JsonSerializerSettings.NullValueHandling;
options.SerializerSettings.Converters.Add(new DateTimeConverter(() =>
{
var httpContextAccessor = services.BuildServiceProvider().GetService <IHttpContextAccessor>();
return(DateTimeConverter.GetTimeZoneByAspNetHeader(httpContextAccessor, timezoneHeaderName));
}));
foreach (var converter in JsonSerializerSettings.Converters)
{
options.SerializerSettings.Converters.Add(converter);
}
});
}
