Specifies the settings on a JsonSerializer object.
        public static void RegisterApis(HttpConfiguration config)
        {
            var serializerSettings = new JsonSerializerSettings();
            serializerSettings.Converters.Add(new IsoDateTimeConverter());

            config.Formatters[0] = new JsonNetFormatter(serializerSettings);
            config.Formatters.Add(new ProtoBufFormatter()); 
            config.Formatters.Add(new ContactPngFormatter());
            config.Formatters.Add(new VCardFormatter());
            config.Formatters.Add(new ContactCalendarFormatter());
            
            config.MessageHandlers.Add(new UriFormatExtensionHandler(new UriExtensionMappings()));
            
            //var loggingRepo = config.ServiceResolver.GetService(typeof(ILoggingRepository)) as ILoggingRepository;
            //config.MessageHandlers.Add(new LoggingHandler(loggingRepo));

            config.MessageHandlers.Add(new NotAcceptableHandler());

            ConfigureResolver(config);

            config.Routes.MapHttpRoute(
                "Default",
                "{controller}/{id}/{ext}",
                new { id = RouteParameter.Optional, ext = RouteParameter.Optional });
        }
Example #2
0
 public Reddit()
 {
     JsonSerializerSettings = new JsonSerializerSettings();
     JsonSerializerSettings.CheckAdditionalContent = false;
     JsonSerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore;
     _webAgent = new WebAgent();
 }
        // ReSharper disable once InconsistentNaming
        public async void Controller_Can_POST_a_new_Registerd_User()
        {
            using (var client = new HttpClient())
            {
                // Arrange
                client.BaseAddress = new Uri(UrlBase);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
           

                // Manually set "content-type" header to reflect serialized data format.
                var settings = new JsonSerializerSettings();
                var ser = JsonSerializer.Create(settings);
                var j = JObject.FromObject(_registration, ser);
                HttpContent content = new StringContent(j.ToString());
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                

                // Act
                // PostAsJsonAsync(), per MS recommendation, however results in problem of RegisterAsync() accepting payload: content type?
                // Serialized registration data is now associated with HttpContent element explicitly, with format then set.
                var response = await client.PostAsync(client.BaseAddress + "/RegisterAsync", content); 
                //var response = await client.PostAsJsonAsync(client.BaseAddress + "/RegisterAsync", _registration); // error
                
                // Assert
                Assert.IsTrue(response.StatusCode == HttpStatusCode.Created);
                Assert.IsTrue(response.IsSuccessStatusCode);
                
            }
        }
        public JsonNetFormatter(JsonSerializerSettings jsonSerializerSettings) {

            _jsonSerializerSettings = jsonSerializerSettings ?? new JsonSerializerSettings();

            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
            Encoding = new UTF8Encoding(false, true);
        }
        public static new void Install(HttpConfiguration config, IAppBuilder app)
        {
            config.SuppressHostPrincipal();

            app.UseCors(CorsOptions.AllowAll);

            app.MapSignalR();

            var jSettings = new JsonSerializerSettings();

            jSettings.Formatting = Formatting.Indented;

            jSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            config.Formatters.Remove(config.Formatters.XmlFormatter);

            config.Formatters.JsonFormatter.SerializerSettings = jSettings;

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );
        }
Example #6
0
        public JsonInputFormatter()
        {
            _supportedMediaTypes = new List<string>
            {
                "application/json",
                "text/json"
            };

            _supportedEncodings = new List<Encoding>
            {
                new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true),
                new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true)
            };

            _jsonSerializerSettings = new JsonSerializerSettings
            {
                MissingMemberHandling = MissingMemberHandling.Ignore,

                // Limit the object graph we'll consume to a fixed depth. This prevents stackoverflow exceptions
                // from deserialization errors that might occur from deeply nested objects.
                MaxDepth = DefaultMaxDepth,

                // Do not change this setting
                // Setting this to None prevents Json.NET from loading malicious, unsafe, or security-sensitive types
                TypeNameHandling = TypeNameHandling.None
            };
        }
 static JsonFormatter()
 {
     SerializerSettings = new JsonSerializerSettings
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver()
     };
 }
Example #8
0
        public TesterController(IInstanceService instanceService)
        {
            this.instanceService = instanceService;

            jsonSerializerSettings = new JsonSerializerSettings();
            jsonSerializerSettings.NullValueHandling = NullValueHandling.Ignore;
        }
        public SchemaRegistry(
            JsonSerializerSettings jsonSerializerSettings,
            IDictionary<Type, Func<Schema>> customSchemaMappings,
            IEnumerable<ISchemaFilter> schemaFilters,
            IEnumerable<IModelFilter> modelFilters,
            Func<Type, string> schemaIdSelector,
            bool ignoreObsoleteProperties,
            bool describeAllEnumsAsStrings,
            bool describeStringEnumsInCamelCase,
            AutoRestEnumSupportType? autoRestEnumSupport)
        {
            _jsonSerializerSettings = jsonSerializerSettings;
            _customSchemaMappings = customSchemaMappings;
            _schemaFilters = schemaFilters;
            _modelFilters = modelFilters;
            _schemaIdSelector = schemaIdSelector;
            _ignoreObsoleteProperties = ignoreObsoleteProperties;
            _describeAllEnumsAsStrings = describeAllEnumsAsStrings;
            _describeStringEnumsInCamelCase = describeStringEnumsInCamelCase;
            _autoRestEnumSupport = autoRestEnumSupport;

            _contractResolver = jsonSerializerSettings.ContractResolver ?? new DefaultContractResolver();
            _referencedTypes = new Dictionary<Type, SchemaInfo>();
            Definitions = new Dictionary<string, Schema>();
        }
 static MobileServiceSerializerTests()
 {
     var settings = new JsonSerializerSettings();
     settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
     settings.DateFormatString = "yyyy-MM-dd'T'HH:mm:ss.fff'Z'";
     MinDateTimeSerializedToJson = JsonConvert.SerializeObject(default(DateTime).ToUniversalTime(), settings);
 }
Example #11
0
		public async Task<LoginResult> Login(string username, string password) {
			var json = "";

			if (string.IsNullOrEmpty (username) || string.IsNullOrEmpty (password)) {
				return new LoginResult {
					Successful = false
				};
			}

			using (var client = new HttpClient ()) {
				using (var message = new HttpRequestMessage (HttpMethod.Post, BaseUrl + "/account/login")) {

					var userPass = string.Format("{0}:{1}", username, password);
					var encoded = Convert.ToBase64String(new System.Text.ASCIIEncoding().GetBytes(userPass));
					message.Headers.Add("Authorization", String.Format("Basic {0}", encoded));

					var result = await client.SendAsync(message);
					json = await result.Content.ReadAsStringAsync();
				}
			}

			var settings = new JsonSerializerSettings
			{
				MissingMemberHandling = MissingMemberHandling.Ignore,
				NullValueHandling = NullValueHandling.Ignore
			};
			var loginCredentials = JsonConvert.DeserializeObject<LoginResult>(json, settings);
			return loginCredentials;

		}
Example #12
0
		public override string ToString()
		{
			JsonSerializerSettings settings = new JsonSerializerSettings();
			settings.Formatting = Formatting.Indented;
			settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
			return JsonConvert.SerializeObject(this, settings);
		}
        /// <summary>
        /// Called before an action method executes.
        /// </summary>
        /// <param name="filterContext">The filter context.</param>
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            // Continue normally if the model is valid.
            if (filterContext == null || filterContext.Controller.ViewData.ModelState.IsValid)
            {
                return;
            }

            var serializationSettings = new JsonSerializerSettings
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };

            // Serialize Model State for passing back to AJAX call
            var serializedModelState = JsonConvert.SerializeObject(
              filterContext.Controller.ViewData.ModelState,
              serializationSettings);

            var result = new ContentResult
            {
                Content = serializedModelState,
                ContentType = "application/json"
            };

            filterContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
            filterContext.Result = result;
        }
Example #14
0
 public override string ToString()
 {
     var settings = new JsonSerializerSettings();
     settings.DefaultValueHandling = DefaultValueHandling.Ignore;
     settings.NullValueHandling = NullValueHandling.Ignore;
     return this.ToJson(settings: settings);
 }
        public static new void Install(HttpConfiguration config, IAppBuilder app)
        {
            config.SuppressHostPrincipal();

            SecurityApi.Services.Contracts.IIdentityService identityService = UnityConfiguration.GetContainer().Resolve<SecurityApi.Services.Contracts.IIdentityService>();

            app.UseOAuthAuthorizationServer(new OAuthOptions(identityService));

            app.UseJwtBearerAuthentication(new SecurityApi.Auth.JwtOptions());

            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            app.UseCors(CorsOptions.AllowAll);

            app.MapSignalR();

            var jSettings = new JsonSerializerSettings();

            jSettings.Formatting = Formatting.Indented;

            jSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            config.Formatters.Remove(config.Formatters.XmlFormatter);

            config.Formatters.JsonFormatter.SerializerSettings = jSettings;

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );
        }
Example #16
0
        /// <summary>
        ///   El código es el mismo de ASP.NET MVC 3, cambie el método que escribe en el response
        ///   http://aspnet.codeplex.com/SourceControl/changeset/view/63930#266491
        /// </summary>
        /// <param name = "context"></param>
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (JsonRequestBehavior == JsonRequestBehavior.DenyGet &&
                String.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(
                    "This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet.");
            }

            var response = context.HttpContext.Response;

            if (!String.IsNullOrEmpty(ContentType))
            {
                response.ContentType = ContentType;
            } else
            {
                response.ContentType = "application/json";
            }
            if (ContentEncoding != null)
            {
                response.ContentEncoding = ContentEncoding;
            }
            if (Data != null)
            {
                var settings = new JsonSerializerSettings();
                settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                settings.Converters.Add(new IsoDateTimeConverter());
                response.Write(JsonConvert.SerializeObject(this.Data, Formatting.None, settings));
            }
        }
Example #17
0
 public static void LogFailedMessage(object messageObj)
 {
     if (LogConfig.IsLoggingEnabled)
     {
         try
         {
             //log.SessionId = ApplicationContext.GetSessionId();
             var dataProvider = new LoggingDataProvider();
             var settings = new JsonSerializerSettings()
             {
                 TypeNameHandling = TypeNameHandling.Objects,
             };
             var log = new Log()
             {
                 Name = "FailedMessageItem",
                 ServiceName = messageObj.GetType().Name,
                 Request = JsonConvert.SerializeObject(messageObj, settings),
             };
             if (LogConfig.IsLogAsyncEnabled)
             {
                 Task.Factory.StartNew(() => dataProvider.SaveLog(log));
             }
             else
             {
                 dataProvider.SaveLog(log);
             }
         }
         catch (Exception ex)
         {
             File.AppendAllText("Logs.txt", "LogMessage method failed" + ex.ToString());
         }
     }
 }
Example #18
0
 public static string ToJson( this object val )
 {
     var settings = new JsonSerializerSettings {
         ReferenceLoopHandling = ReferenceLoopHandling.Ignore
     };
     return JsonConvert.SerializeObject( val, Formatting.Indented, settings );
 }
        public string Serialize(object obj)
        {
            var settings = new JsonSerializerSettings();
            settings.ContractResolver = new LowercaseContractResolver();

            return JsonConvert.SerializeObject(obj, settings);
        }
 public JsonNetResult()
 {
     Settings = new JsonSerializerSettings
     {
         ReferenceLoopHandling = ReferenceLoopHandling.Error
     };
 }
        // GET api/Bill
        public object GetBillData(string url)
        {
            JsonResult jsonResult = new JsonResult();
            try
            {
                using (var client = new WebClient())
                {
                    var jsonData = client.DownloadString(url);
                    var jsonSerializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
                    object model;
                    using (GlimpseTimeline.Capture("====> Get bills from Json URL AngularJS"))
                    {
                        model = CacheHandler.Get(homeAngularJSCacheKey, () =>
                        {
                            return JsonConvert.DeserializeObject<BillModel>(jsonData, jsonSerializerSettings);
                        });
                    }

                    jsonResult = new JsonResult
                    {
                        Data = model,
                        JsonRequestBehavior = JsonRequestBehavior.AllowGet

                    };
                }
            }
            catch (Exception ex)
            {
                Elmah.ErrorSignal.FromCurrentContext().Raise(new Exception(ex.Message));
            }

            return jsonResult.Data;
        }
        public static GlobalSettings Load()
        {
            GlobalSettings settings;
            var configFile = Path.Combine(Directory.GetCurrentDirectory(), "Config", "config.json");

            if (File.Exists(configFile))
            {
                //if the file exists, load the settings
                var input = File.ReadAllText(configFile);

                var jsonSettings = new JsonSerializerSettings();
                jsonSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
                jsonSettings.ObjectCreationHandling = ObjectCreationHandling.Replace;
                jsonSettings.DefaultValueHandling = DefaultValueHandling.Populate;

                settings = JsonConvert.DeserializeObject<GlobalSettings>(input, jsonSettings);
            }
            else
            {
                settings = new GlobalSettings();
            }

            var firstRun = !File.Exists(configFile);
            settings.Save(configFile);

            if (firstRun
                || settings.Port == 0
                )
            {
                Log.Error($"Invalid configuration detected. \nPlease edit {configFile} and try again");
                return null;
            }

            return settings;
        }
Example #23
0
        public void Blah2()
        {
            var foo = new Foo
            {
                Name = "Andrew",
                Friends = {
                    new Friend{Name =  "Matt"},
                    new SubFriend
                        {
                            Name =  "Nick",
                            Age = 28
                        },
                    }
            };
            var settings = new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All, ReferenceLoopHandling = ReferenceLoopHandling.Ignore };

            var serializeObject = JsonConvert.SerializeObject(foo, Formatting.Indented, settings);

            var bytes = Encoding.UTF8.GetBytes(serializeObject);

            var result = JsonConvert.DeserializeObject<Foo>(Encoding.UTF8.GetString(bytes), new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Objects });

            Assert.That(result.Friends.Count, Is.EqualTo(2));

            var nick = result.Friends.Single(x => x.Name == "Nick");
            Assert.That(nick, Is.TypeOf<SubFriend>());

            var matt = result.Friends.Single(x => x.Name == "Matt");
            Assert.That(matt, Is.TypeOf<Friend>());
        }
Example #24
0
        public MetaController()
        {
            JsonSerializerSettings jSettings = new Newtonsoft.Json.JsonSerializerSettings();
            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings = jSettings;

            _serializer = new SerializeLibra.JsonSerializer();
        }
Example #25
0
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            if (JsonRequestBehavior == JsonRequestBehavior.DenyGet &&
                string.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
                throw new InvalidOperationException("This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet.");

            var response = context.HttpContext.Response;

            response.ContentType = !string.IsNullOrEmpty(ContentType) ? ContentType : "application/json";

            if (ContentEncoding != null)
                response.ContentEncoding = ContentEncoding;

            if (Data == null) return;

            var jsonSerializerSettings = new JsonSerializerSettings
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            };

            response.Write(JsonConvert.SerializeObject(Data, Formatting.Indented, jsonSerializerSettings));
        }
        public void SaveProject(IProject project, string location)
        {
            this.project = project;

            CreateDirectoryStructure(project.ResourceTree, location);

            settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                Formatting = Formatting.Indented,
            };

            var rootFile = new JsonRootProject();
            rootFile.Version = SpecificVersion;

            ExportSprites(location);
            ExportScripts(location);

            // Export icon
            var icoFileName = Path.Combine(location, "app.ico");
            File.WriteAllBytes(icoFileName, project.Settings.IconData);

            // Write project file
            var rootFileName = Path.Combine(location, "project.json");
            File.WriteAllText(rootFileName, JsonConvert.SerializeObject(rootFile, settings));
        }
Example #27
0
        public static string JsonCamelCase(this object obj)
        {
            var formatter = new JsonSerializerSettings();
            formatter.ContractResolver = new CamelCasePropertyNamesContractResolver();

            return JsonConvert.SerializeObject(obj, formatter);
        }
        public void CanSerializeAndDeserializeAScope()
        {
            var s1 = new Scope
            {
                Name = "email",
                Required = true,
                Type = ScopeType.Identity,
                Emphasize = true,
                DisplayName = "email foo",
                Description = "desc foo",
                Claims = new List<ScopeClaim> {
                    new ScopeClaim{Name = "email", Description = "email"}
                }
            };
            var s2 = new Scope
            {
                Name = "read",
                Required = true,
                Type = ScopeType.Resource,
                Emphasize = true,
                DisplayName = "foo",
                Description = "desc",
            };
            var converter = new ScopeConverter(new InMemoryScopeStore(new Scope[] { s1, s2 }));

            var settings = new JsonSerializerSettings();
            settings.Converters.Add(converter);
            var json = JsonConvert.SerializeObject(s1, settings);

            var result = JsonConvert.DeserializeObject<Scope>(json, settings);
            Assert.Same(s1, result);
        }
 public virtual ActionResult Read([DataSourceRequest]DataSourceRequest request)
 {
     var data = this.GetData();
     var serializationSettings = new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore };
     var json = JsonConvert.SerializeObject(data.ToDataSourceResult(request), Formatting.None, serializationSettings);
     return this.Content(json, "application/json");
 }
Example #30
0
        public override string ToString()
        {
            Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
            //日期类型默认格式化处理
            setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
            //setting.DateFormatString = "yyyy-MM-dd";
            setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";
            //空值处理
            setting.NullValueHandling = NullValueHandling.Ignore;


            string str = JsonConvert.SerializeObject(this, setting);

            return(str);
        }
Example #31
0
        public ContentResult JsonContent(object data, Encoding encoding, JsonRequestBehavior behavior = JsonRequestBehavior.DenyGet)
        {
            Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings();
            settings.ContractResolver = new DefaultContractResolver();  //设置属性输出默认值;

            if (Request.HttpMethod == HttpMethod.Get.Method)
            {
                if (behavior != JsonRequestBehavior.AllowGet)
                {
                    return(Content("不支持的方法", "text/plain", encoding));
                }
            }

            return(Content(JsonConvert.SerializeObject(data, settings), "application/json", encoding));
        }
Example #32
0
        private void CustomizeJsonFormatting()
        {
            var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
            var settings      = new Newtonsoft.Json.JsonSerializerSettings()
            {
                NullValueHandling  = Newtonsoft.Json.NullValueHandling.Ignore,
                DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat
            };

            jsonFormatter.SerializerSettings            = settings;
            jsonFormatter.SerializerSettings.Converters = new List <JsonConverter>()
            {
                new StringEnumConverter()
            };
        }
Example #33
0
        public string ToJSON(object oo)
        {
            Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();

            var iso = new IsoDateTimeConverter();

            iso.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";

            setting.Converters = new List <JsonConverter> {
                new StringEnumConverter(), iso
            };
            setting.Formatting = Formatting.Indented;
            // setting.en
            return(JsonConvert.SerializeObject(oo, setting));
        }
        private JsonSerializer Serializer()
        {
            var Settings = new Newtonsoft.Json.JsonSerializerSettings()
            {
                Formatting = Formatting.Indented,
                Converters = new List <JsonConverter>()
                {
                    new VersionConverter(),
                    new StringEnumConverter(),
                }
            };
            var S = Newtonsoft.Json.JsonSerializer.Create(Settings);

            return(S);
        }
Example #35
0
        public static void SaveJson <T>(T source, string path, IContractResolver contractResolver, JsonConverter converter)
        {
            var settings = new Newtonsoft.Json.JsonSerializerSettings();

            if (contractResolver != null)
            {
                settings.ContractResolver = contractResolver;
            }
            if (converter != null)
            {
                settings.Converters.Add(converter);
            }
            settings.Converters.Add(new StringEnumConverter());
            SaveJson(JsonConvert.SerializeObject(source, Newtonsoft.Json.Formatting.Indented, settings), path);
        }
Example #36
0
        public static void RegisterFormatters(MediaTypeFormatterCollection formatters)
        {
            var json = new JsonMediaTypeFormatter();
            JsonSerializerSettings jSettings = new Newtonsoft.Json.JsonSerializerSettings()
            {
                Formatting           = Formatting.Indented,
                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
            };

            jSettings.Converters.Add(new CustomDateTimeConvertor());
            json.SerializerSettings = jSettings;
            formatters.Insert(0, json);
            // Remove XML formatter because Opera 12 replaces headers from */* to text/html
            formatters.Remove(formatters.XmlFormatter);
        }
 static JT808CoreDotnettyExtensions()
 {
     JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
     {
         Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings();
         //日期类型默认格式化处理
         settings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
         settings.DateFormatString   = "yyyy-MM-dd HH:mm:ss";
         //空值处理
         settings.NullValueHandling     = NullValueHandling.Ignore;
         settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
         settings.Converters.Add(new JsonIPAddressConverter());
         settings.Converters.Add(new JsonIPEndPointConverter());
         return(settings);
     });
 }
 public JsonResult Add(string roleJson)
 {
     if (ModelState.IsValid)
     {
         var s = new Newtonsoft.Json.JsonSerializerSettings();
         s.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
         s.NullValueHandling     = Newtonsoft.Json.NullValueHandling.Ignore;
         Model.RoleInfo role = Newtonsoft.Json.JsonConvert.DeserializeObject <Model.RoleInfo>(roleJson, s);
         _iPrivilegesService.AddPlatformRole(role);
     }
     else
     {
         return(Json(new { success = true, msg = "验证失败" }));
     }
     return(Json(new { success = true }));
 }
Example #39
0
        public ActionResult Edit(long id)
        {
            var shopId = CurrentSellerManager.ShopId;

            SetPrivileges();
            var           model  = _iPrivilegesService.GetSellerRole(id, shopId);
            RoleInfoModel result = new RoleInfoModel()
            {
                ID = model.Id, RoleName = model.RoleName
            };
            var s = new Newtonsoft.Json.JsonSerializerSettings();

            s.ReferenceLoopHandling   = ReferenceLoopHandling.Ignore;
            ViewBag.RolePrivilegeInfo = Newtonsoft.Json.JsonConvert.SerializeObject(model.RolePrivilegeInfo.Select(item => new { Privilege = item.Privilege }), s);
            return(View(result));
        }
Example #40
0
        static JsonHelper()
        {
            DefaultSetting = new JsonSerializerSettings()
            {
                DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat,
                NullValueHandling  = NullValueHandling.Ignore,
            };
            DefaultSetting.Converters.Add(new StringEnumConverter());

            //全局序列化设置
            Newtonsoft.Json.JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
            {
                var setting = JsonHelper.DefaultSetting;
                return(setting);
            });
        }
Example #41
0
        private string ConvertToProperJSON(Object value)
        {
            DefaultContractResolver contractResolver = new DefaultContractResolver
            {
                NamingStrategy = new CamelCaseNamingStrategy()
            };

            var settings = new Newtonsoft.Json.JsonSerializerSettings
            {
                ContractResolver      = contractResolver,
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                Formatting            = Formatting.Indented,
            };

            return(JsonConvert.SerializeObject(value, settings));
        }
Example #42
0
        public void PackageSerializationTest()
        {
            // arrange
            var settings = new Newtonsoft.Json.JsonSerializerSettings();

            settings.Converters.Add(new StorageConverter());

            // act
            var serialized   = Newtonsoft.Json.JsonConvert.SerializeObject(Package);
            var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <DownloadPackage>(serialized, settings);

            // assert
            PackagesAreEqual(Package, deserialized);

            Package.Clear();
        }
Example #43
0
        protected void Application_Start(object sender, EventArgs e)
        {
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AutoMapperConfiguration.Configure();
            //fix bug serialize for web API
            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
            GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

            JsonSerializerSettings jSettings = new Newtonsoft.Json.JsonSerializerSettings();

            jSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings = jSettings;
        }
        SpotCharter IEventSourceCommandRepository <SpotCharter, SpotCharterId> .Get(SpotCharterId id)
        {
            var settings = new Newtonsoft.Json.JsonSerializerSettings()
            {
                ContractResolver = new JsonNet.PrivateSettersContractResolvers.PrivateSetterContractResolver()
            };

            if (!this.repository.ContainsKey(id))
            {
                return(null);
            }

            var eventStream = this.repository[id];

            return(new SpotCharter(eventStream.Select(json => JsonConvert.DeserializeObject(json.JsonString, json.Type, settings) as IEvent <SpotCharterId>).ToArray()));
        }
Example #45
0
        /// <summary>
        /// 输到前端网页使用时要注册 camelCase/longToStr 参数
        /// </summary>
        /// <param name="data"></param>
        /// <param name="camelCase"> 名称 驼峰结构输出</param>
        /// <param name="longToStr">long转成字串(javascript 超过15长度会有精度问题)</param>
        /// <returns></returns>
        public static string SerializeObject(object data, bool camelCase = false, bool longToStr = false)
        {
            var setting = new Newtonsoft.Json.JsonSerializerSettings();

            if (longToStr)
            {
                setting.Converters.Add(new HexLongConverter());
            }
            if (camelCase)
            {
                setting.ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver();
            }
            setting.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;

            return(JsonConvert.SerializeObject(data, setting));
        }
Example #46
0
        public static string ToJson(this object obj)
        {
            Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
            JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
            {
                //日期类型默认格式化处理
                setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
                setting.DateFormatString   = "yyyy-MM-dd HH:mm:ss";

                //空值处理
                setting.NullValueHandling = NullValueHandling.Ignore;
                //setting.FloatParseHandling = FloatParseHandling.Decimal;
                return(setting);
            });
            return(JsonConvert.SerializeObject(obj, Formatting.None, setting));//Formatting.Indented缩进排版
        }
Example #47
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            var setting = new Newtonsoft.Json.JsonSerializerSettings();

            JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
            {
                // 日期类型默认格式化处理
                setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";
                return(setting);
            });
        }
        public SpeckleApiClient(string baseUrl, bool isPersistent = false) : base()
        {
            _settings = new System.Lazy <Newtonsoft.Json.JsonSerializerSettings>(() =>
            {
                var settings = new Newtonsoft.Json.JsonSerializerSettings();
                UpdateJsonSerializerSettings(settings);
                return(settings);
            });

            UseGzip = true;

            BaseUrl      = baseUrl;
            IsPersistent = isPersistent;

            SetReadyTimer();
        }
Example #49
0
        public async Task <IList <Country> > GetAll()
        {
            var key = "all_country";

            try
            {
                if (!Barrel.Current.IsExpired(key))
                {
                    return(Barrel.Current.Get <List <Country> >(key));
                }

                var response = await Constants.BASE_URL
                               .AppendPathSegment(@"/countries")
                               .SetQueryParam("sort", new[] { "country" })
                               .WithTimeout(30)
                               .GetAsync();

                if (response.IsSuccessStatusCode)
                {
                    var content = await response.Content.ReadAsStringAsync();

                    var setting = new Newtonsoft.Json.JsonSerializerSettings();
                    JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
                    {
                        setting.NullValueHandling  = Newtonsoft.Json.NullValueHandling.Ignore;
                        setting.FloatParseHandling = FloatParseHandling.Decimal;
                        return(setting);
                    });


                    var all = JsonConvert.DeserializeObject <List <Country> >(content);

                    if (all != null)
                    {
                        Barrel.Current.Add(key: key, data: all, expireIn: TimeSpan.FromHours(1));
                    }

                    return(all);
                }
            }
            catch (Exception ex)
            {
                return(null);
            }

            return(null);
        }
Example #50
0
        public override void RegisterBuilder(ConfigurationContext context)
        {
            var apiConfig = AppConfig.Options.ApiGetWay;

            if (apiConfig != null)
            {
                ApiGateWay.AppConfig.AuthenticationServiceKey = apiConfig.AuthenticationServiceKey;
                ApiGateWay.AppConfig.AuthorizationServiceKey  = apiConfig.AuthorizationServiceKey;
                ApiGateWay.AppConfig.AuthorizationRoutePath   = apiConfig.AuthorizationRoutePath;
                ApiGateWay.AppConfig.AuthenticationRoutePath  = apiConfig.AuthenticationRoutePath;
                ApiGateWay.AppConfig.TokenEndpointPath        = apiConfig.TokenEndpointPath;
                ApiGateWay.AppConfig.IsUsingTerminal          = apiConfig.IsUsingTerminal;
                ApiGateWay.AppConfig.Terminals      = apiConfig.Terminals;
                ApiGateWay.AppConfig.JwtSecret      = apiConfig.JwtSecret;
                ApiGateWay.AppConfig.DefaultExpired = apiConfig.DefaultExpired;
            }
            context.Services.AddMvc().AddJsonOptions(options => {
                options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
                if (AppConfig.Options.IsCamelCaseResolver)
                {
                    JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
                    {
                        JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
                        setting.DateFormatString       = "yyyy-MM-dd HH:mm:ss";
                        setting.ContractResolver       = new CamelCasePropertyNamesContractResolver();
                        return(setting);
                    });
                    options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                }
                else
                {
                    JsonConvert.DefaultSettings = new Func <JsonSerializerSettings>(() =>
                    {
                        JsonSerializerSettings setting = new JsonSerializerSettings();
                        setting.DateFormatString       = "yyyy-MM-dd HH:mm:ss";
                        setting.ContractResolver       = new DefaultContractResolver();
                        return(setting);
                    });
                    options.SerializerSettings.ContractResolver = new DefaultContractResolver();
                }
            });
            context.Services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            context.Services.AddSingleton <IIPChecker, IPAddressChecker>();
            context.Services.AddFilters(typeof(AuthorizationFilterAttribute));
            context.Services.AddFilters(typeof(ActionFilterAttribute));
            context.Services.AddFilters(typeof(IPFilterAttribute));
        }
Example #51
0
        /// <summary>
        /// Configura el tipo de respuesta como JSON
        /// </summary>
        /// <param name="config"></param>
        public static void configureJSONResponse(HttpConfiguration config)
        {
            config.Formatters.Add(new JsonMediaTypeFormatter());

            //Sets default JSON response format
            JsonSerializerSettings jSettings = new Newtonsoft.Json.JsonSerializerSettings()
            {
                Formatting       = WebConfigurationManager.AppSettings["entorno"] == "Desarrollo" ? Formatting.Indented : Formatting.None,
                DateFormatString = "dd-MM-yyyy HH:mm:ss",

                //Evitamos referencias cíclicas al serializar a JSON
                PreserveReferencesHandling = PreserveReferencesHandling.None,
                ReferenceLoopHandling      = ReferenceLoopHandling.Ignore
            };

            config.Formatters.JsonFormatter.SerializerSettings = jSettings;
        }
 private void SetSerialisationSettings()
 {
     _settings = new System.Lazy <Newtonsoft.Json.JsonSerializerSettings>(() =>
     {
         var settings = new Newtonsoft.Json.JsonSerializerSettings()
         {
             ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver()
             {
                 NamingStrategy = new Newtonsoft.Json.Serialization.CamelCaseNamingStrategy()
             },
             ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
             NullValueHandling     = NullValueHandling.Ignore
         };
         UpdateJsonSerializerSettings(settings);
         return(settings);
     });
 }
Example #53
0
        public bool TrySerializeObjectToString(Object value, out string serValue)
        {
            Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings();

            const Formatting formatting = Newtonsoft.Json.Formatting.None;

            try
            {
                serValue = JsonConvert.SerializeObject(value, formatting, getSettings());
                return(true);
            }
            catch (Exception)
            {
                serValue = null;
                return(false);
            }
        }
Example #54
0
        public static void Register(HttpConfiguration httpConfiguration)
        {
            // Web API configuration and services

            // Web API routes
            httpConfiguration.MapHttpAttributeRoutes();

            httpConfiguration.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            httpConfiguration.Services.Add(typeof(IExceptionLogger), new NLogExceptionLogger());
            httpConfiguration.Services.Add(typeof(IExceptionLogger), new ElmahExceptionLogger());
            httpConfiguration.Services.Replace(typeof(IExceptionHandler), new ApiExceptionHandler());

            //httpConfiguration.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
            //    new CamelCasePropertyNamesContractResolver();

            // WebApi formatters
            var formatters = httpConfiguration.Formatters;

            formatters.Remove(formatters.XmlFormatter);


            // Set json formatters
            var jsonFormatter = formatters.JsonFormatter;
            var jsonSettings  = new Newtonsoft.Json.JsonSerializerSettings()
            {
                Formatting            = Formatting.Indented,                          // Nice for debugging I think, looks pretty
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,                 // Fix JSON.NET self referencing hell
                ContractResolver      = new CamelCasePropertyNamesContractResolver(), // automatic camelCasing
                Culture = new CultureInfo("fr-BE")
            };

            // add a custom date formatter to override Datetime format settings
            //jsonSettings.Converters.Add(new MyDateFormatConverter());

            // Finally set new settings to global config
            jsonFormatter.SerializerSettings = jsonSettings;

            //httpConfiguration.Formatters.JsonFormatter.SerializerSettings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat;
            //httpConfiguration.Formatters.JsonFormatter.SerializerSettings.Culture = new CultureInfo("fr-FR");
            //httpConfiguration.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new MyDateFormatConverter());
        }
Example #55
0
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context is null");
            }

            if (context.RequestContext.HttpContext.Request.HttpMethod == HttpMethod.Get.Method && this.JsonRequestBehavior == JsonRequestBehavior.DenyGet)
            {
                throw new NotSupportedException("不支持get请求");
            }

            HttpResponseBase httpResponseBase = context.RequestContext.HttpContext.Response;

            if (string.IsNullOrEmpty(this.ContentType))
            {
                httpResponseBase.ContentType = "application/json";
            }
            else
            {
                httpResponseBase.ContentType = this.ContentType;
            }

            if (ContentEncoding == null)
            {
                httpResponseBase.ContentEncoding = Encoding.UTF8;
            }
            else
            {
                httpResponseBase.ContentEncoding = this.ContentEncoding;
            }

            if (string.IsNullOrEmpty(this.DateFormatString))
            {
                this.DateFormatString = "yyyy-MM-dd";
            }

            if (Data != null)
            {
                Newtonsoft.Json.JsonSerializerSettings serializerSettings = new Newtonsoft.Json.JsonSerializerSettings();
                serializerSettings.DateFormatString      = this.DateFormatString;
                serializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
                serializerSettings.ContractResolver      = new DefaultContractResolver();
                httpResponseBase.Write(JsonConvert.SerializeObject(new { code = this.Code, msg = this.Msg, data = this.Data }, serializerSettings));
            }
        }
Example #56
0
        /// <summary> Initialization function for this storage provider. </summary>
        /// <see cref="IProvider#Init"/>
        public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
        {
            Name      = name;
            serviceId = providerRuntime.ServiceId.ToString();

            if (!config.Properties.ContainsKey(CONNECTION_STRING) ||
                string.IsNullOrWhiteSpace(config.Properties[CONNECTION_STRING]))
            {
                throw new ArgumentException("Specify a value for:", CONNECTION_STRING);
            }
            var connectionString = config.Properties[CONNECTION_STRING];

            sqlconnBuilder = new SqlConnectionStringBuilder(connectionString);

            //a validation of the connection would be wise to perform here
            //await new SqlConnection(sqlconnBuilder.ConnectionString).OpenAsync();

            //initialize to use the default of JSON storage (this is to provide backwards compatiblity with previous version
            useJsonOrBinaryFormat = StorageFormatEnum.Binary;

            if (config.Properties.ContainsKey(USE_JSON_FORMAT_PROPERTY))
            {
                if ("true".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase))
                {
                    useJsonOrBinaryFormat = StorageFormatEnum.Json;
                }

                if ("both".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase))
                {
                    useJsonOrBinaryFormat = StorageFormatEnum.Both;
                }
            }

            jsonSettings = new Newtonsoft.Json.JsonSerializerSettings()
            {
                TypeNameHandling           = TypeNameHandling.All,
                PreserveReferencesHandling = PreserveReferencesHandling.Objects,
                DateFormatHandling         = DateFormatHandling.IsoDateFormat,
                DefaultValueHandling       = DefaultValueHandling.Ignore,
                MissingMemberHandling      = MissingMemberHandling.Ignore,
                NullValueHandling          = NullValueHandling.Ignore,
                ConstructorHandling        = ConstructorHandling.AllowNonPublicDefaultConstructor
            };

            Log = providerRuntime.GetLogger("StorageProvider.SimpleSQLServerStorage." + serviceId);
        }
Example #57
0
 public LndSwaggerClient(LndRestSettings settings)
 {
     if (settings == null)
     {
         throw new ArgumentNullException(nameof(settings));
     }
     _LndSettings    = settings;
     _Authentication = settings.CreateLndAuthentication();
     BaseUrl         = settings.Uri.AbsoluteUri.TrimEnd('/');
     _httpClient     = CreateHttpClient(settings);
     _settings       = new System.Lazy <Newtonsoft.Json.JsonSerializerSettings>(() =>
     {
         var json = new Newtonsoft.Json.JsonSerializerSettings();
         UpdateJsonSerializerSettings(json);
         return(json);
     });
 }
Example #58
0
        protected void Application_Start()
        {
            //Override the default json serializer settings
            var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
            var jSettings     = new Newtonsoft.Json.JsonSerializerSettings()
            {
                DefaultValueHandling = DefaultValueHandling.Include
            };

            jsonFormatter.SerializerSettings = jSettings;

            AreaRegistration.RegisterAllAreas();

            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }
Example #59
0
        /// <summary> Initialization function for this storage provider. </summary>
        /// <see cref="IProvider#Init"/>
        public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
        {
            serviceId = providerRuntime.ServiceId.ToString();
            Log       = providerRuntime.GetLogger("StorageProvider.SimpleSQLServerStorage." + serviceId);

            try
            {
                Name = name;
                this.jsonSettings = SerializationManager.UpdateSerializerSettings(SerializationManager.GetDefaultJsonSerializerSettings(), config);

                if (!config.Properties.ContainsKey(CONNECTION_STRING) || string.IsNullOrWhiteSpace(config.Properties[CONNECTION_STRING]))
                {
                    throw new BadProviderConfigException($"Specify a value for: {CONNECTION_STRING}");
                }
                var connectionString = config.Properties[CONNECTION_STRING];
                sqlconnBuilder = new SqlConnectionStringBuilder(connectionString);

                //a validation of the connection would be wise to perform here
                var sqlCon = new SqlConnection(sqlconnBuilder.ConnectionString);
                await sqlCon.OpenAsync();

                sqlCon.Close();

                //initialize to use the default of JSON storage (this is to provide backwards compatiblity with previous version
                useJsonOrBinaryFormat = StorageFormatEnum.Binary;

                if (config.Properties.ContainsKey(USE_JSON_FORMAT_PROPERTY))
                {
                    if ("true".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase))
                    {
                        useJsonOrBinaryFormat = StorageFormatEnum.Json;
                    }

                    if ("both".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase))
                    {
                        useJsonOrBinaryFormat = StorageFormatEnum.Both;
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error((int)SimpleSQLServerProviderErrorCodes.SimpleSQLServerProvider_InitProvider, ex.ToString(), ex);
                throw;
            }
        }
        /// <summary>
        /// default constructor
        /// </summary>
        public CustomJsonConverter(JsonSerializerSettings settings)
        {
            if (settings == null)
                throw new ArgumentNullException("settings");

            JsonSerializerSettings = settings;
        }