Serialize and deserialize vcs in JS (2)
diff --git a/public/js/src/vc.js b/public/js/src/vc.js
new file mode 100644
index 0000000..26fa281
--- /dev/null
+++ b/public/js/src/vc.js
@@ -0,0 +1,331 @@
+var KorAP = KorAP || {};
+/*
+ 704: "Operation needs operand list"
+ 701: "JSON-LD group has no @type attribute"
+
+ 802: "Match type is not supported by value type"
+ 804: "Unknown value type"
+ 805: "Value is invalid"
+ 806: "Value is not a valid date string"
+ 807: "Value is not a valid regular expression"
+
+// new:
+ 810: "Unknown document group operation" (like 711)
+ 811: "Document group expects operation" (like 703)
+ 812: "Operand not supported in document group" (like 744)
+*/
+
+(function (KorAP) {
+ "use strict";
+
+ // Default log message
+ KorAP.log = KorAP.log || function (type, msg) {
+ console.log(type + ": " + msg);
+ };
+
+ KorAP._validStringMatchRE = new RegExp("^(?:eq|ne|contains)$");
+ KorAP._validRegexMatchRE = new RegExp("^(?:eq|ne)$");
+ KorAP._validDateMatchRE = new RegExp("^(?:since|until|eq)$");
+ KorAP._validDateRE = new RegExp("^(?:\\d{4})(?:-\\d\\d(?:-\\d\\d)?)?$");
+ KorAP._validGroupOpRE = new RegExp("^(?:and|or)$");
+
+ /*
+ KorAP.VirtualCollection = {
+ create : function () {
+ return Object.create(KorAP.VirtualCollection);
+ },
+ fromJson : function (json) {
+ },
+ render : function (element) {
+ // ...
+ }
+ };
+ */
+ // Make KorAP.DocElement inherit from KorAP.Doc
+ KorAP.DocElement = {
+ create : function (param) {
+ return Object.create(Korap.DocElement)._init(param);
+ },
+ _init : function () {
+ KorAP.Doc.create(param)
+ }
+ };
+
+ KorAP.DocGroup = {
+ create : function (type) {
+ var docGroup = Object.create(KorAP.DocGroup);
+ docGroup.operation = type;
+ docGroup._operands = [];
+ docGroup.ldType = "docGroup";
+ return docGroup;
+ },
+
+ // Deserialize from json
+ fromJson : function (json) {
+ return Object.create(KorAP.DocGroup)._init(json);
+ },
+
+ _init : function (json) {
+
+ if (json === undefined)
+ return KorAP.DocGroup.create("and");
+
+ if (json["@type"] != "korap:docGroup") {
+ KorAP.log(701, "JSON-LD group has no @type attribute");
+ return;
+ };
+
+ this.ldType = "docGroup";
+
+ if (json["operation"] === undefined ||
+ typeof json["operation"] !== 'string') {
+ KorAP.log(811, "Document group expects operation");
+ return;
+ };
+
+ var operation = json["operation"];
+ this.operation = operation.replace(/^operation:/,'');
+
+ this._operands = [];
+
+ if (json["operands"] === undefined ||
+ !(json["operands"] instanceof Array)) {
+ KorAP.log(704, "Operation needs operand list")
+ return;
+ };
+
+ var operands = json["operands"];
+
+ // Add all documents
+ for (var i in operands) {
+ var operand = operands[i];
+
+ switch (operand["@type"]) {
+ case undefined:
+ KorAP.log(701, "JSON-LD group has no @type attribute");
+ return;
+ case "korap:doc":
+ var doc = KorAP.Doc.fromJson(operand);
+ if (doc === undefined)
+ return;
+ this.appendOperand(doc);
+ break;
+ case "korap:docGroup":
+ var docGroup = KorAP.DocGroup.fromJson(operand);
+ if (docGroup === undefined)
+ return;
+ this.appendOperand(docGroup);
+ break;
+ default:
+ KorAP.log(812, "Operand not supported in document group");
+ return;
+ };
+ };
+ return this;
+ },
+ set operation (op) {
+ if (KorAP._validGroupOpRE.test(op)) {
+ this._op = op;
+ }
+ else {
+ KorAP.log(810, "Unknown operation type");
+ return;
+ };
+ },
+ get operation () {
+ return this._op || 'and';
+ },
+ get operands () {
+ return this._operands;
+ },
+ appendOperand : function (obj) {
+ this._operands.push(obj)
+ return obj;
+ },
+ getOperand : function (index) {
+ return this._operands[index];
+ },
+ set ldType (type) {
+ this._ldtype = type;
+ },
+ get ldType () {
+ return this._ldType || "docGroup";
+ },
+ toJson : function () {
+ var operands = new Array();
+ for (var i in this._operands) {
+ operands.push(this._operands[i].toJson());
+ };
+ return {
+ "@type" : "korap:" + this.ldType,
+ "operation" : "operation:" + this.operation,
+ "operands" : operands
+ };
+ }
+ };
+
+ /**
+ * Virtual collection doc criterion.
+ */
+ KorAP.Doc = {
+
+ // Create new
+ create : function () {
+ var doc = Object.create(KorAP.Doc);
+ doc.ldType = "doc";
+ return doc;
+ },
+
+ // Deserialize from json
+ fromJson : function (json) {
+ return Object.create(KorAP.Doc)._init(json);
+ },
+
+ // Init new doc criterion or deserialize fro JSON-LD
+ _init : function (json) {
+ if (json === undefined)
+ return this.create();
+
+ if (json["@type"] !== "korap:doc") {
+ KorAP.log(701, "JSON-LD group has no @type attribute");
+ return;
+ };
+
+ this.ldType = "doc";
+
+ if (json["value"] === undefined ||
+ typeof json["value"] != 'string') {
+ KorAP.log(805, "Value is invalid");
+ return;
+ };
+
+ // There is a defined key
+ if (json["key"] !== undefined &&
+ typeof json["key"] === 'string') {
+
+ // Set key
+ this.key = json["key"];
+
+ // Set match operation
+ if (json["match"] !== undefined) {
+ if (typeof json["match"] === 'string')
+ this.matchop = json["match"];
+ else {
+ KorAP.log(802, "Match type is not supported by value type");
+ return;
+ };
+ };
+
+ // Key is a string
+ if (json["type"] === undefined ||
+ json["type"] == "type:string") {
+ this.type = "string";
+
+ // Check match type
+ if (!KorAP._validStringMatchRE.test(this.matchop)) {
+ KorAP.log(802, "Match type is not supported by value type");
+ return;
+ };
+
+ // Set string value
+ this.value = json["value"];
+ }
+
+ // Key is a date
+ else if (json["type"] === "type:date") {
+ this.type = "date";
+
+ if (json["value"] !== undefined &&
+ KorAP._validDateRE.test(json["value"])) {
+
+ if (!KorAP._validDateMatchRE.test(this.matchop)) {
+ KorAP.log(802, "Match type is not supported by value type");
+ return;
+ };
+
+ // Set value
+ this.value = json["value"];
+ }
+ else {
+ KorAP.log(806, "Value is not a valid date string");
+ return;
+ };
+ }
+
+ // Key is a regular expression
+ else if (json["type"] === "type:regex") {
+ this.type = "regex";
+
+ try {
+
+ // Try to create a regular expression
+ var check = new RegExp(json["value"]);
+
+ if (!KorAP._validRegexMatchRE.test(this.matchop)) {
+ KorAP.log(802, "Match type is not supported by value type");
+ return;
+ };
+
+ this.value = json["value"];
+ }
+ catch (e) {
+ KorAP.log(807, "Value is not a valid regular expression");
+ return;
+ };
+ this.type = "regex";
+ }
+
+ else {
+ KorAP.log(804, "Unknown value type");
+ return;
+ };
+ };
+
+ return this;
+ },
+ set key (value) {
+ this._key = value;
+ },
+ get key () {
+ return this._key;
+ },
+ set matchop (match) {
+ this._matchop = match.replace(/^match:/, '');
+ },
+ get matchop () {
+ return this._matchop || "eq";
+ },
+ set type (type) {
+ this._type = type;
+ },
+ get type () {
+ return this._type || "string";
+ },
+ set value (value) {
+ this._value = value;
+ },
+ get value () {
+ return this._value;
+ },
+
+ // Todo: Redundant and should be inherited
+ set ldType (type) {
+ this._ldtype = type;
+ },
+ get ldType () {
+ return this._ldType || "doc";
+ },
+ toJson : function () {
+ if (!this.matchop || !this.key)
+ return {};
+
+ return {
+ "@type" : "korap:" + this.ldType,
+ "key" : this.key,
+ "match" : "match:" + this.matchop,
+ "value" : this.value || '',
+ "type" : "type:" + this.type
+ };
+ }
+ };
+}(this.KorAP));