I try to filter a geojson layer on leaflet using checkboxes. My layer is correctly displayed, but when I click on the boxes, nothing happens. I have a correct url in the flask server which shows me that the request is taken into account. I use data back from Postgresql. How can I display this filtered information on my map? I think it's from my python code but I can't figure how to do it.
JS code :
function refreshroutesfermees(whr) {
if (whr) {
var objData = {tbl:'routes_fermees_adn', flds:"id, cpx_numero, cpx_gestio, fermeture, dep", where:whr};
} else {
var objData = {tbl:'routes_fermees_adn', flds:"id, cpx_numero, cpx_gestio, fermeture, dep"};
}
$.ajax({
url: '/routes_fermees', ///retrieve my data from app.py
data: objData,
type: 'POST',
success: function (response) {
if (response=="ERROR"){
alert (response);
} else {
arProjectIDs=[];
if (lyrroutesfermees) {
ctlLayers.removeLayer(lyrroutesfermees);
lyrroutesfermees.remove();
}
lyrroutesfermees = L.geoJSON(response,
{style:styleroutesfermees, onEachFeature:processroutesfermees});
ctlLayers.addOverlay(lyrroutesfermees, "routes fermées");
arProjectIDs.sort(function(a,b){return a-b});
}
},
error: function (xhr, status, error) {
alert("ERROR: " + error);
}
});
}
HTML checkboxes :
$("#btnFilterroutesfermees").click(function(){
var arTypes=[];
var cntChecks=0;
$("input[name=fltferme]").each(function(){
if (this.checked) {
if(this.value=='ferm 38'){
arTypes.push("'38'");
cntChecks++;
}
if(this.value=='ferm 73'){
arTypes.push("'73'");
cntChecks++;
}
if(this.value=='ferm 74'){
arTypes.push("'74'");
cntChecks++;
}
}
});
// alert(cntChecks);
if (cntChecks==0) {
refreshroutesfermees("1=2");
} else if (cntChecks==3){ ////le nombre de checkbox
refreshroutesfermees();
} else {
// alert("type IN ("+arTypes.toString()+")");
refreshroutesfermees("dep IN ("+arTypes.toString()+")");
}
});
Part of the app.py
#app.route('/routes_fermees', methods=["POST", "GET"])
def routes_fermees():
cur = con.cursor()
cur.execute("""
select json_build_object(
'type', 'FeatureCollection',
'features', json_agg(ST_AsGeoJSON(routes_fermees_adn.*)::json)
) as geojson
from routes_fermees_adn
""")
return cur.fetchone()[0]
The link created from flask
GET /routes_fermees?tbl=routes_fermees_adn&flds=id%2C%20cpx_numero%2C%20cpx_gestio%2C%20fermeture%2C%20dep
It seems that you only add the new layer to L.LayerControl, but not the map itself. From Leaflet's documentation:
addOverlay: Adds an overlay (checkbox entry) with the given name to the control.
Try adding .addTo(map) after the L.geoJSON call, where map is your Leaflet map instance. Like this:
lyrroutesfermees = L.geoJSON(response, {
style: styleroutesfermees,
onEachFeature: processroutesfermees
}).addTo(map); // <- Adds the geoJSON features to the map.
Let me know if that works!
Check the two part of code bellow. There is two method second one is python method which make a post request to a url but i want to do same api call with same payload with c# restsharp. I already tried to convert code like bellow but since i don't have idea about python i am not able to understand how can i add payload as its done in python code. I already tried to add this payload using request.AddBody but it is not same as it was done in python code. How can i add those payload info with restsharp request exactly as done in py? please advice
payload:
data={
"locationType": "LOCATION_INPUT",
"zipCode": zip_code,
"storeContext": "generic",
"deviceType": "web",
"pageType": "Gateway",
"actionSource": "glow",
"almBrandId": "undefined",
}
C#
public static IRestResponse MakeApiCall(string zip_code)
{
var client = new RestClient("https://www.example.com");
var request = new RestRequest(Method.POST);
//request.AddHeader();//i can add header like this thats not a problem
//request.AddCookie();//i can add cookie like this thats not a problem
request.AddBody("data=", #"{" +
"locationType\": \"LOCATION_INPUT",
"zipCode\": zip_code,
"storeContext\": \"generic",
"deviceType\": \"web",
"pageType\": \"Gateway",
"actionSource\": \"glow",
"almBrandId\": \"undefined");
var result = client.Execute(request);
return result;
}
Python:
def MakeApiCall(zip_code: str, headers: dict, cookies: dict):
response = requests.post(
url="https://www.example.com",
data={
"locationType": "LOCATION_INPUT",
"zipCode": zip_code,
"storeContext": "generic",
"deviceType": "web",
"pageType": "Gateway",
"actionSource": "glow",
"almBrandId": "undefined",
},
headers=headers,
cookies=cookies,
)
assert response.json()["isValidAddress"], "Invalid change response"
return response.cookies
If I understood your question correctly, you are trying to convert the method from python into a C# method. I am assuming that you are using .NET Core and the RestSharp library, if not you need to clarify what you are using in your original post.
In your class instantiate the RestClient class in a constructor
public class RandomClass
{
private readonly IRestClient _client;
public RandomClass(){
_client = new RestClient("baseUrl");
_client.UseSerializer(
() => new JsonSerializer { DateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ" }
);
}
}
Now, define a class for your request data:
public class Location {
public string LocationType {get; set;}
public string ZipCode {get; set;}
public string StoreContext {get; set; }
public string DeviceType {get; set;}
public string ActionSource {get; set;}
public string BrandId {get; set;}
}
In your MakeApiCall method:
public IRestResponse MakeApiCall(Location data){
var request = _client.Request("/endpoint/relative/to/baseUrl", Method.POST);
var jsonToSend = JsonSerializer.Serialize(data);
request.AddParameter(
"application/json; charset=utf-8",
jsonToSend,
ParameterType.RequestBody
);
var response = _client.Execute(request);
if (response.ErrorException != null)
{
const string message = "Error retrieving response.";
throw new Exception(message, response.ErrorException);
}
// if we get to here then the request succeeded
return response.data;
}
I haven't tested it, but nonetheless it should point you in the right direction.
There are two ways to go about it.
Use a strongly typed data structure
Create a dynamic object and use that as your data object.
Create a class to store your data object
class MyDataType
{
[JsonProperty("locationType")]
public string LocationType { get; set; }
[JsonProperty("zipCode")]
public string ZipCode { get; set; }
//...
}
// and in your method, you would use the above datatype like this,
var data = new MyDataType
{
LocationType = "location",
ZipCode = "zipCode"
// ...
};
or 2. Create a dynamic / anonymous object and use that as json body.
var data = new
{
locationType = "location",
zipCode = "zipCode",
storeContext = "generic",
deviceType = "web",
pageType = "Gateway",
actionSource = "glow",
almBrandId = "undefined",
};
Once you have your object, I would recommend using AddJsonBody as AddBody is deprecated.
var client = new RestClient("https://www.example.com");
var request = new RestRequest(Method.POST);
request.AddHeader(#"Content-Type", #"application/json");
request.AddHeader(#"Accept", #"application/json");
request.AddJsonBody(data);
var result = client.Execute(request);
string actualData = result.Content;
result.Content would have your response. You can use Newtonsoft Json to convert data in your response to a class object and validate your data that way.
I have a reactjs class called MyDictionary that renders data that a python file sends in. This class returns a dictionary structure. I want to access only a couple of elements from MyDictionary via a separate class, and a different set of elements also from MyDictionary, via a separate class. I tried React.createElement(SomeOtherClass, { as shown below, but this doesn't work... what am I missing?
class MyDictionary extends React.Component {
render() {
return this.props.results.map((result, index) =>
React.createElement(
"div",
{ className: "col-sm-12" },
React.createElement(SomeOtherClass, {
key: result.id,
name: result.name,
index: result.index,
activity: this.props.index + 1,
images: this.props.image_labels
})
)
);
}
}
return MyDictionary;
Looks like your this operator inside the callback function is not what you expect.
The easiest way to resolve this is to create a var to this before your map call.
var _this = this;
Then use _this instead of this inside your callback.
You should also read up on javascript closures.
Edit: render() should return one root element.
class MyDictionary extends React.Component {
render() {
var _this = this;
var children = this.props.results.map((result, index) =>
React.createElement(
"div",
{ className: "col-sm-12" },
React.createElement(SomeOtherClass, {
key: result.id,
name: result.name,
index: result.index,
activity: _this.props.index + 1, // using _this
images: _this.props.image_labels // using _this
})
)
);
return React.createElement("div", null, children);
}
}
return MyDictionary;
Given a string of JSON data, how can I safely turn that string into a JavaScript object?
Obviously I can do this unsafely with something like:
var obj = eval("(" + json + ')');
but that leaves me vulnerable to the JSON string containing other code, which it seems very dangerous to simply eval.
JSON.parse(jsonString) is a pure JavaScript approach so long as you can guarantee a reasonably modern browser.
The jQuery method is now deprecated. Use this method instead:
let jsonObject = JSON.parse(jsonString);
Original answer using deprecated jQuery functionality:
If you're using jQuery just use:
jQuery.parseJSON( jsonString );
It's exactly what you're looking for (see the jQuery documentation).
This answer is for IE < 7, for modern browsers check Jonathan's answer above.
This answer is outdated and Jonathan's answer above (JSON.parse(jsonString)) is now the best answer.
JSON.org has JSON parsers for many languages including four different ones for JavaScript. I believe most people would consider json2.js their goto implementation.
Use the simple code example in "JSON.parse()":
var jsontext = '{"firstname":"Jesper","surname":"Aaberg","phone":["555-0100","555-0120"]}';
var contact = JSON.parse(jsontext);
and reversing it:
var str = JSON.stringify(arr);
This seems to be the issue:
An input that is received via Ajax websocket etc, and it will be in String format, but you need to know if it is JSON.parsable. The touble is, if you always run it through JSON.parse, the program MAY continue "successfully" but you'll still see an error thrown in the console with the dreaded "Error: unexpected token 'x'".
var data;
try {
data = JSON.parse(jqxhr.responseText);
} catch (_error) {}
data || (data = {
message: 'Server error, please retry'
});
I'm not sure about other ways to do it but here's how you do it in Prototype (JSON tutorial).
new Ajax.Request('/some_url', {
method:'get',
requestHeaders: {Accept: 'application/json'},
onSuccess: function(transport){
var json = transport.responseText.evalJSON(true);
}
});
Calling evalJSON() with true as the argument sanitizes the incoming string.
If you're using jQuery, you can also use:
$.getJSON(url, function(data) { });
Then you can do things like
data.key1.something
data.key1.something_else
etc.
Just for fun, here is a way using a function:
jsonObject = (new Function('return ' + jsonFormatData))()
$.ajax({
url: url,
dataType: 'json',
data: data,
success: callback
});
The callback is passed the returned data, which will be a JavaScript object or array as defined by the JSON structure and parsed using the $.parseJSON() method.
Using JSON.parse is probably the best way.
Here's an example
var jsonRes = '{ "students" : [' +
'{ "firstName":"Michel" , "lastName":"John" ,"age":18},' +
'{ "firstName":"Richard" , "lastName":"Joe","age":20 },' +
'{ "firstName":"James" , "lastName":"Henry","age":15 } ]}';
var studentObject = JSON.parse(jsonRes);
The easiest way using parse() method:
var response = '{"result":true,"count":1}';
var JsonObject= JSON.parse(response);
Then you can get the values of the JSON elements, for example:
var myResponseResult = JsonObject.result;
var myResponseCount = JsonObject.count;
Using jQuery as described in the jQuery.parseJSON() documentation:
JSON.parse(jsonString);
Try using the method with this Data object. ex:Data='{result:true,count:1}'
try {
eval('var obj=' + Data);
console.log(obj.count);
}
catch(e) {
console.log(e.message);
}
This method really helps in Nodejs when you are working with serial port programming
I found a "better" way:
In CoffeeScript:
try data = JSON.parse(jqxhr.responseText)
data ||= { message: 'Server error, please retry' }
In Javascript:
var data;
try {
data = JSON.parse(jqxhr.responseText);
} catch (_error) {}
data || (data = {
message: 'Server error, please retry'
});
JSON parsing is always a pain. If the input is not as expected it throws an error and crashes what you are doing.
You can use the following tiny function to safely parse your input. It always turns an object even if the input is not valid or is already an object which is better for most cases:
JSON.safeParse = function (input, def) {
// Convert null to empty object
if (!input) {
return def || {};
} else if (Object.prototype.toString.call(input) === '[object Object]') {
return input;
}
try {
return JSON.parse(input);
} catch (e) {
return def || {};
}
};
Parse the JSON string with JSON.parse(), and the data becomes a JavaScript object:
JSON.parse(jsonString)
Here, JSON represents to process JSON dataset.
Imagine we received this text from a web server:
'{ "name":"John", "age":30, "city":"New York"}'
To parse into a JSON object:
var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}');
Here obj is the respective JSON object which looks like:
{ "name":"John", "age":30, "city":"New York"}
To fetch a value use the . operator:
obj.name // John
obj.age //30
Convert a JavaScript object into a string with JSON.stringify().
JSON.parse(jsonString);
json.parse will change into object.
JSON.parse() converts any JSON string passed into the function into a JSON object.
To understand it better, press F12 to open "Inspect Element" in your browser and go to the console to write the following commands:
var response = '{"result":true,"count":1}'; //sample json object(string form)
JSON.parse(response); //converts passed string to JSON Object.
Now run the command:
console.log(JSON.parse(response));
You'll get output as an Object {result: true, count: 1}.
In order to use that Object, you can assign it to the variable, maybe obj:
var obj = JSON.parse(response);
By using obj and the dot (.) operator you can access properties of the JSON object.
Try to run the command:
console.log(obj.result);
Official documentation:
The JSON.parse() method parses a JSON string, constructing the JavaScript value or object described by the string. An optional reviver function can be provided to perform a transformation on the resulting object before it is returned.
Syntax:
JSON.parse(text[, reviver])
Parameters:
text
: The string to parse as JSON. See the JSON object for a description of JSON syntax.
reviver (optional)
: If a function, this prescribes how the value originally produced by parsing is transformed, before being returned.
Return value
The Object corresponding to the given JSON text.
Exceptions
Throws a SyntaxError exception if the string to parse is not valid JSON.
If we have a string like this:
"{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"
then we can simply use JSON.parse twice to convert this string to a JSON object:
var sampleString = "{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"
var jsonString= JSON.parse(sampleString)
var jsonObject= JSON.parse(jsonString)
And we can extract values from the JSON object using:
// instead of last JSON.parse:
var { status, token } = JSON.parse(jsonString);
The result will be:
status = 1 and token = 65b4352b2dfc4957a09add0ce5714059
Performance
There are already good answer for this question, but I was curious about performance and today 2020.09.21 I conduct tests on MacOs HighSierra 10.13.6 on Chrome v85, Safari v13.1.2 and Firefox v80 for chosen solutions.
Results
eval/Function (A,B,C) approach is fast on Chrome (but for big-deep object N=1000 they crash: "maximum stack call exceed)
eval (A) is fast/medium fast on all browsers
JSON.parse (D,E) are fastest on Safari and Firefox
Details
I perform 4 tests cases:
for small shallow object HERE
for small deep object HERE
for big shallow object HERE
for big deep object HERE
Object used in above tests came from HERE
let obj_ShallowSmall = {
field0: false,
field1: true,
field2: 1,
field3: 0,
field4: null,
field5: [],
field6: {},
field7: "text7",
field8: "text8",
}
let obj_DeepSmall = {
level0: {
level1: {
level2: {
level3: {
level4: {
level5: {
level6: {
level7: {
level8: {
level9: [[[[[[[[[['abc']]]]]]]]]],
}}}}}}}}},
};
let obj_ShallowBig = Array(1000).fill(0).reduce((a,c,i) => (a['field'+i]=getField(i),a) ,{});
let obj_DeepBig = genDeepObject(1000);
// ------------------
// Show objects
// ------------------
console.log('obj_ShallowSmall:',JSON.stringify(obj_ShallowSmall));
console.log('obj_DeepSmall:',JSON.stringify(obj_DeepSmall));
console.log('obj_ShallowBig:',JSON.stringify(obj_ShallowBig));
console.log('obj_DeepBig:',JSON.stringify(obj_DeepBig));
// ------------------
// HELPERS
// ------------------
function getField(k) {
let i=k%10;
if(i==0) return false;
if(i==1) return true;
if(i==2) return k;
if(i==3) return 0;
if(i==4) return null;
if(i==5) return [];
if(i==6) return {};
if(i>=7) return "text"+k;
}
function genDeepObject(N) {
// generate: {level0:{level1:{...levelN: {end:[[[...N-times...['abc']...]]] }}}...}}}
let obj={};
let o=obj;
let arr = [];
let a=arr;
for(let i=0; i<N; i++) {
o['level'+i]={};
o=o['level'+i];
let aa=[];
a.push(aa);
a=aa;
}
a[0]='abc';
o['end']=arr;
return obj;
}
Below snippet presents chosen solutions
// src: https://stackoverflow.com/q/45015/860099
function A(json) {
return eval("(" + json + ')');
}
// https://stackoverflow.com/a/26377600/860099
function B(json) {
return (new Function('return ('+json+')'))()
}
// improved https://stackoverflow.com/a/26377600/860099
function C(json) {
return Function('return ('+json+')')()
}
// src: https://stackoverflow.com/a/5686237/860099
function D(json) {
return JSON.parse(json);
}
// src: https://stackoverflow.com/a/233630/860099
function E(json) {
return $.parseJSON(json)
}
// --------------------
// TEST
// --------------------
let json = '{"a":"abc","b":"123","d":[1,2,3],"e":{"a":1,"b":2,"c":3}}';
[A,B,C,D,E].map(f=> {
console.log(
f.name + ' ' + JSON.stringify(f(json))
)})
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
This shippet only presents functions used in performance tests - it not perform tests itself!
And here are example results for chrome
Converting the object to JSON, and then parsing it, works for me, like:
JSON.parse(JSON.stringify(object))
The recommended approach to parse JSON in JavaScript is to use JSON.parse()
Background
The JSON API was introduced with ECMAScript 5 and has since been implemented in >99% of browsers by market share.
jQuery once had a $.parseJSON() function, but it was deprecated with jQuery 3.0. In any case, for a long time, it was nothing more than a wrapper around JSON.parse().
Example
const json = '{ "city": "Boston", "population": 500000 }';
const object = JSON.parse(json);
console.log(object.city, object.population);
Browser Compatibility
Is JSON.parse supported by all major browsers?
Pretty much, yes (see reference).
Older question, I know, however nobody notice this solution by using new Function(), an anonymous function that returns the data.
Just an example:
var oData = 'test1:"This is my object",test2:"This is my object"';
if( typeof oData !== 'object' )
try {
oData = (new Function('return {'+oData+'};'))();
}
catch(e) { oData=false; }
if( typeof oData !== 'object' )
{ alert( 'Error in code' ); }
else {
alert( oData.test1 );
alert( oData.test2 );
}
This is a little more safe because it executes inside a function and do not compile in your code directly. So if there is a function declaration inside it, it will not be bound to the default window object.
I use this to 'compile' configuration settings of DOM elements (for example the data attribute) simple and fast.
Summary:
Javascript (both browser and NodeJS) have a built in JSON object. On this Object are 2 convenient methods for dealing with JSON. They are the following:
JSON.parse() Takes JSON as argument, returns JS object
JSON.stringify() Takes JS object as argument returns JSON object
Other applications:
Besides for very conveniently dealing with JSON they have can be used for other means. The combination of both JSON methods allows us to make very easy make deep clones of arrays or objects. For example:
let arr1 = [1, 2, [3 ,4]];
let newArr = arr1.slice();
arr1[2][0] = 'changed';
console.log(newArr); // not a deep clone
let arr2 = [1, 2, [3 ,4]];
let newArrDeepclone = JSON.parse(JSON.stringify(arr2));
arr2[2][0] = 'changed';
console.log(newArrDeepclone); // A deep clone, values unchanged
You also can use reviver function to filter.
var data = JSON.parse(jsonString, function reviver(key, value) {
//your code here to filter
});
For more information read JSON.parse.
Just to the cover parse for different input types
Parse the data with JSON.parse(), and the data becomes a JavaScript object.
var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}');
When using the JSON.parse() on a JSON derived from an array, the method will return a JavaScript array, instead of a JavaScript object.
var myArr = JSON.parse(this.responseText);
console.log(myArr[0]);
Date objects are not allowed in JSON.
For Dates do somthing like this
var text = '{ "name":"John", "birth":"1986-12-14", "city":"New York"}';
var obj = JSON.parse(text);
obj.birth = new Date(obj.birth);
Functions are not allowed in JSON.
If you need to include a function, write it as a string.
var text = '{ "name":"John", "age":"function () {return 30;}", "city":"New York"}';
var obj = JSON.parse(text);
obj.age = eval("(" + obj.age + ")");
Another option
const json = '{ "fruit": "pineapple", "fingers": 10 }'
let j0s,j1s,j2s,j3s
console.log(`{ "${j0s="fruit"}": "${j1s="pineapple"}", "${j2s="fingers"}": ${j3s="10"} }`)
Try this. This one is written in typescript.
export function safeJsonParse(str: string) {
try {
return JSON.parse(str);
} catch (e) {
return str;
}
}
I'm generating a table of results dynamically and one cell in each row contains an autocomplete. I'm using Select2 to display the autocomplete options and am populating the drop-down from ajax data and custom data unique for each row. My ajax data is coming from my Python app method and I'm using POST to send a variable back to the Python method to use to generate the custom data. Here's how this is set-up:
$(".js-example-tokenizer-ajax-data").select2({
tags: true,
createTag: function (params) {
return {
id: params.term,
text: params.term,
newOption: true
}
},
templateResult: function (data) {
var $result = $("<span></span>");
$result.text(data.text);
if (data.newOption) {
$result.append(" <em>(new)</em>");
}
return $result;
},
placeholder: 'Select an option',
maximumSelectionLength: 3,
ajax: {
url: '{{ url_for("select2Autocomplete") }}',
contentType: 'application/json',
method: "POST",
dataType : 'json',
data: JSON.stringify({variable:myValue}),
processResults: function (data) {
return {
results: data.resource_list
};
}
}
});
I've set the id of the select element to a value from my Jinja template.
<select onfocus="this.selectedIndex = -1;" id="{{ key }}" class="js-example-tokenizer-ajax-data" multiple="multiple" miriamId="{{ value }}" style="width:100%">
<option value="{{ key }}" selected>{{ miriam_name_dict[value] }}</option>
</select>
Since it's dynamic I don't know what that id is for each select. I am able to get the value like this:
$('.js-example-tokenizer-ajax-data').on('select2:opening', function (evt) {
myValue = document.getElementById(this.id).getAttribute('id');
console.log("myValue: ", myValue)
});
I'd like to use myValue as the variable I send back to my python method via the data variable. Is there some way to access myValue to use in the autocomplete code?
I was able to pass back data to the autocomplete method for the select element the user clicked on as follows:
$(".js-example-tokenizer-ajax-data").select2({
tags: true, //Allows for free text input of tag values
createTag: function (params) {
return {
id: params.term,
text: params.term,
newOption: true
}
},
templateResult: function (data) {
var $result = $("<span></span>");
$result.text(data.text);
if (data.newOption) {
$result.append(" <em>(new)</em>");
}
return $result;
},
placeholder: 'Select an option',
maximumSelectionLength: 3,
ajax: {
url: '{{ url_for("select2Autocomplete") }}',
contentType: 'application/json',
method: "POST",
dataType : 'json',
data: function() {
var myValue = $(this).attr('id');
return JSON.stringify({variable: myValue})
},
processResults: function (data) {
return {
results: data.resource_list
};
}
}
});
I was not able to use {variable: $(this).attr('id')} directly as the value for the data parameter and did need to use JSON.stringify on the value to get the value in the python method using jsonData = request.json["variable"]