return function (params, callback) {
return jsonld.toRDF(params, db.jsonld.options, function (err, triples) {
if (err) { throw err; }
var result = triples['@default'].map(function (triple) {
return ['subject', 'predicate', 'object'].reduce(function(acc, key) {
var node = triple[key];
// uses type field set to 'blank node' by jsonld.js toRDF()
if (node.type === 'blank node') {
node.value = db.v('@id');
}
// preserve object data types using double quotation for literals
// and don't keep data type for strings without defined language
if(key === 'object' && triple.object.datatype){
if(triple.object.datatype.match(XSDTYPE)){
if(triple.object.datatype === 'http://www.w3.org/2001/XMLSchema#string'){
node.value = '"' + triple.object.value + '"';
} else {
node.value = '"' + triple.object.value + '"^^<' + triple.object.datatype + '>';
}
} else if(triple.object.datatype.match(RDFLANGSTRING)){
node.value = '"' + triple.object.value + '"@' + triple.object.language;
}
}
acc[key] = node.value;
return acc;
}, {});
});
callback(null, result);
});
};
function parse(rawDocument, contentType, convertCallback) {
var n3Parser = N3.Parser();
var n3Writer;
var triples = [];
var prefixes = {};
if (contentType === 'application/ld+json') {
var jsonDocument;
try {
jsonDocument = JSON.parse(rawDocument);
} catch (err) {
convertCallback(err, null);
}
jsonld.toRDF(jsonDocument, {
format: 'application/nquads'
}, nquadCallback);
} else if (contentType === 'application/nquads' ||
contentType === 'application/n-quads') {
nquadCallback(null, rawDocument);
} else {
convertCallback(new Error("Wrong content type"), null);
}
function nquadCallback(err, nquads) {
if (err) {
debug("Error parsing nquads: " + err);
convertCallback(err, null);
}
try {
n3Parser.parse(nquads, tripleCallback, prefixCallback);
} catch (err) {
convertCallback(err, null);
}
}
function tripleCallback(err, triple, prefixes) {
if (err) {
convertCallback(err, null);
}
if (triple) {
triples.push(triple);
} else {
n3Writer = N3.Writer({
prefixes: prefixes
});
for (var i = 0; i < triples.length; i++) {
n3Writer.addTriple(triples[i]);
}
n3Writer.end(convertCallback);
}
}
function prefixCallback(prefix, iri) {
prefixes[prefix] = iri;
}
}
$scope.toRDF = function () {
var jsonld = require('jsonld');
var copiedForm = jQuery.extend(true, {}, $rootScope.jsonToSave);
if (copiedForm) {
jsonld.toRDF(copiedForm, {format: 'application/nquads'}, function (err, nquads) {
$rootScope.jsonToRDF = nquads;
return nquads;
});
}
};
stream = stream.pipe(es.map(function (data, submit) {
jsonld.toRDF(data, {format: 'application/nquads'}, function(err, out) {
if (err) {
console.error(err);
submit(null, {});
}
else {
submit(err, out);
}
});
}))
// Extracts triples from a JSON-LD document
function extractTriples(json, addTriple, done) {
jsonld.toRDF(json, function (error, triples) {
for (var graphName in triples) {
triples[graphName].forEach(function (triple) {
addTriple(triple.subject.value,
triple.predicate.value,
convertEntity(triple.object));
});
}
done(error);
});
}
onSocketMessage: function(ewd) {
var wsMsg = ewd.webSocketMessage;
var type = wsMsg.type;
var params = wsMsg.params;
var sessid = ewd.session.$('ewd_sessid')._value;
if (type === 'EWD.form.login') {
console.log('login: '******'') return 'You must enter a username';
if (params.password === '') return 'You must enter a password';
//if (params.username !== 'rob' && params.username !== 'Rob') return 'Invalid login';
//if (params.password !== 'secret') return 'Invalid login';
ewd.session.setAuthenticated();
ewd.sendWebSocketMsg({
type: 'loggedInAs',
message: {
fullName: params.username,
}
});
return '';
};
if (!ewd.session.isAuthenticated) return;
if (type === 'EWD.form.queryText' || type==='FMQL.subquery') {
if (params.queryText === '') return 'no query entered';
var result = ewd.mumps.function('WRAP^FMQLEWD', sessid, params.queryText);
var qresult = new ewd.mumps.GlobalNode('%zewdTemp', [sessid]);
var array = qresult._getDocument();
//for (var i=0;i<array.length;i++){
//}
var bquery=array.join('');
var jdata=JSON.parse(bquery);
ewd.sendWebSocketMsg({
type: 'FMQLJData',
message: {
data: jdata
}
});
jsonld.toRDF(jdata, {format: 'application/nquads'}, function(err,nquads) {
ewd.sendWebSocketMsg({
type: 'testld',
message: {
err:err,
nquads:nquads
}
});
});
return 'got '+array.length;
};
}
stream = stream.pipe(es.map(function (data, submit) {
jsonld.toRDF(data, {format: 'application/nquads'}, function(err, out) {
if (err) {
console.error(err);
submit(null, {});
}
else {
out.split('.\n').forEach(function(triplet) {
worksheet.addRow(CSV.parse(triplet.replace(" ", "@").replace(" ", "@"), "@").pop()).commit();
});
submit();
}
});
}));
inputs.forEach(function(input) {
// report what's beeing tested
var json = JSON.parse(fs.readFileSync(input));
var validations = [];
validators.forEach(function(test) {
// test it!
validations.push(test(json));
});
// dump nquads
// TODO: collect results then output, so nquads stay with validation
// TODO: eventually validate this to (obviously...)
jsonld.toRDF(json, {format: 'application/nquads'},
function(err, nquads) {
console.log('Results for ' + input.blue);
validations.forEach(function(msg) {
console.log(msg);
});
console.log("NQuads:".grey);
if (!err) console.log(nquads);
else console.log(err.red);
}
);
});
/**
* Parse a string and put the result into the graph kb.
* Normal method is sync.
* Unfortunately jsdonld is currently written to need to be called async.
* Hence the mess below with executeCallback.
*/
function parse (str, kb, base, contentType, callback) {
try {
if (contentType === 'text/n3' || contentType === 'text/turtle') {
var p = N3Parser(kb, kb, base, base, null, null, '', null)
p.loadBuf(str)
executeCallback()
} else if (contentType === 'application/rdf+xml') {
var parser = new RDFParser(kb)
parser.parse(Util.parseXML(str), base, kb.sym(base))
executeCallback()
} else if (contentType === 'application/xhtml+xml') {
parseRDFaDOM(Util.parseXML(str, {contentType: 'application/xhtml+xml'}), kb, base)
executeCallback()
} else if (contentType === 'text/html') {
parseRDFaDOM(Util.parseXML(str, {contentType: 'text/html'}), kb, base)
executeCallback()
} else if (contentType === 'application/sparql-update') { // @@ we handle a subset
sparqlUpdateParser(str, kb, base)
executeCallback()
} else if (contentType === 'application/ld+json' ||
contentType === 'application/nquads' ||
contentType === 'application/n-quads') {
var n3Parser = N3.Parser()
var triples = []
if (contentType === 'application/ld+json') {
var jsonDocument
try {
jsonDocument = JSON.parse(str)
} catch (parseErr) {
callback(parseErr, null)
}
jsonld.toRDF(jsonDocument,
{format: 'application/nquads'},
nquadCallback)
} else {
nquadCallback(null, str)
}
} else {
throw new Error("Don't know how to parse " + contentType + ' yet')
}
} catch (e) {
executeErrorCallback(e)
}
function executeCallback () {
if (callback) {
callback(null, kb)
} else {
return
}
}
function executeErrorCallback (e) {
if (contentType !== 'application/ld+json' ||
contentType !== 'application/nquads' ||
contentType !== 'application/n-quads') {
if (callback) {
callback(e, kb)
} else {
throw new Error('Error trying to parse <' + base + '> as ' +
contentType + ':\n' + e + ':\n' + e.stack)
}
}
}
/*
function setJsonLdBase (doc, base) {
if (doc instanceof Array) {
return
}
if (!('@context' in doc)) {
doc['@context'] = {}
}
doc['@context']['@base'] = base
}
*/
function nquadCallback (err, nquads) {
if (err) {
callback(err, kb)
}
try {
n3Parser.parse(nquads, tripleCallback)
} catch (err) {
callback(err, kb)
}
}
function tripleCallback (err, triple, prefixes) {
if (err) {
callback(err, kb)
}
if (triple) {
triples.push(triple)
} else {
for (var i = 0; i < triples.length; i++) {
addTriple(kb, triples[i])
}
callback(null, kb)
}
}
function addTriple (kb, triple) {
var subject = createTerm(triple.subject)
var predicate = createTerm(triple.predicate)
var object = createTerm(triple.object)
var why = null
if (triple.graph) {
why = createTerm(triple.graph)
}
kb.add(subject, predicate, object, why)
}
function createTerm (termString) {
var value
if (N3.Util.isLiteral(termString)) {
value = N3.Util.getLiteralValue(termString)
var language = N3.Util.getLiteralLanguage(termString)
var datatype = new NamedNode(N3.Util.getLiteralType(termString))
return new Literal(value, language, datatype)
} else if (N3.Util.isIRI(termString)) {
return new NamedNode(termString)
} else if (N3.Util.isBlank(termString)) {
value = termString.substring(2, termString.length)
return new BlankNode(value)
} else {
return null
}
}
}
fs.readFile(draftLocation, (err, draftData) => {
if (err) {
console.error("JSON Schema Draft could not be found at ", draftLocation);
throw err;
};
console.log("Taking Schema Draft found at ", draftLocation);
var draft = JSON.parse(draftData);
var ajv = new Ajv(); // options can be passed, e.g. {allErrors: true}
ajv.addMetaSchema(draft);
ajv.addSchema(schema, 'td');
// var validate = ajv.compile(schema);
// var valid = validate(data);
// if (!valid) console.log(validate.errors);
// //OR
// var valid = ajv.validate(schema, data);
// if (!valid) console.log(ajv.errors);
// //OR
// var valid = ajv.addSchema(schema, 'mySchema')
// .validate('mySchema', data);
// if (!valid) console.log(ajv.errorsText());
// schema validation
if (tdJson.hasOwnProperty('properties') || tdJson.hasOwnProperty('actions') || tdJson.hasOwnProperty('events')) {
if (!tdJson.hasOwnProperty('base')) {
//no need to do something. Each href should be absolute
console.log(':) Tip: Without base, each href should be an absolute URL');
} else {
//need to check if base finishes with / or not
//if it does, hrefs shouldnt start with it, if it doesnt, then hrefs must start with it
//QUESTION should there be separate schemas or transformation?
try {
tdJson = transformHref(tdJson);
} catch (err) {
console.error('X JSON Schema validation... KO:');
console.error('> ' + err);
throw err;
}
}
}
var valid = ajv.validate('td', tdJson);
//used to be var valid = ajv.validate('td', e.detail);
if (valid) {
console.log('JSON Schema validation... OK');
checkEnumConst(tdJson);
checkPropItems(tdJson);
checkInteractions(tdJson);
checkSecurity(tdJson);
checkUniqueness(tdJson);
} else {
console.log('X JSON Schema validation... KO:');
//console.log(ajv.errors);
//TODO: Handle long error messages in case of oneOf
console.log('> ' + ajv.errorsText());
}
//json ld validation
jsonld.toRDF(tdJson, {
format: 'application/nquads'
}, function (err, triples) {
if (!err) {
console.log('JSON-LD validation... OK');
} else {
console.log('X JSON-LD validation... KO:');
console.log('> ' + err);
}
});
});
// serialize the ontoly to RDF/XML
jsonld.toRDF(jsonldObj, {format: 'application/nquads'}, function(err, nquads) {
var store = rdflib.graph();
if (err) {
console.log(err);
} else {
try {
rdflib.parse(nquads, store, null, 'application/n-quads', function(err) {
if (err) {
console.log(err);
} else {
// var base = jsonldObj["@context"] && jsonldObj["@context"]["@base"];
// not using base because is not explicitly set in rdf/xml
rdflib.serialize(
null, store, null, 'application/rdf+xml',
function(err, rdfXml) {
if (err) {
console.log(err);
} else {
fs.writeFileSync(path.join(ontologiesDir, 'spa.owl'), rdfXml);
console.log('Ontology in RDF/XML regenerated successfully.');
}
});
}
});
} catch (err) {
console.log(err);
}
}
});