function executeValidation(params) {
if (params /*&& params.wfs*/ && params.geom && params.typeName && params.bounds) {
var resp = null;
var requestParams = "?request=GetFeature&version=1.0.0&typeName=" + params.typeName + "&BBOX=" +
params.bounds + ",EPSG:4326&outputFormat=JSON";
var exchange = httpclient.get(/*params.wfs*/ wfsAddress + requestParams);
var obj = JSON.parse(exchange.content);
if (obj.type != "FeatureCollection") {
throw new Error("Invalid GeoJSON type - " + obj.type);
}
obj.features.forEach(function(f) {
f.geometry = gs.geom.create(f.geometry);
});
resp = response.json(vt.validateIntersect(params, obj.features));
} else {
print("Server Error: Invalid parameters");
resp = {
status: 500,
headers: {"Content-Type": "text/plain",
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "POST, GET",
"Access-Control-Allow-Headers": "x-requested-with,Content-Type"},
body: ["Invalid parameters"]
};
}
resp.headers['Access-Control-Allow-Origin'] = '*';
return resp;
}
exports.testConvenience = function() {
getResponse = function(req) {
var params = {};
var input = req.method == "POST" ? req.input.read() : req.queryString;
parseParameters(input, params);
if (params.foo) {
return response.html(req.method + " with param");
}
return response.html(req.method);
};
var x = post(baseUri);
assert.strictEqual(x.status, 200);
assert.strictEqual(x.content, "POST");
x = post(baseUri, {foo: 'bar'});
assert.strictEqual(x.status, 200);
assert.strictEqual(x.content, "POST with param");
x = get(baseUri, {foo: 'bar'});
assert.strictEqual(x.status, 200);
assert.strictEqual(x.content, "GET with param");
x = del(baseUri);
assert.strictEqual(x.status, 200);
assert.strictEqual(x.content, "DELETE");
x = put(baseUri);
assert.strictEqual(x.status, 200);
assert.strictEqual(x.content, "PUT");
};
exports.testConvenience = function() {
getResponse = function(req) {
if (req.params.foo) {
return new Response (req.method + ' with param');
}
return new Response(req.method);
};
var myStatus, myData;
var callback = function(data, status) {
myData = data;
myStatus = status;
};
post(baseUri, callback);
assert.strictEqual(200, myStatus);
assert.strictEqual('POST', myData);
post(baseUri, {foo: 'bar'}, callback);
assert.strictEqual(200, myStatus);
assert.strictEqual('POST with param', myData);
get(baseUri, {foo: 'bar'}, callback);
assert.strictEqual(200, myStatus);
assert.strictEqual('GET with param', myData);
del(baseUri, callback);
assert.strictEqual(200, myStatus);
assert.strictEqual('DELETE', myData);
put(baseUri, callback);
assert.strictEqual(200, myStatus);
assert.strictEqual('PUT', myData);
};
exports.testConvenience = function() {
getResponse = function(req) {
var params = {};
var input = req.method == "POST" ? req.input.read() : req.queryString;
parseParameters(input, params);
if (params.foo) {
return html(req.method + ' with param');
}
return html(req.method);
};
var x = post(baseUri);
assert.strictEqual(200, x.status);
assert.strictEqual('POST', x.content);
x = post(baseUri, {foo: 'bar'});
assert.strictEqual(200, x.status);
assert.strictEqual('POST with param', x.content);
x = get(baseUri, {foo: 'bar'});
assert.strictEqual(200, x.status);
assert.strictEqual('GET with param', x.content);
x = del(baseUri);
assert.strictEqual(200, x.status);
assert.strictEqual('DELETE', x.content);
x = put(baseUri);
assert.strictEqual(200, x.status);
assert.strictEqual('PUT', x.content);
};
exports.testAuth = function () {
http.get(LOGIN_URL, function (data, status) {
assertMatch(data, /Unauthorized/);
assertEqual(401, status);
});
http.request({
url: LOGIN_URL,
username: '******',
password: '******',
success: function (data, status) {
assertMatch(data, /See other/);
assertEqual(303, status); // If authorized successfully, redirect.
},
error: function (data) {
assertTrue(false);
}
});
};
// ------------------------------------------------------------------
function neo4j_get_record_proc (dict_aa,nn)
{
var client= require ("ringo/httpclient");
var url='http://localhost:7474/db/data/node/' + nn + '/properties';
var data=client.get (url);
// print (data.content);
var dd_aa = JSON.parse (data.content);
if ("id" in dd_aa)
{
dict_aa = text_manipulate.dict_append_proc
(dict_aa,dd_aa.id,dd_aa.name,dd_aa.population,dd_aa.date_mod);
}
return dict_aa;
}
function executeWps(params) {
if (params && params.x && params.y && params.radius /*&& params.wfs*/ && params.typeName) {
var resp = null;
var bbox = makeBBox(params.x, params.y, params.radius);
var requestParams = "?request=GetFeature&version=1.0.0&typeName=" + params.typeName + "&BBOX=" +
bbox.lowerleft.x + "," + bbox.lowerleft.y + "," + bbox.upperright.x + "," + bbox.upperright.y + ",EPSG:900913&outputFormat=JSON";
var exchange = httpclient.get(/*params.wfs*/ wfsAddress + requestParams);
var obj = JSON.parse(exchange.content);
if (obj.type != "FeatureCollection") {
throw new Error("Invalid GeoJSON type - " + obj.type);
}
obj.features.forEach(function(f) {
f.geometry = gs.geom.create(f.geometry);
});
resp = response.json(db.distanceBearing(params, obj.features));
} else {
print("Server Error: Invalid parameters");
resp = {
status: 500,
headers: {"Content-Type": "text/plain",
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "POST, GET",
"Access-Control-Allow-Headers": "x-requested-with,Content-Type"},
body: ["Invalid parameters"]
};
}
resp.headers['Access-Control-Allow-Origin'] = '*';
return resp;
}
//
// ------------------------------------------------------------------
var text_manipulate = require ('/var/www/data_base/common/ringo_common/text_manipulate.js');
var xml_manipulate = require ('/var/www/data_base/common/ringo_common/xml_manipulate.js');
// ------------------------------------------------------------------
print ("*** 開始 ***");
var args = require('system').args;
var id_in = args[1];
print (id_in);
var client= require ("ringo/httpclient");
var url='http://localhost:8086/exist/rest/db/cities/cities.xml';
print ("*** ppp ***");
var data=client.get (url);
print ("*** qqq ***");
print (data.status);
// print (data.content);
var dict_aa = xml_manipulate.xml_to_dict_proc (data.content);
delete dict_aa[id_in];
text_manipulate.dict_display_proc (dict_aa);
var out_str = xml_manipulate.dict_to_xml_proc (dict_aa);
// print (out_str);
var testUrl = function(urlinfo) {
var url = urlinfo.url;
var component = urlinfo.component;
var expects = urlinfo.expects;
if (components != null) {
if (components.indexOf(component) == -1) {
console.log("Skipping test on: "+url);
return;
}
}
url = modifyUrlForComponent(url, component);
console.log("Testing URL: "+url);
print(JSON.stringify(urlinfo, ' ', null));
var date = new Date();
var t1 = date.getTime();
var x = httpclient.get(url);
date = new Date();
var t2 = date.getTime();
var td = t2-t1;
console.log("TIME\t"+component+"\t"+url+"\t"+td);
console.log("Status: " + x.status);
if (urlinfo.maxTimeMilliseconds != null) {
if (td > urlinfo.maxTimeMilliseconds) {
console.warn("TIME_EXCEEDS_EXPECTED: Call to "+url+" takes too long: "+td+" ms");
//assert.fail("Call to "+url+" takes too long: "+td+" ms");
}
}
if (expects.status != null) {
assert.equal(expects.status, x.status);
}
if (expects.status == null && x.status == 500) {
console.warn("Received a 500");
console.warn("DEBUG:"+x.content);
assert.notEqual(x.status, 500);
// no point testing further
return;
}
var resultObj = null;
if (expects.format != null) {
var rawContent = x.content;
if (expects.raw_contains != null) {
var strings = listify(expects.raw_contains);
strings.forEach(function(s) {
console.log("Checking for presence of string: "+s);
//assert.isTrue(rawContent.indexOf(s) > -1);
assert.stringContains(rawContent, s);
});
}
if (expects.raw_not_contains != null) {
var strings = expects.raw_not_contains.push == null ? [expects.raw_not_contains] : expects.raw_not_contains; // listify
strings.forEach(function(s) {
console.log("Checking for presence of string: "+s);
//assert.isTrue(rawContent.indexOf(s) > -1);
assert.stringContains(rawContent, s);
});
}
if (expects.format == 'json') {
resultObj = JSON.parse(rawContent);
}
else if (expects.format == 'xml') {
resultObj = new XML(rawContent.replace("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>",""));
}
else if (expects.format == 'html') {
console.warn("ignoring html");
}
else {
console.warn("TODO: "+expects.format);
}
}
if (resultObj != null) {
var results = null;
if (component == 'vocabulary') {
results = resultObj;
}
else if (component == 'federation') {
results = resultObj.result.result; // yes this looks odd, but this is how fed returns data
}
else if (component == 'ontoquest') {
// TODO - OQ XML layered on JSON is complex - best just do raw checks for now
results = resultObj.data;
}
else if (component == 'monarch') {
var subcomponent = urlinfo.subcomponent;
if (subcomponent == 'simsearch') {
results = [resultObj];
}
else {
results = [resultObj];
//console.warn("Not implemented: "+ subcomponent);
}
}
else {
console.warn("??"+component);
results = resultObj;
}
console.log("# results: "+results.length);
testResults(urlinfo, results);
}
}