/// <summary>Main entry-point for this application.</summary> /// <param name="args">The arguments.</param> public static void Main(string[] args) { // setup our configuration (command line > environment > appsettings.json) Configuration = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: true) .AddEnvironmentVariables() .Build() ; // update configuration to make sure listen url is properly formatted Regex regex = new Regex(_regexBaseUrlMatch); Match match = regex.Match(Configuration["Basic_Internal_Url"]); Configuration["Basic_Internal_Url"] = match.ToString(); // create our rest client _restClient = new HttpClient(); // configure serialization _contractResolver = new CamelCasePropertyNamesContractResolver(); // create our web host (new Thread(() => { CreateWebHostBuilder(args).Build().Run(); })).Start(); // start our process StartProcessing(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddConfigurationOptions(Configuration); services.AddHttpContextAccessor(); services.AddPerformance(); services.AddSecurity(Configuration); services.AddSingletonService(); services.AddScopedService(); services.AddDbContextService(); services.AddRxWebLocalization(); services.AddControllers(); services.AddSwaggerOptions(); services.AddMvc(options => { options.AddRxWebSanitizers(); options.AddValidation(); }).SetCompatibilityVersion(CompatibilityVersion.Version_3_0).AddNewtonsoftJson( oo => { var resolver = new CamelCasePropertyNamesContractResolver(); if (resolver != null) { var res = resolver as DefaultContractResolver; res.NamingStrategy = null; } oo.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore; }); }
public NFCertaJsonSerializer() { ContractResolver = new CamelCasePropertyNamesContractResolver(); DateFormatHandling = DateFormatHandling.IsoDateFormat; DateParseHandling = DateParseHandling.DateTimeOffset; Converters.Add(new StringEnumConverter()); }
public static string GetFields(Type type) { var resolver = new CamelCasePropertyNamesContractResolver(); var contract = (JsonObjectContract)resolver.ResolveContract(type); return(string.Join(",", contract.Properties.Select(p => p.PropertyName))); }
/// <summary> /// Constructor method. /// </summary> public SharedJsonSettings() { NullValueHandling = NullValueHandling.Ignore; ReferenceLoopHandling = ReferenceLoopHandling.Ignore; Culture = System.Threading.Thread.CurrentThread.CurrentCulture; ContractResolver = new CamelCasePropertyNamesContractResolver(); }
public Startup(IConfiguration configuration, IHostEnvironment env) { Startup.Configuration = configuration; // https://github.com/drwatson1/AspNet-Core-REST-Service/wiki#using-environment-variables-in-configuration-options var envPath = Path.Combine(env.ContentRootPath, ".env"); DotNetEnv.Env.Load(envPath); // See: https://github.com/drwatson1/AspNet-Core-REST-Service/wiki#content-formatting JsonConvert.DefaultSettings = () => { var settings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Include, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, #if DEBUG Formatting = Formatting.Indented #else Formatting = Formatting.None #endif }; settings.Converters.Add(new StringEnumConverter { CamelCaseText = true }); return(settings); }; }
public JsonSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(); Formatting = Formatting.Indented; TypeNameHandling = TypeNameHandling.None; NullValueHandling = NullValueHandling.Include; }
public CamelCaseJsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(); Converters.Add(new StringEnumConverter { CamelCaseText = true }); }
public CamelCaseJsonSerializer() { ContractResolver = new CamelCasePropertyNamesContractResolver(); DateFormatHandling = DateFormatHandling.IsoDateFormat; DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind; Formatting = Formatting.Indented; }
public Startup(IConfiguration configuration, IHostEnvironment env) { Startup.Configuration = configuration; var envPath = Path.Combine(env.ContentRootPath, ".env"); if (File.Exists(envPath)) { DotNetEnv.Env.Load(); } JsonConvert.DefaultSettings = () => new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Include, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, #if DEBUG Formatting = Formatting.Indented #else Formatting = Formatting.None #endif }; }
public void SetUp() { _container = new Container { Name = "Something", PaymentModels = new List <BasePaymentModel> { new AchInputModel { PaymentType = "ach", PaymentEnum = PaymentType.One, PaymentNumber = 1, AccountNumber = "123" }, new CreditCardInputModel { PaymentType = "cc", PaymentEnum = PaymentType.Two, PaymentNumber = 2, Name = "John" }, new PayPalInputModel { PaymentType = "paypal", PaymentEnum = PaymentType.Three, PaymentNumber = 3, CancelUrl = "https://cancel.com" } } }; _resolver = new CamelCasePropertyNamesContractResolver(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services config.Formatters.Clear(); config.Formatters.Add(new JsonMediaTypeFormatter()); var item = new CamelCasePropertyNamesContractResolver(); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = item; // Configure Web API to use only bearer token authentication. config.SuppressDefaultHostAuthentication(); config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType)); var corsAttr = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(corsAttr); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "SearchAPI", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional }); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); }
/// <summary> /// Converts the inheriting class to a JSON-formatted string using programmed serializers adding in the contents from the specified generic dictionary. /// </summary> /// <param name="parameters">The dictionary that will have it contents added to resulting JSON string.</param> public virtual string ToJson(IDictionary parameters) { var camel = new CamelCasePropertyNamesContractResolver(); var cSerialize = new JsonSerializer { ContractResolver = camel }; var serializer = new JsonSerializerSettings { ContractResolver = camel, DateFormatHandling = DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = DateTimeZoneHandling.Utc, DefaultValueHandling = DefaultValueHandling.Populate, Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Include, MissingMemberHandling = MissingMemberHandling.Error }; serializer.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy())); var job = JObject.FromObject(this, cSerialize); string[] keys = parameters.Keys.Cast <string>().ToArray(); for (int i = 0; i < keys.Length; i++) { string key = keys[i]; job.Add(key, JToken.FromObject(parameters[key], cSerialize)); } return(JsonConvert.SerializeObject(job, serializer)); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer"></param> /// <param name="value"></param> /// <param name="serializer"></param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var extension = value as UiExtension; if (extension == null) { return; } var extensionStructure = new { extension }; var resolver = new CamelCasePropertyNamesContractResolver(); resolver.NamingStrategy.OverrideSpecifiedNames = false; var settings = new JsonSerializerSettings { ContractResolver = resolver, }; var jObject = JObject.FromObject(extensionStructure, JsonSerializer.Create(settings)); serializer.Serialize(writer, jObject); }
public ClientConfiguration() { UseSsl = false; SslPort = 11207; ApiPort = 8092; DirectPort = 11210; MgmtPort = 8091; HttpsMgmtPort = 18091; HttpsApiPort = 18092; ObserveInterval = 10; //ms ObserveTimeout = 500; //ms MaxViewRetries = 2; ViewHardTimeout = 30000; //ms HeartbeatConfigInterval = 10000; //ms EnableConfigHeartBeat = true; SerializationContractResolver = new CamelCasePropertyNamesContractResolver(); DeserializationContractResolver = new CamelCasePropertyNamesContractResolver(); PoolConfiguration = new PoolConfiguration(); BucketConfigs = new Dictionary <string, BucketConfiguration> { { DefaultBucket, new BucketConfiguration { PoolConfiguration = PoolConfiguration } } }; Servers = new List <Uri> { _defaultServer }; //Set back to default _serversChanged = false; _poolConfigurationChanged = false; }
/// <summary> /// Converts string to camel-case formatted string /// </summary> /// <param name="str"></param> /// <param name="config"></param> /// <returns></returns> public static string ToCamelCase(this string str, Action <CamelCasePropertyNamesContractResolver> config = null) { var camelCase = new CamelCasePropertyNamesContractResolver(); config?.Invoke(camelCase); return(camelCase.GetResolvedPropertyName(str)); }
/// <summary> /// Registers all Web API routes /// </summary> /// <param name="config"></param> public static void Register(HttpConfiguration config) { config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "APIWithActions", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; //((DefaultContractResolver)config.Formatters.JsonFormatter.SerializerSettings.ContractResolver).IgnoreSerializableAttribute = true; var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter; var contractResolver = new CamelCasePropertyNamesContractResolver(); contractResolver.IgnoreSerializableAttribute = true; jsonFormatter.SerializerSettings.ContractResolver = contractResolver; }
public static void Register(HttpConfiguration config) { config.Formatters.Remove(config.Formatters.FormUrlEncodedFormatter); config.Formatters.Remove(config.Formatters.XmlFormatter); var formatting = (DevEnvironment.IsDebug) ? Formatting.Indented : Formatting.None; var contractResolver = new CamelCasePropertyNamesContractResolver(); var dateTimeConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fff" }; var jsonSerializerSettings = config.Formatters.JsonFormatter.SerializerSettings; jsonSerializerSettings.Formatting = formatting; jsonSerializerSettings.ContractResolver = contractResolver; jsonSerializerSettings.Converters.Add(dateTimeConverter); config.IncludeErrorDetailPolicy = DevEnvironment.IsDebug ? IncludeErrorDetailPolicy.Always : IncludeErrorDetailPolicy.Default; config.MapHttpAttributeRoutes(); config.EnsureInitialized(); }
public CustomJsonSerializer() { Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()); ContractResolver = new CamelCasePropertyNamesContractResolver(); DateTimeZoneHandling = DateTimeZoneHandling.Local; NullValueHandling = NullValueHandling.Ignore; }
public Startup(IConfiguration configuration, IHostingEnvironment env, ILogger <Startup> logger) { Logger = logger; Startup.Configuration = configuration; // https://github.com/drwatson1/AspNet-Core-REST-Service/wiki#using-environment-variables-in-configuration-options var envPath = Path.Combine(env.ContentRootPath, ".env"); if (File.Exists(envPath)) { DotNetEnv.Env.Load(); } // See: https://github.com/drwatson1/AspNet-Core-REST-Service/wiki#content-formatting JsonConvert.DefaultSettings = () => new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Include, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, #if DEBUG Formatting = Formatting.Indented #else Formatting = Formatting.None #endif }; }
private void InitFormatters(HttpConfiguration config) { var json = config.Formatters.JsonFormatter; var resolver = new CamelCasePropertyNamesContractResolver(); resolver.NamingStrategy.ProcessDictionaryKeys = true; json.SerializerSettings.ContractResolver = resolver; }
public ServiceJsonSerializerSettings() { Culture = CultureInfo.InvariantCulture; ContractResolver = new CamelCasePropertyNamesContractResolver(); ReferenceLoopHandling = ReferenceLoopHandling.Ignore; Converters.Add(new DateTimeJsonConverter()); Converters.Add(new StringEnumConverter()); }
public CamelCaseJsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(); Converters.Add(new StringEnumConverter { NamingStrategy = new CamelCaseNamingStrategy() }); NullValueHandling = NullValueHandling.Ignore; }
private MluviiApiJsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(); Converters = new List <JsonConverter>() { new SafeStringEnumConverter() }; }
public static void ConfigureApi(this IServiceCollection services, FluentValidationOptions fluentValidationOptions, Action <MvcOptions> configureMvc = null, Action <MvcJsonOptions> configureJson = null) { /************************* * IConfiguration is not available yet *************************/ services.AddAntiforgery(options => options.HeaderName = "X-XSRF-TOKEN"); services.AddRouting(options => { options.LowercaseUrls = true; options.LowercaseQueryStrings = true; }); services.AddApiVersioning(options => { options.AssumeDefaultVersionWhenUnspecified = true; options.DefaultApiVersion = new ApiVersion(1, 0); options.ReportApiVersions = true; options.UseApiBehavior = false; }); var mvcBuilder = services.AddMvcCore(o => { o.Filters.AddService(typeof(GlobalExceptionFilter)); o.ModelValidatorProviders.Clear(); configureMvc?.Invoke(o); }) .AddAuthorization() .AddJsonFormatters() .AddJsonOptions(options => { var settings = options.SerializerSettings; var camelCasePropertyNamesContractResolver = new CamelCasePropertyNamesContractResolver(); settings.ContractResolver = camelCasePropertyNamesContractResolver; settings.Converters.Add(new IsoDateTimeConverter()); settings.Converters.Add(new StringEnumConverter(new DefaultNamingStrategy())); configureJson?.Invoke(options); }); services.AddVersionedApiExplorer(options => { options.GroupNameFormat = "VVV"; options.SubstituteApiVersionInUrl = true; }); if (fluentValidationOptions.Enabled) { mvcBuilder.AddFluentValidation( configuration => fluentValidationOptions.Configure?.Invoke(configuration)); } }
public static IEnumerable <string> GetPaths <T>(bool camelCase = false) where T : class { var resolver = new CamelCasePropertyNamesContractResolver(); return(typeof(T).GetProperties() .Where(p => p.GetCustomAttribute <UniqueKeyAttribute>() != null) .Select(p => $"/{(camelCase ? resolver.GetResolvedPropertyName(p.Name) : p.Name)}")); }
public DefaultSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver { NamingStrategy = new SnakeCaseNamingStrategy() }; NullValueHandling = NullValueHandling.Ignore; Converters.Add(new EnumConverter()); }
public GuidelineJsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(); TypeNameHandling = TypeNameHandling.None; DateFormatHandling = DateFormatHandling.IsoDateFormat; NullValueHandling = NullValueHandling.Ignore; DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate; Converters.Add(new StringEnumConverter()); }
private static string Serialize <TItem>(TItem value) { var resolver = new CamelCasePropertyNamesContractResolver(); var settings = new JsonSerializerSettings { ContractResolver = resolver }; return(JsonConvert.SerializeObject(value, settings)); }
public RestSerializeSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Serialize; PreserveReferencesHandling = PreserveReferencesHandling.None; TypeNameHandling = TypeNameHandling.All; Formatting = Formatting.None; ContractResolver = new CamelCasePropertyNamesContractResolver(); }