710 lines
27 KiB
PHP
710 lines
27 KiB
PHP
<% /*
|
||
$Revision$
|
||
$Id$
|
||
|
||
File: api2_rest.inc
|
||
Description: Functies voor de http-REST interface op de modellen
|
||
Notes: Hier wordt van alles met de 'buitenwereld' gecommuniceerd.
|
||
Het manipuleren met behulp van modellen gebeurt in api2.inc
|
||
Status:
|
||
|
||
*/
|
||
%>
|
||
<!-- #include file="api2.inc" -->
|
||
<%
|
||
|
||
api2_rest = {
|
||
authenticate: function _authenticate(model)
|
||
{
|
||
var APIKEY;
|
||
if (S("fac_api_key_in_url"))
|
||
APIKEY = getQParam("APIKEY", "");
|
||
if (!APIKEY && Request.ServerVariables("HTTP_X_FACILITOR_API_KEY").Count)
|
||
APIKEY = String(Request.ServerVariables("HTTP_X_FACILITOR_API_KEY")); // Meegegeven als X-FACILITOR-API-Key
|
||
|
||
if (!APIKEY && Session("user_key") > 0)
|
||
{
|
||
user_key = Session("user_key"); // Hierdoor is de API intern te gebruiken zonder authenticatie
|
||
}
|
||
else
|
||
{
|
||
if (Session("user_key") > 0)
|
||
{} // Tijdens ontwikkeling heb je soms in tweede tab de GUI open. Laat dat ongemoeid.
|
||
else
|
||
Session.Abandon(); // Altijd, voor de zekerheid
|
||
|
||
var sql = "SELECT prs_perslid_key, prs_perslid_naam"
|
||
+ " FROM prs_perslid"
|
||
+ " WHERE prs_perslid_verwijder IS NULL"
|
||
+ " AND prs_perslid_apikey = " + safe.quoted_sql(APIKEY);
|
||
var oRs = Oracle.Execute(sql);
|
||
if (oRs.Eof || !APIKEY)
|
||
{
|
||
Response.Status = "401 Unauthorized";
|
||
//Response.AddHeader("WWW-Authenticate", "Basic realm=\"FACILITOR API\"");
|
||
Response.End;
|
||
};
|
||
__Log("API2 User is: " + oRs("prs_perslid_naam").Value);
|
||
/* global */ user_key = oRs("prs_perslid_key").Value;
|
||
|
||
if (typeof NO_ADDHEADER == "undefined" && Request.Servervariables("HTTP_FCLT_VERSION").Count > 0)
|
||
{ // wordt opgepikt door FCLTAPI.DLL voor in de logging en daarna gestript. Niet in Fiddler dus
|
||
Response.AddHeader ("FCLT_USERID", customerId + "\\" + String(user_key));
|
||
}
|
||
|
||
oRs.Close();
|
||
}
|
||
|
||
// Impersonate?
|
||
var IMPERS;
|
||
if (S("fac_api_key_in_url"))
|
||
IMPERS = getQParam("SWITCHUSER", "");
|
||
if (!IMPERS && Request.ServerVariables("HTTP_X_FACILITOR_SWITCH_USER").Count)
|
||
IMPERS = String(Request.ServerVariables("HTTP_X_FACILITOR_SWITCH_USER")); // Meegegeven als X-FACILITOR-SWITCH-USER
|
||
if (IMPERS && S("fac_api_allow_impersonate"))
|
||
{
|
||
var sql = "SELECT prs_perslid_key, prs_perslid_naam"
|
||
+ " FROM prs_perslid"
|
||
+ " WHERE prs_perslid_verwijder IS NULL"
|
||
+ " AND prs_perslid_oslogin = " + safe.quoted_sql_upper(IMPERS);
|
||
var oRs = Oracle.Execute(sql);
|
||
if (oRs.Eof)
|
||
{
|
||
Response.Status = "412 Invalid X-Facilitor-Switch-User header";
|
||
Response.End;
|
||
};
|
||
__Log("IMPERS User is: " + oRs("prs_perslid_naam").Value);
|
||
var other_user_key = oRs("prs_perslid_key").Value;
|
||
oRs.Close();
|
||
if (model.impersonate_auth)
|
||
{
|
||
var xfunc = user.func_enabled2(model.module, { prs_key: other_user_key, isOptional: true });
|
||
var can = (xfunc && xfunc.canRead(model.impersonate_auth));
|
||
if (can)
|
||
/* global */ user_key = other_user_key;
|
||
}
|
||
if (user_key != other_user_key)
|
||
{
|
||
Response.Status = "412 Unauthorized X-Facilitor-Switch-User header";
|
||
Response.End;
|
||
}
|
||
}
|
||
|
||
/* global */ user = new Perslid(user_key);
|
||
CheckForLogging(Request.QueryString("logging")); // Nu pas kan autorisatie via user gecontroleerd worden
|
||
},
|
||
process: function _process(model)
|
||
{
|
||
Session.Codepage = 65001; // We doen *uitsluitend* utf-8
|
||
Response.Charset = 'utf-8';
|
||
|
||
if (typeof model == "function") // Nieuwe stijl is het een function. Even compatible.
|
||
model = new model();
|
||
|
||
api2_rest.authenticate(model);
|
||
|
||
var method = String(Request.ServerVariables("REQUEST_METHOD"));
|
||
|
||
if (!/GET|PUT|POST|DELETE/.test(method)) // Overigens houdt IIS deze al eerder tegen
|
||
{
|
||
Response.Status = "405 Method not allowed";
|
||
Response.End;
|
||
}
|
||
if (!("REST_" + method in model))
|
||
{
|
||
Response.Status = "501 Not Implemented";
|
||
// TODO The response MUST include an Allow header containing a list of valid methods for the requested resource.
|
||
Response.End;
|
||
}
|
||
var jsondata = {};
|
||
var filter = shared.qs2json();
|
||
filter = api2_rest.plugin.transform_filter(filter);
|
||
var requestparams = { filter: filter, include: getQParamArray("include", []) };
|
||
|
||
if (/PUT|POST/.test(method)) // Dan is er in de body data meegestuurd
|
||
{
|
||
switch (getQParamSafe("format", "invalid").toLowerCase())
|
||
{
|
||
case "json":
|
||
{
|
||
var parsed = RequestJSON();
|
||
if (parsed.error)
|
||
api2.error(500, "Error parsing input JSON: " + parsed.error);
|
||
jsondata = api2_rest.plugin.transform_incoming(requestparams, parsed.json);
|
||
if (!jsondata)
|
||
api2.error(500, "Error parsing input JSON: Empty");
|
||
break;
|
||
}
|
||
case "xml":
|
||
{
|
||
var parsed = RequestXML();
|
||
if (parsed.error)
|
||
api2.error(500, "Error parsing input XML: " + parsed.error);
|
||
jsondata = api2_rest.xml2json(parsed.xml);
|
||
if (!jsondata)
|
||
api2.error(500, "Error parsing input XML: Empty");
|
||
break;
|
||
}
|
||
default:
|
||
UNKNOWN_FORMAT_TYPE;
|
||
}
|
||
if (!jsondata || !(model.record_name in jsondata || (model.multi_update && model.records_name in jsondata)))
|
||
{
|
||
api2.error(500, "No '{0}' found in input".format(model.record_name));
|
||
}
|
||
}
|
||
var key = getQParamInt("id", -1); // Voor POST/PUT/DELETE
|
||
var isSingle = /PUT|POST|DELETE/.test(method) || (key>0); // PUT, POST en DELETE altijd single
|
||
|
||
if (getQParamSafe("format", "json") == "doc")
|
||
{
|
||
// Dan hoeven we verder niets te doen
|
||
}
|
||
else if (getQParamSafe("format", "json") == "api")
|
||
{
|
||
// TODO: Onderstaande in een of ander standaardformaat opleveren?
|
||
var result = { id: model.records_name,
|
||
methods: [],
|
||
includes: [],
|
||
fields: []
|
||
};
|
||
for (var i in model.includes)
|
||
result.includes.push(i);
|
||
if ("REST_GET" in model)
|
||
result.methods.push("GET");
|
||
if ("REST_PUT" in model)
|
||
result.methods.push("PUT");
|
||
if ("REST_POST" in model)
|
||
result.methods.push("POST");
|
||
if ("REST_DELETE" in model)
|
||
result.methods.push("DELETE");
|
||
|
||
for (var fld in model.fields)
|
||
{ // TODO: We missen hard-coded filters als reservableequipment/allowedinroom nu nog
|
||
if (!model.fields.hidden)
|
||
result.fields.push({ id: fld,
|
||
filter: model.fields[fld].filter,
|
||
type: model.fields[fld].typ,
|
||
label: model.fields[fld].label
|
||
});
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (method == "DELETE")
|
||
{
|
||
var result = model["REST_" + method]( requestparams, key );
|
||
}
|
||
else if (method == "GET" && filter.mode == "attachment" && "custom_fields" in model.includes)
|
||
{
|
||
requestparams.filter.id = key; // Die kan er maar beter wel zijn!
|
||
requestparams.include = ["custom_fields"];
|
||
var data = model.REST_GET(requestparams);
|
||
if (!data.length) // mogelijk not authorized op hele record
|
||
Response.Status = "404 Not Found";
|
||
else
|
||
model.includes["custom_fields"].model.streamattachment(filter, data[0].custom_fields);
|
||
Response.End;
|
||
}
|
||
else if (method == "GET")
|
||
{
|
||
var result = model["REST_" + method]( requestparams, null, key );
|
||
}
|
||
else if (model.record_name in jsondata) // een enkel record
|
||
{
|
||
var result = model["REST_" + method]( requestparams, jsondata[model.record_name], key );
|
||
}
|
||
else
|
||
{ // Loop door de multiple records en geef de REST_ functie altijd <20><>n record
|
||
for (var record in jsondata[model.records_name])
|
||
{
|
||
var thisdata = jsondata[model.records_name][record];
|
||
var result = model["REST_" + method]( requestparams, thisdata, thisdata.id );
|
||
}
|
||
}
|
||
}
|
||
|
||
switch (method)
|
||
{
|
||
case "DELETE":
|
||
{
|
||
Response.Status = "204 No Content";
|
||
Response.End;
|
||
break;
|
||
}
|
||
case "GET":
|
||
{
|
||
data = result;
|
||
break;
|
||
}
|
||
case "PUT":
|
||
case "POST":
|
||
{
|
||
var key = result.key;
|
||
if (key)
|
||
{
|
||
var params = { filter: shared.qs2json(), include: getQParamArray("include", []) }, jsondata, key
|
||
// requestparams.include is mogelijk uitgebreid met wat er in de body stond
|
||
data = model.REST_GET({ filter: { id: key }, include: requestparams.include }); // resulterende data weer terug
|
||
__Log(data);
|
||
}
|
||
else
|
||
{
|
||
data = [];
|
||
isSingle = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
api2_rest.deliver(data, model, getQParamSafe("format", "json"), isSingle);
|
||
|
||
},
|
||
// Data is een array met 'records'
|
||
deliver: function _deliver(data, model, format, single )
|
||
{
|
||
if (single && !data.length)
|
||
{
|
||
Response.Status = "404 Not Found";
|
||
Response.End;
|
||
}
|
||
|
||
if (format == "html" || format == "json")
|
||
{
|
||
var result = { };
|
||
if (single)
|
||
result[model.record_name] = data[0];
|
||
else
|
||
{
|
||
result.total_count = model.total_count;
|
||
result.limit = model.limit;
|
||
result.offset = 0;
|
||
result[model.records_name] = data;
|
||
}
|
||
|
||
var resultdata = api2_rest.plugin.transform_outgoing({}, result);
|
||
}
|
||
switch (format)
|
||
{
|
||
case "api":
|
||
{
|
||
var xml_antwoord = api2_rest.json2xml(data, model, single);
|
||
Response.ContentType = "application/json";
|
||
break;
|
||
}
|
||
case "doc":
|
||
{
|
||
if (model.fields) // Ga de hints er bij zoeken
|
||
{
|
||
var safefieldnames = [];
|
||
var lcl2fld = {};
|
||
for (var fld in model.fields)
|
||
{
|
||
var lclname = "{0}.{1}.hint".format(model.records_name, fld);
|
||
lcl2fld[lclname] = fld;
|
||
safefieldnames.push(safe.quoted_sql(lclname));
|
||
}
|
||
//model.fields[fld].hint = "Hallo";
|
||
var sql = "SELECT fac_locale_xsl_label, "
|
||
+ " COALESCE(fac_locale_xsl_cust, fac_locale_xsl_tekst) fac_locale_xsl_tekst"
|
||
+ " FROM fac_locale_xsl xsl"
|
||
+ " WHERE fac_locale_xsl_lang = " + safe.quoted_sql(user_lang)
|
||
+ " AND fac_locale_xsl_module = 'ASP'"
|
||
+ " AND fac_locale_xsl_label IN (" + safefieldnames.join(", ") + ")";
|
||
var oRs = Oracle.Execute(sql);
|
||
while (!oRs.Eof)
|
||
{
|
||
model.fields(lcl2fld[oRs("fac_locale_xsl_label").Value]) = oRs("fac_locale_xsl_tekst").value;
|
||
oRs.MoveNext();
|
||
}
|
||
}
|
||
Response.ContentType = "text/html";
|
||
var str_antwoord = simple_json2xml(model, "api");
|
||
var xml_antwoord = new ActiveXObject("MSXML2.DOMDocument.6.0");
|
||
xml_antwoord.loadXML(str_antwoord);
|
||
if (xml_antwoord.parseError.errorCode)
|
||
{
|
||
abort_with_warning("XSL error: " + xml_antwoord.parseError.reason + " @ " + xml_antwoord.parseError.line + "." + xml_antwoord.parseError.linepos + "\n"+ xml_antwoord.parseError.srcText);
|
||
}
|
||
|
||
var style = new ActiveXObject("MSXML2.DOMDocument.6.0");
|
||
style.async = false;
|
||
style.resolveExternals = false;
|
||
if (Request.QueryString("debug").Count == 0)
|
||
{
|
||
style.load(Server.MapPath(rooturl + "/appl/api2/reference.xsl")); // De stylesheet laden. API's redeneren vanuit de root
|
||
var str_antwoord = xml_antwoord.transformNode(style); // terugstoppen in antwoord
|
||
}
|
||
else
|
||
{
|
||
if (Application("otap_environment") != "O")
|
||
ONLY_ON_OTAP_O;
|
||
|
||
style.load(Server.MapPath(rooturl + "/appl/shared/indent.xsl")); // De stylesheet laden. API's redeneren vanuit de root
|
||
var str_antwoord = "<pre>" + Server.HTMLEncode(xml_antwoord.transformNode(style)) + "</pre>";
|
||
}
|
||
if (style.parseError.errorCode)
|
||
{
|
||
abort_with_warning("XSL error: " + style.parseError.reason + " @ " + style.parseError.line + "." + style.parseError.linepos );
|
||
}
|
||
break;
|
||
}
|
||
case "json":
|
||
var str_antwoord = JSON.stringify(resultdata, null, getQParam("pretty","0")=="1"?2:0);
|
||
var jsonp = getQParam("jsonp", getQParam("callback",""));
|
||
if (jsonp)
|
||
{
|
||
str_antwoord = jsonp + "(" + str_antwoord + ")";
|
||
Response.ContentType = "application/javascript";
|
||
}
|
||
else
|
||
Response.ContentType = "application/json";
|
||
break;
|
||
case "html":
|
||
Response.ContentType = "text/html";
|
||
var antwoord = JSON.stringify(resultdata, null, 2);
|
||
var str_antwoord = "<!DOCTYPE html><html><head></head><body><pre>"
|
||
+ Server.HTMLEncode(antwoord)
|
||
+ "</pre></body></html>";
|
||
break;
|
||
case "xml":
|
||
Response.ContentType = "text/xml";
|
||
var xml_antwoord = api2_rest.json2xml(data, model, single);
|
||
// TODO: Output XSL transform ondersteunen?
|
||
if (getQParam("pretty","0")=="1")
|
||
{
|
||
var style = new ActiveXObject("MSXML2.DOMDocument.6.0");
|
||
style.async = false;
|
||
style.resolveExternals = false;
|
||
style.load(Server.MapPath(rooturl + "/appl/shared/indent.xsl")); // De stylesheet laden. API's redeneren vanuit de root
|
||
if (style.parseError.errorCode)
|
||
{
|
||
abort_with_warning("XSL error: " + style.parseError.reason + " @ " + style.parseError.line + "." + style.parseError.linepos );
|
||
}
|
||
var str_antwoord = xml_antwoord.transformNode(style); // terugstoppen in antwoord
|
||
}
|
||
else
|
||
var str_antwoord = xml_antwoord.xml;
|
||
//Response.ContentType = "application/json";
|
||
//var str_antwoord = JSON.stringify(api2_rest.xml2json(xml_antwoord), null, 2);;
|
||
break;
|
||
default:
|
||
WRONG_FORMAT;
|
||
}
|
||
|
||
// str_antwoord heeft nu het te versturen antwoord
|
||
// Bepaal eTag
|
||
var oCrypto = new ActiveXObject("SLNKDWF.Crypto");
|
||
var eTag = '"' + oCrypto.hex_sha1(String(S("cache_changecounter")) + "_" + str_antwoord).toLowerCase() + '"';
|
||
Response.AddHeader("ETag", eTag);
|
||
if (Request.ServerVariables("HTTP_IF_NONE_MATCH") == eTag)
|
||
{ // We hebben een match! Effectief besparen wel alleen op dataverkeer, de queries zijn al geweest
|
||
Response.Clear();
|
||
Response.Status = "304 Not modified";
|
||
Response.End;
|
||
}
|
||
|
||
Response.write(str_antwoord);
|
||
},
|
||
|
||
// TODO: Wanneer attributes gebruiken en wanneer (sub)-elements?
|
||
// Streven: data == xml2json(json2xml(data))
|
||
json2xml: function _json2xml(data, model, single)
|
||
{
|
||
var rootname = model.records_name;
|
||
var record_name = model.record_name;
|
||
var xmlDoc = new ActiveXObject("MSXML2.DOMDocument.6.0");
|
||
xmlDoc.appendChild(xmlDoc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\""));
|
||
|
||
var record2json = function(record, record_name)
|
||
{
|
||
var elementRecord = xmlDoc.createElement(record_name);
|
||
for (var fld in record)
|
||
{
|
||
var elementField = xmlDoc.createElement(fld);
|
||
if (record[fld] instanceof Date)
|
||
{
|
||
var elementFieldText = xmlDoc.createTextNode(String(record[fld].toJSON()));
|
||
elementField.appendChild(elementFieldText);
|
||
}
|
||
else if (record[fld] instanceof Array)
|
||
{
|
||
var inc_record_name;
|
||
for (var ii in model.includes)
|
||
{
|
||
if (model.includes[ii].model.records_name == fld)
|
||
inc_record_name = model.includes[ii].model.record_name;
|
||
}
|
||
// Fallback voor attachments array --> "attachment"
|
||
if (!inc_record_name)
|
||
inc_record_name = fld.substr(0, fld.length-1);
|
||
|
||
for (var i = 0; i < record[fld].length; i++)
|
||
elementField.appendChild(record2json(record[fld][i], inc_record_name));
|
||
}
|
||
else if (record[fld] && typeof record[fld] == "object") // Veronderstelt dat dit foreign met name/key is
|
||
{
|
||
if ("name" in record[fld] && "id" in record[fld])
|
||
{
|
||
elementField.setAttribute("name", fld);
|
||
elementField.setAttribute("id", record[fld].id);
|
||
}
|
||
else
|
||
elementField = record2json(record[fld], fld);
|
||
}
|
||
else
|
||
{
|
||
var elementFieldText = xmlDoc.createTextNode(String(record[fld]||""));
|
||
elementField.appendChild(elementFieldText);
|
||
}
|
||
elementRecord.appendChild(elementField);
|
||
}
|
||
return elementRecord;
|
||
};
|
||
|
||
if (single)
|
||
{
|
||
xmlDoc.appendChild(record2json(data[0], record_name));
|
||
}
|
||
else
|
||
{
|
||
var arrayElement = xmlDoc.createElement(rootname);
|
||
for (var i = 0; i < data.length; i++)
|
||
arrayElement.appendChild(record2json(data[i], record_name));
|
||
xmlDoc.appendChild(arrayElement);
|
||
}
|
||
return xmlDoc;
|
||
},
|
||
// Streven: data == json2xml(xml2json(xml))
|
||
// http://davidwalsh.name/convert-xml-json maar @attributes er uit gehaald
|
||
xml2json: function _xml2json(xml)
|
||
{
|
||
// Create the return object
|
||
var obj = {};
|
||
|
||
if (xml.nodeType == 1)
|
||
{ // element
|
||
// do attributes
|
||
if (xml.attributes.length > 0)
|
||
{
|
||
// JGL removed: obj["@attributes"] = {};
|
||
for (var j = 0; j < xml.attributes.length; j++)
|
||
{
|
||
var attribute = xml.attributes.item(j);
|
||
obj[attribute.nodeName] = attribute.nodeValue;
|
||
}
|
||
}
|
||
}
|
||
else if (xml.nodeType == 3)
|
||
{ // text
|
||
obj = xml.nodeValue;
|
||
}
|
||
|
||
// do children
|
||
if (xml.hasChildNodes())
|
||
{
|
||
for(var i = 0; i < xml.childNodes.length; i++)
|
||
{
|
||
var item = xml.childNodes.item(i);
|
||
var nodeName = item.nodeName;
|
||
if (typeof(obj[nodeName]) == "undefined")
|
||
{
|
||
// JGL Added: Only one Textnode is simplified. Autodetect data
|
||
if (item.nodeType == 3 && xml.childNodes.length == 1)
|
||
{
|
||
var dt = myJSON.internal_parsedate(null, item.nodeValue);
|
||
if (dt && dt instanceof Date)
|
||
return dt;
|
||
return item.nodeValue;
|
||
}
|
||
|
||
obj[nodeName] = api2_rest.xml2json(item);
|
||
}
|
||
else
|
||
{
|
||
if (typeof(obj[nodeName].push) == "undefined")
|
||
{
|
||
var old = obj[nodeName];
|
||
obj[nodeName] = [];
|
||
obj[nodeName].push(old);
|
||
}
|
||
obj[nodeName].push(api2_rest.xml2json(item));
|
||
}
|
||
}
|
||
}
|
||
return obj;
|
||
},
|
||
find_plugin: function()
|
||
{
|
||
var plugin_name = getQParamSafe("plugin", "").toLowerCase();
|
||
if (!plugin_name)
|
||
return {};
|
||
var fso = new ActiveXObject("Scripting.FileSystemObject");
|
||
var paths = ["/cust/" + customerId, "/cust", "/appl/api2"]; // Hieronder zoeken naar '/plugins' folder
|
||
for (var p in paths)
|
||
{
|
||
var ppath = Server.MapPath(rooturl + paths[p] + "/plugins/" + plugin_name + ".wsc")
|
||
//__Log(ppath);
|
||
if (fso.FileExists(ppath))
|
||
{
|
||
try
|
||
{
|
||
var hook = GetObject("script:" + ppath);
|
||
}
|
||
catch(e)
|
||
{
|
||
api2.error(500, "Loading {0} failed: {1}".format(ppath, e.description));
|
||
}
|
||
hook.initialize({ S: S, Oracle: Oracle, customerId: customerId, safe: safe });
|
||
return hook;
|
||
}
|
||
}
|
||
api2.error(500, "Undefined plugin {0}".format(plugin_name));
|
||
},
|
||
plugin: {
|
||
transform_filter: function(filter)
|
||
{
|
||
var outdata = filter;
|
||
var hook = api2_rest.find_plugin();
|
||
if ("transform_filter" in hook)
|
||
{
|
||
outdata = hook.transform_filter(filter);
|
||
}
|
||
hook = null;
|
||
return outdata;
|
||
},
|
||
transform_incoming: function(params, data)
|
||
{
|
||
var outdata = data;
|
||
var hook = api2_rest.find_plugin();
|
||
if ("transform_incoming" in hook)
|
||
{
|
||
outdata = hook.transform_incoming(params, data);
|
||
}
|
||
hook = null;
|
||
return outdata;
|
||
},
|
||
transform_outgoing: function(params, data)
|
||
{
|
||
var outdata = data;
|
||
var hook = api2_rest.find_plugin();
|
||
if ("transform_outgoing" in hook)
|
||
outdata = hook.transform_outgoing(params, data);
|
||
hook = null;
|
||
return outdata;
|
||
}
|
||
}
|
||
}
|
||
|
||
// LET OP: Verwacht wordt dat de JSON-code in de body utf-8 encoded is, niet windows-1252!
|
||
// (in de praktijk moet je *moeite* doen om windows-1252 te krijgen dus dit is handiger)
|
||
function RequestJSON()
|
||
{
|
||
var jvraag;
|
||
if(Request.TotalBytes > 0)
|
||
{
|
||
var lngBytesCount = Request.TotalBytes;
|
||
jvraag = BytesToStr(Request.BinaryRead(lngBytesCount));
|
||
}
|
||
__Log("Vraag: " + jvraag);
|
||
try
|
||
{
|
||
var vraag = myJSON.parse(jvraag);
|
||
}
|
||
catch (e)
|
||
{
|
||
__DoLog("JSON eval faalt met: {0}<br>{1}".format(e.description, jvraag), "ffff00");
|
||
return { error: e.description };
|
||
}
|
||
return { json: vraag };
|
||
}
|
||
|
||
function RequestXML()
|
||
{
|
||
try
|
||
{
|
||
var inputXML = Server.CreateObject("MSXML2.DOMDocument.6.0");
|
||
inputXML.load(Request);
|
||
}
|
||
catch (e)
|
||
{
|
||
return { error: e.description };
|
||
}
|
||
if (inputXML.parseError.errorCode)
|
||
{
|
||
return { error: inputXML.parseError.reason + " @ " + inputXML.parseError.line + "." + inputXML.parseError.linepos };
|
||
}
|
||
return { xml: inputXML };
|
||
}
|
||
|
||
function BytesToStr(bytes)
|
||
{
|
||
var stream = Server.CreateObject("ADODB.Stream");
|
||
stream.type = 1;
|
||
stream.open;
|
||
stream.write(bytes);
|
||
stream.position = 0;
|
||
stream.type = 2; // Text
|
||
stream.charset = "utf-8";
|
||
|
||
var sOut = stream.readtext();
|
||
stream.close;
|
||
return sOut;
|
||
}
|
||
|
||
function getQParamISODate(pName, defVal)
|
||
{
|
||
return _get_ParamISODate(Request.Querystring, pName, defVal)
|
||
}
|
||
function getFParamISODate(pName, defVal)
|
||
{
|
||
return _get_ParamISODate(Request.Form, pName, defVal)
|
||
}
|
||
function _get_ParamISODate(pColl, pName, defVal)
|
||
{
|
||
var strval = _get_Param(pColl, pName, defVal, true); // force: een lege waarde wordt als afwezig beschouwd
|
||
if (strval)
|
||
{
|
||
var dt = myJSON.internal_parsedate(null, strval);
|
||
if (dt && dt instanceof Date)
|
||
return dt;
|
||
}
|
||
|
||
if (defVal instanceof Date)
|
||
{
|
||
return defVal;
|
||
}
|
||
if (defVal === null) // bewust triple===
|
||
{
|
||
return null;
|
||
}
|
||
// Error message will get to client and/or IIS logfiles
|
||
eval("INTERNAL_ERROR_PARAMETER_" + pName + "_IS_NOT_ISODATE");
|
||
}
|
||
|
||
var simple_json2xml = (function (undefined) {
|
||
"use strict";
|
||
var tag = function (name, closing) {
|
||
return (closing ? "</" : "\n<") + name + ">";
|
||
};
|
||
return function (obj, rootname) {
|
||
var xml = "";
|
||
for (var i in obj) {
|
||
if (obj.hasOwnProperty(i)) {
|
||
var value = obj[i],
|
||
type = typeof value;
|
||
if (value instanceof Array && type == 'object') {
|
||
for (var sub in value) {
|
||
xml += simple_json2xml(value[sub]);
|
||
}
|
||
} else if (value instanceof Object && type == 'object') {
|
||
xml += tag(i) + simple_json2xml(value) + tag(i, 1);
|
||
} else {
|
||
xml += tag(i) + Server.HTMLEncode(value) + tag(i, 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
return rootname ? tag(rootname) + xml + tag(rootname, 1) : xml;
|
||
};
|
||
})(simple_json2xml || {});
|
||
%> |