/* version: 1.4beta3 */
var Scrutari = {};
Scrutari.log = function (msg) {
if ((console) && (console.log)) {
console.log(msg);
}
};
Scrutari.logError = function (error) {
var errorMessage = "Scrutari Request Error [key = " + error.key + " | parameter = " + error.parameter;
if (error.hasOwnProperty("value")) {
errorMessage += " | value = " + error.value;
}
if (error.hasOwnProperty("array")) {
errorMessage += " | array = (";
for(var i = 0; i < error.array.length; i++) {
if (i > 0) {
errorMessage += ";";
}
var obj = error.array[i];
errorMessage += obj.key;
if (obj.hasOwnProperty("value")) {
errorMessage += "=" + obj.value;
}
}
errorMessage += ")";
}
errorMessage += "}";
Scrutari.log(errorMessage);
};
Scrutari.escape = function (text) {
var result = "";
for(let i = 0; i < text.length; i++) {
let carac = text.charAt(i);
switch (carac) {
case '&':
result += "&";
break;
case '"':
result += """;
break;
case '<':
result += "<";
break;
case '>':
result += ">";
break;
case '\'':
result += "'";
break;
default:
result += carac;
}
}
return result;
};
Scrutari.hasAttribute = function (fiche, attributeKey) {
if (!fiche.attrMap) {
return false;
}
if (attributeKey) {
return fiche.attrMap.hasOwnProperty(attributeKey);
} else {
return true;
}
};
Scrutari.hasMarkedAttribute = function (fiche, attributeKey) {
if (!fiche.mattrMap) {
return false;
}
if (attributeKey) {
return fiche.mattrMap.hasOwnProperty(attributeKey);
} else {
return true;
}
};
Scrutari.Api = function (settings) {
var name, engineUrl, lang, origin;
var argumentLength = arguments.length;
var options = {
dataType: "json",
queryVariant: "query",
ficheFields: null,
motcleFields: null,
paginationLength: 50,
subsearchThreshold: 250,
groupSortFunction: _ficheCountSort,
limit: 0
};
if (argumentLength === 1) {
name = settings.name;
engineUrl = settings.engineUrl;
lang = settings.lang;
origin = settings.origin;
if (settings.options) {
_assignOptions(settings.options);
};
_assignOptions(settings);
} else if ((argumentLength === 4) || (argumentLength === 5)) {
name = arguments[0];
engineUrl = arguments[1];
lang = arguments[2];
origin = arguments[3];
if (argumentLength === 5) {
_assignOptions(arguments[4]);
}
} else {
throw new Error("Argument length should be 1, 4 or 5");
}
if (!name) {
throw new Error("name undefined");
}
if (!engineUrl) {
throw new Error("engineUrl undefined");
}
if (!lang) {
throw new Error("lang undefined");
}
if (!origin) {
throw new Error("origin undefined");
}
this.name = name;
this.engineUrl = engineUrl;
this.lang = lang;
this.origin = origin;
this.options = options;
this.meta = null;
function _assignOptions(object) {
for(let key in object) {
let value = object[key];
switch(key) {
case "name":
case "engineUrl":
case "lang":
case "origin":
case "options":
break;
default:
options[key] = value;
}
}
}
function _ficheCountSort(group1, group2) {
let count1 = group1.ficheCount;
let count2 = group2.ficheCount;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
let rank1 = group1.category.rank;
let rank2 = group1.category.rank;
if (rank1 < rank2) {
return -1;
} else if (rank1 > rank2) {
return 1;
} else {
return 0;
}
}
}
};
Scrutari.Config = Scrutari.Api;
Scrutari.Api.prototype.getJsonUrl = function () {
return this.engineUrl + "json";
};
Scrutari.Api.prototype.getDownloadUrl = function (qId, extension) {
switch(extension) {
case "ods":
case "csv":
return this.engineUrl + "export/" + "result_" + qId + "_" + this.lang + "." + extension;
case "atom":
return this.engineUrl + "feed/" + "fiches_" + this.lang + ".atom?qid=" + qId + "&all=" + _getCurrentDate();
default:
Scrutari.log("Unknown extension: " + extension);
return "";
}
function _getCurrentDate() {
var date = new Date();
var dateString = date.getFullYear() + "-";
var mois = date.getMonth() + 1;
if (mois < 10) {
dateString += "0";
}
dateString += mois;
dateString += "-";
var jour = date.getDate();
if (jour < 10) {
dateString += "0";
}
dateString += jour;
return dateString;
}
};
Scrutari.Api.prototype.getPermalinkUrl = function (qId, permalinkPattern) {
var permalink = permalinkPattern.replace("$LANG", this.lang);
permalink = permalink.replace("$QID", qId);
return permalink;
};
Scrutari.Api.prototype.getLimit = function () {
if (this.options.limit) {
return this.options.limit;
} else {
return this.options.paginationLength * 2;
}
};
Scrutari.Api.prototype.buildRequestParameters = function (type) {
var api = this;
var requestParameters = {
"lang": api.lang,
"warnings": 1,
"version": 3
};
var argLength = arguments.length;
if (argLength > 1) {
for(let i = 1; i < argLength; i++) {
_assign(arguments[i]);
}
}
requestParameters.type = type;
return requestParameters;
function _assign(parameters) {
if (!parameters) {
return;
}
for(let propKey in parameters) {
let propValue = parameters[propKey];
if (!propValue) {
propValue = "";
}
requestParameters[propKey] = propValue;
}
}
};
Scrutari.Api.prototype.initMeta = function (callback) {
var api = this;
this.loadEngineInfo({
callback: function (engineInfo) {
let scrutariMeta = new Scrutari.Meta(engineInfo);
api.meta = scrutariMeta;
if (callback) {
callback(scrutariMeta);
}
}
});
};
Scrutari.Api.prototype.loadBaseArray = function(args) {
Scrutari.Ajax.loadBaseArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadCategoryArray = function(args) {
Scrutari.Ajax.loadCategoryArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadCorpusArray = function(args) {
Scrutari.Ajax.loadCorpusArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadThesaurusArray = function(args) {
Scrutari.Ajax.loadThesaurusArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadEngineInfo = function(args) {
Scrutari.Ajax.loadEngineInfo(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadFicheArray = function(args) {
Scrutari.Ajax.loadFicheArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadMotcleArray = function(args) {
Scrutari.Ajax.loadMotcleArray(this, args.requestParameters, args.callback);
};
Scrutari.Api.prototype.loadGeoJson = function(args) {
Scrutari.Ajax.loadGeoJson(this, args.requestParameters, args.callback, args.errorCallback);
};
Scrutari.Api.prototype.loadFicheSearch = function(args) {
var requestParameters = args.requestParameters;
if ((!requestParameters) && (args.q)) {
requestParameters = {
q: args.q
};
}
Scrutari.Ajax.loadFicheSearchResult(this, args.requestParameters, args.callback, args.errorCallback);
};
Scrutari.Api.prototype.loadExistingFicheSearch = function(args) {
var requestParameters = args.requestParameters;
if ((!requestParameters) && (args.qid)) {
requestParameters = {
qid: args.qid
};
}
Scrutari.Ajax.loadExistingFicheSearchResult(this, requestParameters, args.callback);
};
Scrutari.Ajax = {};
Scrutari.Ajax.load = function (settings) {
$.ajax(settings);
};
Scrutari.Ajax.loadBaseArray = function (api, requestParameters, baseArrayCallback) {
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("base", requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "baseArray", baseArrayCallback);
}
});
};
Scrutari.Ajax.loadCategoryArray = function (api, requestParameters, categoryArrayCallback) {
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("category", requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "categoryArray", categoryArrayCallback);
}
});
};
Scrutari.Ajax.loadCorpusArray = function (api, requestParameters, corpusArrayCallback) {
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("corpus", requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "corpusArray", corpusArrayCallback);
}
});
};
Scrutari.Ajax.loadThesaurusArray = function (api, requestParameters, thesaurusArrayCallback) {
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("thesaurus", requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "thesaurusArray", thesaurusArrayCallback);
}
});
};
Scrutari.Ajax.loadEngineInfo = function (api, requestParameters, engineInfoCallback) {
var defaultParameters = {
"info": "all"
};
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("engine", defaultParameters, requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "engineInfo", engineInfoCallback);
}
});
};
Scrutari.Ajax.loadFicheArray = function (api, requestParameters, ficheArrayCallback) {
var defaultParameters = {
"fieldvariant": "data"
};
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("fiche", defaultParameters, requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, ["ficheArray", "motcleArray"], ficheArrayCallback);
}
});
};
Scrutari.Ajax.loadMotcleArray = function (api, requestParameters, motcleArrayCallback) {
var defaultParameters = {
"fieldvariant": "data"
};
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("motcle", defaultParameters, requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "motcleArray", motcleArrayCallback);
}
});
};
Scrutari.Ajax.loadGeoJson = function (api, requestParameters, geojsonCallback, errorCallback) {
var defaultParameters = {
"fieldvariant": api.options.queryVariant,
"origin": api.origin
};
if (api.options.ficheFields !== null) {
defaultParameters["fichefields"] = api.options.ficheFields;
}
if (api.options.motcleFields !== null) {
defaultParameters["motclefields"] = api.options.motcleFields;
}
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("geojson", defaultParameters, requestParameters),
success: function (data, textStatus) {
if (data.hasOwnProperty("error")) {
if (errorCallback) {
errorCallback(data.error);
} else {
Scrutari.logError(data.error);
}
} else {
Scrutari.Ajax.logWarnings(data);
geojsonCallback(data);
}
}
});
};
Scrutari.Ajax.loadFicheSearchResult = function (api, requestParameters, ficheSearchResultCallback, errorCallback) {
var defaultParameters = {
"fieldvariant": api.options.queryVariant,
"origin": api.origin,
"start": 1,
"limit": api.getLimit(),
"starttype": "in_all",
"q-mode": "intersection"
};
if (api.options.ficheFields !== null) {
defaultParameters["fichefields"] = api.options.ficheFields;
}
if (api.options.motcleFields !== null) {
defaultParameters["motclefields"] = api.options.motcleFields;
}
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("q-fiche", defaultParameters, requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "ficheSearchResult", ficheSearchResultCallback, errorCallback);
}
});
};
Scrutari.Ajax.loadExistingFicheSearchResult = function (api, requestParameters, existingFicheSearchResultCallback) {
var defaultParameters = {
"fieldvariant": api.options.queryVariant,
"insert": "-searchmeta,-motclearray",
"start": 1,
"limit": api.getLimit()
};
if (api.options.ficheFields !== null) {
defaultParameters["fichefields"] = api.options.ficheFields;
}
if (api.options.motcleFields !== null) {
defaultParameters["motclefields"] = api.options.motcleFields;
}
Scrutari.Ajax.load({
url: api.getJsonUrl(),
dataType: api.options.dataType,
data: api.buildRequestParameters("q-fiche", defaultParameters, requestParameters),
success: function (data, textStatus) {
Scrutari.Ajax.success(data, "ficheSearchResult", existingFicheSearchResultCallback);
}
});
};
Scrutari.Ajax.success = function(ajaxResult, objectNames, objectCallback, errorCallback) {
if (ajaxResult.hasOwnProperty("error")) {
if (errorCallback) {
errorCallback(ajaxResult.error);
} else {
Scrutari.logError(ajaxResult.error);
}
} else {
Scrutari.Ajax.logWarnings(ajaxResult);
if (!objectCallback) {
return;
}
if (Array.isArray(objectNames)) {
let apiObjectArray = new Array();
for(let objectName of objectNames) {
if (!ajaxResult.hasOwnProperty(objectName)) {
apiObjectArray.push(null);
} else {
apiObjectArray.push(ajaxResult[objectName]);
}
}
objectCallback.apply(this, apiObjectArray);
} else {
let objectName = objectNames;
if (!ajaxResult.hasOwnProperty(objectName)) {
throw new Error(objectName + " object is missing in json response");
} else {
objectCallback(ajaxResult[objectName]);
}
}
}
};
Scrutari.Ajax.logWarnings = function (ajaxResult) {
if (ajaxResult.hasOwnProperty("warnings")) {
var warningsMessage = "Scrutari Request Warnings [";
for(let i = 0; i < ajaxResult.warnings.length; i++) {
if (i > 0) {
warningsMessage += ";";
}
let warning = ajaxResult.warnings[i];
warningsMessage += "key = ";
warningsMessage += warning.key;
warningsMessage += " | parameter = ";
warningsMessage += warning.parameter;
if (warning.hasOwnProperty("value")) {
warningsMessage += " | value = ";
warningsMessage += warning.value;
}
}
warningsMessage += "]";
Scrutari.log(warningsMessage);
}
};
Scrutari.Meta = function (engineInfo) {
this.engineInfo = engineInfo;
};
Scrutari.Meta.prototype.getAttributeArray = function (familyName) {
if (!this.engineInfo.hasOwnProperty("attributes")) {
return new Array();
}
if (!this.engineInfo.attributes.hasOwnProperty(familyName)) {
return new Array();
}
return this.engineInfo.attributes[familyName];
};
Scrutari.Meta.prototype.getBase = function (code) {
var key = "code_" + code;
if (this.engineInfo.baseMap.hasOwnProperty(key)) {
return this.engineInfo.baseMap[key];
} else {
return null;
}
};
Scrutari.Meta.prototype.getBaseArray = function (sortFunction) {
var array = new Array();
var baseMap = this.engineInfo.baseMap;
var p=0;
for(let prop in baseMap) {
array[p] = baseMap[prop];
p++;
}
if (sortFunction) {
array = array.sort(sortFunction);
}
return array;
};
Scrutari.Meta.prototype.getCategory = function (categoryName) {
if (this.engineInfo.hasOwnProperty("categoryMap")) {
if (this.engineInfo.categoryMap.hasOwnProperty(categoryName)) {
return this.engineInfo.categoryMap[categoryName];
} else {
return null;
}
} else {
return null;
}
};
Scrutari.Meta.prototype.getCategoryArray = function (sortFunction) {
var array = new Array();
if (!this.engineInfo.hasOwnProperty("categoryMap")) {
return array;
}
var categoryMap = this.engineInfo.categoryMap;
var p=0;
for(let prop in categoryMap) {
array[p] = categoryMap[prop];
p++;
}
if (sortFunction) {
array = array.sort(sortFunction);
}
return array;
};
Scrutari.Meta.prototype.getCategoryForCorpus = function (code) {
if (!this.engineInfo.hasOwnProperty("categoryMap")) {
return null;
}
var categoryMap = this.engineInfo.categoryMap;
for(let prop in categoryMap) {
let category = categoryMap[prop];
for(let codecorpus of category.codecorpusArray) {
if (codecorpus === code) {
return category;
}
}
}
return null;
};
Scrutari.Meta.prototype.getComplementTitle = function(code, complementNumber) {
var corpus = this.getCorpus(code);
if (!corpus) {
return "";
}
var key = "complement_" + complementNumber;
if (corpus.phraseMap.hasOwnProperty(key)) {
return corpus.phraseMap[key];
} else {
return key;
}
};
Scrutari.Meta.prototype.getCorpus = function (code) {
var key = "code_" + code;
if (this.engineInfo.corpusMap.hasOwnProperty(key)) {
return this.engineInfo.corpusMap[key];
} else {
return null;
}
};
Scrutari.Meta.prototype.getCorpusArray = function (sortFunction) {
var array = new Array();
var corpusMap = this.engineInfo.corpusMap;
var p=0;
for(let prop in corpusMap) {
array[p] = corpusMap[prop];
p++;
}
if (sortFunction) {
array = array.sort(sortFunction);
}
return array;
};
Scrutari.Meta.prototype.getCorpusArrayForBases = function (baseArray) {
var result = new Array();
for(let codebase of baseArray) {
let key = "code_" +codebase;
if (this.engineInfo.baseMap.hasOwnProperty(key)) {
result = result.concat(this.engineInfo.baseMap[key].codecorpusArray);
}
}
return result;
};
Scrutari.Meta.prototype.getCorpusArrayForCategories = function (categoryArray) {
var result = new Array();
if (!this.engineInfo.hasOwnProperty("categoryMap")) {
return result;
}
for(let categoryName of categoryArray) {
if (this.engineInfo.categoryMap.hasOwnProperty(categoryName)) {
result = result.concat(this.engineInfo.categoryMap[categoryName].codecorpusArray);
}
}
return result;
};
Scrutari.Meta.prototype.getCorpusFicheCount = function (code) {
var corpus = this.getCorpus(code);
if (!corpus) {
return 0;
}
return corpus.stats.fiche;
};
Scrutari.Meta.prototype.getCorpusLangFicheCount = function (code, langArray) {
var corpus = this.getCorpus(code);
if (!corpus) {
return 0;
}
var ficheCount = 0;
for(let langObj of corpus.stats.langArray) {
if (langArray.indexOf(langObj.lang) !== -1) {
ficheCount += langObj.fiche;
}
}
return ficheCount;
};
Scrutari.Meta.prototype.getDefaultOptions = function () {
var options = {};
var attrMap = this.engineInfo.metadata.attrMap;
for(let key in attrMap) {
if (key.indexOf("scrutarijs:") === 0) {
let name = key.substring("scrutarijs:".length);
let values = attrMap[key];
if (values.length === 1) {
let value = values[0];
if (value === "false") {
value = false;
} else if (value === "true") {
value = true;
}
options[name] = value;
} else {
options[name] = values;
}
}
this[key] = options[key];
}
return options;
};
Scrutari.Meta.prototype.getEngineInfo = function () {
return this.engineInfo;
};
Scrutari.Meta.prototype.getGlobalFicheCount = function () {
return this.engineInfo.stats.fiche;
};
Scrutari.Meta.prototype.getGlobalLangFicheCount = function (langArray) {
var ficheCount = 0;
for(let langObj of this.engineInfo.stats.langArray) {
if (langArray.indexOf(langObj.lang) !== -1) {
ficheCount += langObj.fiche;
}
}
return ficheCount;
};
Scrutari.Meta.prototype.getLangArray = function (sortFunction) {
var array = new Array();
var length = this.engineInfo.stats.langArray.length;
for(let i = 0; i < length; i++) {
array[i] = this.engineInfo.stats.langArray[i];
}
if (sortFunction) {
array = array.sort(sortFunction);
}
return array;
};
Scrutari.Meta.prototype.getLangLabel = function (iso) {
if (this.engineInfo.langMap.hasOwnProperty(iso)) {
return this.engineInfo.langMap[iso];
} else {
return iso;
}
};
Scrutari.Meta.prototype.getThesaurus = function (code) {
var key = "code_" + code;
if (this.engineInfo.thesaurusMap.hasOwnProperty(key)) {
return this.engineInfo.thesaurusMap[key];
} else {
return null;
}
};
Scrutari.Meta.prototype.getThesaurusArray = function (sortFunction) {
var array = new Array();
var thesaurusMap = this.engineInfo.thesaurusMap;
var p=0;
for(let prop in thesaurusMap) {
array[p] = thesaurusMap[prop];
p++;
}
if (sortFunction) {
array = array.sort(sortFunction);
}
return array;
};
Scrutari.Meta.prototype.getTitle = function () {
return this.engineInfo.metadata.title;
};
Scrutari.Meta.prototype.withCategory = function () {
return this.engineInfo.hasOwnProperty("categoryMap");
};
Scrutari.Meta.load = function(api, callback) {
api.initMeta(callback);
};
Scrutari.Completor = function (scrutariMeta) {
this.scrutariMeta = scrutariMeta;
};
Scrutari.Completor.prototype.bythesaurusArray = function (fiche, motcleProvider) {
var scrutariMeta = this.scrutariMeta;
if (!fiche.hasOwnProperty("bythesaurusMap")) {
return false;
}
let thesaurusArray = scrutariMeta.getThesaurusArray();
let _bythesaurusArray = new Array();
for(let thesaurus of thesaurusArray) {
let codethesaurus = thesaurus.codethesaurus;
let key = "code_" + codethesaurus;
if (fiche.bythesaurusMap.hasOwnProperty(key)) {
let motcleArray = new Array();
for(let codemotcle of fiche.bythesaurusMap[key]) {
let motcle = motcleProvider(codemotcle);
if (motcle) {
motcleArray.push(motcle);
}
}
_bythesaurusArray.push({
thesaurus: thesaurus,
motcleArray: motcleArray
});
}
}
fiche._bythesaurusArray = _bythesaurusArray;
return true;
};
Scrutari.Completor.prototype.complementTitle = function (fiche) {
var scrutariMeta = this.scrutariMeta;
if (fiche.hasOwnProperty("mcomplementArray")) {
for(let mcomplement of fiche.mcomplementArray) {
mcomplement.title = scrutariMeta.getComplementTitle(fiche.codecorpus, mcomplement.number);
}
return true;
} else {
return false;
}
};
Scrutari.Completor.prototype.icon = function (fiche) {
if (fiche.hasOwnProperty("icon")) {
fiche._icon = fiche.icon;
return true;
} else if (fiche.hasOwnProperty("ficheicon")) {
fiche._icon = fiche.ficheicon;
return true;
} else {
return false;
}
};
Scrutari.Completor.prototype.markedAttributeArray = function (fiche, familyName ) {
var scrutariMeta = this.scrutariMeta;
let attributeArray = scrutariMeta.getAttributeArray(familyName);
if (attributeArray.length === 0) {
return false;
}
let objArray = new Array();
for(let attribute of attributeArray) {
if (fiche.mattrMap.hasOwnProperty(attribute.name)) {
objArray.push({
name: attribute.name,
title: attribute.title,
type: attribute.type,
valueArray: fiche.mattrMap[attribute.name]
});
}
}
fiche["_" + familyName + "AttributeArray"] = objArray;
return true;
};
Scrutari.Completor.prototype.motcleArray = function (fiche, motcleProvider) {
if (!fiche.hasOwnProperty("codemotcleArray")) {
return false;
}
let motcleArray = new Array();
for(let codemotcle of fiche.codemotcleArray) {
let motcle = motcleProvider(codemotcle);
if (motcle) {
motcleArray.push(motcle);
}
}
if (motcleArray.length > 0) {
fiche._motcleArray = motcleArray;
return true;
} else {
return false;
}
};
Scrutari.Completor.prototype.target = function (fiche, target) {
fiche._target = target;
return true;
};
Scrutari.Completor.prototype.thumbnail = function (fiche) {
if (fiche.hasOwnProperty("thumbnail")) {
fiche._thumbnail = fiche.thumbnail;
return true;
} else if (Scrutari.hasAttribute(fiche, "sct:thumbnail")) {
fiche._thumbnail = fiche.attrMap["sct:thumbnail"][0];
return true;
} else {
return false;
}
};
Scrutari.SearchUnit = function (settings) {
var result = settings.ficheSearchResult;
var completeFicheFunction = settings.completeFicheFunction;
this.api = settings.api;
this.ficheSearchResult = result;
this.requestParameters = settings.requestParameters;
this.searchMeta = result.searchMeta;
this.ficheGroupArray = result.ficheGroupArray;
this.completeFicheFunction = completeFicheFunction;
this.searchOrigin = settings.searchOrigin;
var groupSortFunction = settings.groupSortFunction;
if ((groupSortFunction) && (this.ficheGroupArray.length > 1)) {
this.ficheGroupArray = this.ficheGroupArray.sort(groupSortFunction);
}
this.motcleMap = new Object();
if (result.hasOwnProperty("motcleArray")) {
for(let motcle of result.motcleArray) {
this.motcleMap["code_" + motcle.codemotcle] = motcle;
}
}
this.notfoundArray = [];
for(let reportItem of result.searchMeta.reportArray) {
if (reportItem.canonicalArray.length === 0) {
this.notfoundArray.push(reportItem);
}
}
for(let group of this.ficheGroupArray) {
let ficheGroupName;
if (group.category){
ficheGroupName = group.category.name;
}
for(let fiche of group.ficheArray) {
completeFicheFunction(this, fiche, ficheGroupName);
}
}
};
Scrutari.SearchUnit.prototype.getQId = function () {
if (this.searchMeta) {
return this.searchMeta.qId;
} else {
return "";
}
};
Scrutari.SearchUnit.prototype.getQ = function () {
if (this.searchMeta) {
return this.searchMeta.q;
} else {
return "";
}
};
Scrutari.SearchUnit.prototype.getFicheCount = function (ficheGroupName) {
if (ficheGroupName) {
for(let group of this.ficheGroupArray) {
if ((group.category) && (group.category.name === ficheGroupName)) {
return group.ficheCount;
}
}
return 0;
} else {
if (this.searchMeta) {
return this.searchMeta.ficheCount;
} else {
return -1;
}
}
};
Scrutari.SearchUnit.prototype.getFicheGroupType = function () {
var type = this.ficheSearchResult.ficheGroupType;
if (type === "none") {
type = "unique";
}
return type;
};
Scrutari.SearchUnit.prototype.getUniqueFicheArray = function () {
var group = this.getFicheGroup();
if (!group) {
return new Array();
}
return group.ficheArray;
};
Scrutari.SearchUnit.prototype.isLoaded = function (args) {
var ficheGroupName = args.ficheGroupName;
var pagination = args.pagination;
var group = this.getFicheGroup(ficheGroupName);
if (!group) {
return true;
}
if (group.ficheArray.length === group.ficheCount) {
return true;
}
if (!pagination) {
return false;
}
var endIndex = (pagination.length * pagination.number) - 1;
if (endIndex < group.ficheArray.length) {
return true;
}
return false;
};
Scrutari.SearchUnit.prototype.loadFiches = function (args) {
var searchUnit = this;
var ficheGroupName = args.ficheGroupName;
var pagination = args.pagination;
var completeFicheFunction = searchUnit.completeFicheFunction;
var ficheCount, length, limit;
var currentGroup = searchUnit.getFicheGroup(ficheGroupName);
if (!currentGroup) {
return true;
}
ficheCount = currentGroup.ficheCount;
length = currentGroup.ficheArray.length;
if (length === ficheCount) {
return;
}
if (pagination) {
limit = (pagination.length * (pagination.number + 2)) - length;
if (limit < 1) {
return;
}
} else {
limit = -1;
}
var requestParameters = {
qid: searchUnit.getQId(),
start: length +1,
limit: limit
};
if (ficheGroupName) {
requestParameters.starttype = "in:" + ficheGroupName;
}
this.api.loadExistingFicheSearch({
requestParameters: requestParameters,
callback: function (ficheSearchResult) {
if (ficheGroupName) {
for(let newGroup of ficheSearchResult.ficheGroupArray) {
if (newGroup.category.name === currentGroup.category.name) {
_concat(currentGroup, newGroup);
}
}
} else {
if (ficheSearchResult.ficheGroupArray.length > 0) {
_concat(currentGroup, ficheSearchResult.ficheGroupArray[0]);
}
}
if (args.callback) {
args.callback();
}
}
});
function _concat(currentGroup, newGroup) {
for(let fiche of newGroup.ficheArray) {
completeFicheFunction(searchUnit, fiche, ficheGroupName);
currentGroup.ficheArray.push(fiche);
}
}
};
Scrutari.SearchUnit.prototype.extractFicheArray = function (args) {
var ficheGroupName = args.ficheGroupName;
var pagination = args.pagination;
let group = this.getFicheGroup(ficheGroupName);
if (!group) {
return new Array();
}
return Scrutari.Utils.extractFicheArray(group.ficheArray, pagination.length, pagination.number);
};
Scrutari.SearchUnit.prototype.getFicheGroup = function (ficheGroupName) {
if (!ficheGroupName) {
if (this.ficheGroupArray.length === 0) {
return null;
}
return this.ficheGroupArray[0];
}
for(let ficheGroup of this.ficheGroupArray) {
if ((ficheGroup.category) && (ficheGroup.category.name === ficheGroupName)) {
return ficheGroup;
}
}
return null;
};
Scrutari.SearchUnit.prototype.getMotcle = function (code) {
var key = "code_" + code;
if (this.motcleMap.hasOwnProperty(key)) {
return this.motcleMap[key];
} else {
return null;
}
};
Scrutari.SearchUnit.prototype.getMotcleArray = function (motcleFilter) {
if (!motcleFilter) {
motcleFilter = _accept;
}
var result = new Array();
if (this.ficheSearchResult.hasOwnProperty("motcleArray")) {
for(let motcle of this.ficheSearchResult.motcleArray) {
if (motcleFilter(motcle)) {
result.push(motcle);
}
}
}
return result;
function _accept(motcle) {
return true;
}
};
Scrutari.jQuery = {};
Scrutari.jQuery.find = function () {
switch(arguments.length) {
case 0:
throw new Error("No argument");
case 1: {
let uniqueArg = arguments[0];
if (typeof uniqueArg === "string") {
return _byId(uniqueArg);
} else {
return _byProperties(uniqueArg);
}
}
case 2: {
let arg1 = arguments[0];
let arg2 = arguments[1];
if ((typeof arg1 === "string") && (typeof arg2 === "string")) {
return _byId(arg1 + "_" + arg2);
} else {
return _find(arg1, arg2);
}
}
default:
return _byId(Array.from(arguments).join("_"));
}
function _byId(id) {
return $(document.getElementById(id));
}
function _byProperties(properties) {
return $(Scrutari.jQuery.toCssSelector(properties));
}
function _find(jqArgument, properties) {
return Scrutari.jQuery.convert(jqArgument).find(Scrutari.jQuery.toCssSelector(properties));
}
};
Scrutari.jQuery.convert = function (jqArgument) {
if (jqArgument.jquery) {
return jqArgument;
} else {
return $(jqArgument);
}
};
Scrutari.jQuery.exists = function (jqArgument) {
return Scrutari.jQuery.convert(jqArgument).length > 0;
};
Scrutari.jQuery.toCssSelector = function (properties) {
var query = "";
var elementName = false;
var suffix = "";
for(let key in properties) {
let value = properties[key];
if (!key.startsWith("_")) {
if (value === true) {
query += "[" + Scrutari.jQuery.toDataAttribute(key) + "]";
} else {
query += "[" + Scrutari.jQuery.toDataAttribute(key) + "='" + value + "']";
}
} else if (key === "_checked") {
if (value) {
suffix += ":checked";
} else {
suffix += ":not(:checked)";
}
} else if (key === "_type") {
query += "[type='" + value + "']";
} else if (key === "_name") {
query += "[name='" + value + "']";
} else if (key === "_value") {
query += "[value='" + value + "']";
} else if (key === "_element") {
elementName = value;
}
}
if (elementName) {
query = elementName + query;
}
query += suffix;
return query;
};
Scrutari.jQuery.toDataAttribute = function (camelCaseString) {
return "data-" + camelCaseString.replace(/[A-Z]/g, function (upperLetter) {
return "-" + upperLetter.toLowerCase();
});
};
Scrutari.jQuery.find.toSelector = Scrutari.jQuery.toCssSelector;
Scrutari.toCssQuery = Scrutari.jQuery.toCssSelector;
Scrutari.toDataAttribute = Scrutari.jQuery.toDataAttribute;
Scrutari.convert = Scrutari.jQuery.convert;
Scrutari.exists = Scrutari.jQuery.exists;
Scrutari.$ = Scrutari.jQuery.find;
Scrutari.Utils = {};
Scrutari.Utils.divideIntoColumns = function (objectArray, jqArgument, objectTemplate) {
var objectCount = objectArray.length;
if (objectCount === 0) {
return;
}
var $elements = Scrutari.jQuery.convert(jqArgument);
var elementCount = $elements.length;
if (elementCount === 0) {
Scrutari.log("HtmlElement selection with jqArgument is empty ");
return;
}
var objectCount = objectArray.length;
if (objectCount <= elementCount) {
for(let i = 0; i < objectCount; i++) {
$($elements[i]).append(objectTemplate(objectArray[i]));
}
return;
}
var modulo = objectCount % elementCount;
var columnLength = (objectCount - modulo) / elementCount;
var start = 0;
var stop = 0;
for(let i = 0; i< elementCount; i++) {
let $element = $($elements[i]);
stop += columnLength;
if (i < modulo) {
stop++;
}
for(let j = start; j < stop; j++) {
$element.append(objectTemplate(objectArray[j]));
}
start = stop;
}
};
Scrutari.Utils.getTabArray = function (ficheCount, paginationLength, currentPaginationNumber) {
var result = new Array();
var paginationCount;
if (ficheCount <= paginationLength) {
paginationCount = 1;
return result;
} else {
let modulo = ficheCount % paginationLength;
paginationCount = (ficheCount - modulo) / paginationLength;
if (modulo > 0) {
paginationCount ++;
}
}
if (currentPaginationNumber > paginationCount) {
currentPaginationNumber = paginationCount;
}
var paginationNumberStart = 1;
var paginationNumberEnd = 9;
if (currentPaginationNumber > 6) {
paginationNumberStart = currentPaginationNumber - 3;
paginationNumberEnd = currentPaginationNumber + 3;
}
if (paginationNumberEnd > paginationCount) {
paginationNumberEnd = paginationCount;
}
if (paginationNumberStart > 1) {
result.push({
number: 1,
title: "1",
state: 'enabled'
});
result.push({
number: 0,
title: "…",
state: 'etc'
});
}
for(let i = paginationNumberStart; i <= paginationNumberEnd; i++) {
let state = 'enabled';
if (i === currentPaginationNumber) {
state = 'active';
}
result.push({
number: i,
title: i.toString(),
state: state
});
}
if (paginationNumberEnd < paginationCount) {
result.push({
number: 0,
title: "…",
state: 'etc'
});
}
return result;
};
Scrutari.Utils.disable = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.prop('disabled', true);
return $elements;
};
Scrutari.Utils.enable = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.prop('disabled', false);
return $elements;
};
Scrutari.Utils.uncheck = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.prop('checked', false);
return $elements;
};
Scrutari.Utils.check = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.prop('checked', true);
return $elements;
};
Scrutari.Utils.toggle = function (jqElement, stateDataKey) {
var state = jqElement.data(stateDataKey);
if (state === 'off') {
state = 'on';
} else {
state = 'off';
}
jqElement.data(stateDataKey, state);
return state;
};
Scrutari.Utils.toggle.disabled = function (jqArgument, state) {
var $elements = Scrutari.jQuery.convert(jqArgument);
if (state === 'off') {
$elements.prop('disabled', true);
} else {
$elements.prop('disabled', false);
}
return $elements;
};
Scrutari.Utils.toggle.text = function (jqArgument, alterDataKey) {
var $elements = Scrutari.jQuery.convert(jqArgument);
var length = $elements.length;
for(let i = 0; i < length; i++) {
let jqEl = $($elements[i]);
let currentText =jqEl.text();
let alterText = jqEl.data(alterDataKey);
jqEl.text(alterText);
jqEl.data(alterDataKey, currentText);
}
return $elements;
};
Scrutari.Utils.toggle.classes = function (jqArgument, state, onClass, offClass) {
var $elements = Scrutari.jQuery.convert(jqArgument);
if (state === 'off') {
$elements.addClass(offClass).removeClass(onClass);
} else {
$elements.removeClass(offClass).addClass(onClass);
}
return $elements;
};
Scrutari.Utils.getBaseSortFunction = function (baseSortType, locales) {
var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
switch(baseSortType) {
case "fiche-count":
return _ficheCountSort;
case "title":
return _titleSort;
default:
return null;
}
function _ficheCountSort(base1, base2) {
var count1 = base1.stats.fiche;
var count2 = base2.stats.fiche;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
return Scrutari.Utils.compareCodebase(base1, base2);
}
}
function _titleSort(base1, base2) {
var title1 = base1.title;
var title2 = base2.title;
if (!title1) {
title1 = "";
}
if (!title2) {
title2 = "";
}
var comp = compareFunction(title1, title2);
if (comp !== 0) {
return comp;
} else {
return Scrutari.Utils.compareCodebase(base1, base2);
}
}
};
Scrutari.Utils.getCorpusSortFunction = function (corpusSortType, locales) {
var _ficheCountSort = function (corpus1, corpus2) {
var count1 = corpus1.stats.fiche;
var count2 = corpus2.stats.fiche;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
return Scrutari.Utils.compareCodecorpus(corpus1, corpus2);
}
};
var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
var _titleSort = function (corpus1, corpus2) {
var title1 = corpus1.title;
var title2 = corpus2.title;
if (!title1) {
title1 = "";
}
if (!title2) {
title2 = "";
}
var comp = compareFunction(title1, title2);
if (comp !== 0) {
return comp;
} else {
return Scrutari.Utils.compareCodecorpus(corpus1, corpus2);
}
};
switch(corpusSortType) {
case "fiche-count":
return _ficheCountSort;
case "title":
return _titleSort;
default:
return null;
}
};
Scrutari.Utils.getCategorySortFunction = function (categorySortType, locales) {
var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
switch(categorySortType) {
case "rank":
return _rankSort;
case "fiche-count":
return _ficheCountSort;
case "title":
return _titleSort;
default:
return null;
}
function _rankSort(category1, category2) {
let count1 = category1.rank;
let count2 = category2.rank;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
let code1 = category1.name;
let code2 = category2.name;
if (code1 < code2) {
return -1;
} else if (code1 > code2) {
return 1;
} else {
return 0;
}
}
}
function _ficheCountSort(category1, category2) {
let count1 = category1.stats.fiche;
let count2 = category2.stats.fiche;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
return _rankSort(category1, category2);
}
}
function _titleSort(category1, category2) {
let title1 = category1.title;
let title2 = category2.title;
if (!title1) {
title1 = "";
}
if (!title2) {
title2 = "";
}
let comp = compareFunction(title1, title2);
if (comp !== 0) {
return comp;
} else {
return _rankSort(category1, category2);
}
}
};
Scrutari.Utils.getLangSortFunction = function (langSortType, locales) {
var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
switch(langSortType) {
case "code":
return _codeSort;
case "fiche-count":
return _ficheCountSort;
case "title":
return _titleSort;
default:
return null;
}
function _codeSort(lang1, lang2) {
let code1 = lang1.lang;
let code2 = lang2.lang;
if (code1 < code2) {
return -1;
} else if (code1 > code2) {
return 1;
} else {
return 0;
}
}
function _ficheCountSort(lang1, lang2) {
let count1 = lang1.fiche;
let count2 = lang2.fiche;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
return _codeSort(lang1, lang2);
}
}
function _titleSort(lang1, lang2) {
let title1 = lang1.title;
let title2 = lang2.title;
if (!title1) {
title1 = lang1.lang;
}
if (!title2) {
title2 = lang2.lang;
}
let comp = compareFunction(title1, title2);
if (comp !== 0) {
return comp;
} else {
return _codeSort(lang1, lang2);
}
}
};
Scrutari.Utils.getGroupSortFunction = function (groupSortType) {
switch(groupSortType) {
case "fiche-count":
return _ficheCountSort;
default:
return null;
}
function _ficheCountSort(group1, group2) {
let count1 = group1.ficheCount;
let count2 = group2.ficheCount;
if (count1 > count2) {
return -1;
} else if (count1 < count2) {
return 1;
} else {
let rank1 = group1.category.rank;
let rank2 = group1.category.rank;
if (rank1 < rank2) {
return -1;
} else if (rank1 > rank2) {
return 1;
} else {
return 0;
}
}
}
};
Scrutari.Utils.mark = function (markArray, classAttribute) {
if (!classAttribute) {
classAttribute = "scrutari-Mark";
}
var html = "";
for (let obj of markArray) {
if (typeof obj === 'string') {
html += Scrutari.escape(obj);
} else if (obj.s) {
html += "";
html += Scrutari.escape(obj.s);
html += "";
}
}
return html;
};
Scrutari.Utils.unmark = function (markArray) {
var text = "";
for (let obj of markArray) {
if (typeof obj === 'string') {
text += obj;
} else if (obj.s) {
text += obj.s;
}
}
return text;
};
Scrutari.Utils.formatSearchSequence = function (client, searchUnit) {
var q = searchUnit.getQ();
q = q.replace(/\&\&/g, client.loc('_ and'));
q = q.replace(/\|\|/g, client.loc('_ or'));
return q;
};
Scrutari.Utils.render = function (templateString, object) {
var result = templateString;
for(let key in object) {
let normalReplace = new RegExp("{{:" + key + "}}", 'g');
let escapeReplace = new RegExp("{{>" + key + "}}", 'g');
let value = object[key];
result = result.replace(normalReplace, value);
result = result.replace(escapeReplace, Scrutari.escape(value));
}
return result;
};
Scrutari.Utils.compareCodebase = function (obj1, obj2) {
var code1 = obj1.codebase;
var code2 = obj2.codebase;
if (code1 < code2) {
return -1;
} else if (code1 > code2) {
return 1;
} else {
return 0;
}
};
Scrutari.Utils.compareCodecorpus = function (obj1, obj2) {
var code1 = obj1.codecorpus;
var code2 = obj2.codecorpus;
if (code1 < code2) {
return -1;
} else if (code1 > code2) {
return 1;
} else {
return 0;
}
};
Scrutari.Utils.getCompareLocaleFunction = function (locales) {
var _localeCompareSupportsLocales = function () {
try {
"a".localeCompare("b", "i");
} catch (exception) {
return exception.name === "RangeError";
}
return false;
};
var _localesCompare = function (string1, string2) {
return string1.localeCompare(string2, locales, {
usage: "sort",
sensitivity: "base",
ignorePunctuation: true});
};
var _oldCompare = function (string1, string2) {
string1 = string1.toLowerCase();
string2 = string2.toLowerCase();
return string1.localeCompare(string2);
};
if (_localeCompareSupportsLocales()) {
return _localesCompare;
} else {
return _oldCompare;
}
};
Scrutari.Utils.buildCorpusMap = function (scrutariMeta, arrays) {
var corpusMap = new Object();
var finalCount = 0;
if (arrays.categoryArray) {
finalCount++;
let arrayForCategories = scrutariMeta.getCorpusArrayForCategories(arrays.categoryArray);
for(let i = 0; i < arrayForCategories.length; i++) {
let key = "code_" + arrayForCategories[i];
if (corpusMap.hasOwnProperty(key)) {
corpusMap[key] = corpusMap[key] + 1;
} else {
corpusMap[key] = 1;
}
}
}
if (arrays.baseArray) {
finalCount++;
let arrayForBases = scrutariMeta.getCorpusArrayForBases(arrays.baseArray);
for(let i = 0; i < arrayForBases.length; i++) {
let key = "code_" + arrayForBases[i];
if (corpusMap.hasOwnProperty(key)) {
corpusMap[key] = corpusMap[key] + 1;
} else {
corpusMap[key] = 1;
}
}
}
if (arrays.corpusArrays) {
finalCount++;
for(let i = 0; i < arrays.corpusArrays.length; i++) {
let key = "code_" + arrays.corpusArrays[i];
if (corpusMap.hasOwnProperty(key)) {
corpusMap[key] = corpusMap[key] + 1;
} else {
corpusMap[key] = 1;
}
}
}
corpusMap.completeValue = finalCount;
return corpusMap;
};
Scrutari.Utils.checkKey = function (type, value) {
switch(type) {
case "base":
case "corpus":
return "code_" + value;
}
return value;
};
Scrutari.Utils.hasFilter = function (requestParameters) {
for(let prop in requestParameters) {
switch(prop) {
case "baselist":
case "corpuslist":
case "categorylist":
case "langlist":
var value = requestParameters[prop];
if (value) {
return true;
}
}
if (prop.indexOf("flt") === 0) {
return true;
}
}
return false;
};
Scrutari.Utils.extractFicheArray = function (ficheArray, paginationLength, paginationNumber) {
var startIndex = paginationLength * (paginationNumber - 1);
var length = ficheArray.length;
var extractArray = new Array();
if (startIndex >= length) {
return extractArray;
}
var min = Math.min(ficheArray.length, startIndex + paginationLength);
for(let i = startIndex; i < min; i++) {
extractArray.push(ficheArray[i]);
}
return extractArray;
};
Scrutari.Loc = function (map) {
if (map) {
this.map = map;
} else {
this.map = new Object();
}
};
Scrutari.Loc.prototype.putAll = function (map) {
for(var key in map) {
this.map[key] = map[key];
}
};
Scrutari.Loc.prototype.putLoc = function (locKey, locText) {
this.map[locKey] = locText;
};
Scrutari.Loc.prototype.loc = function (locKey, ...values) {
if (!this.map.hasOwnProperty(locKey)) {
return locKey;
}
var text = this.map[locKey];
var length = values.length;
if ((length === 1) && (Array.isArray(values[0]))) {
values = values[0];
length = values.length;
}
if (length > 0) {
for(let i = 0; i < length; i++) {
let mark = "{" + i + "}";
text = text.replace(mark, values[i]);
}
}
return text;
};
Scrutari.Loc.prototype.escape = function (locKey, ...values) {
if ((values.length === 1) && (Array.isArray(values[0]))) {
values = values[0];
}
return Scrutari.escape(this.loc(locKey, values));
};
Scrutari.Overlay = {};
Scrutari.Overlay.idNumber = 1;
Scrutari.Overlay.overlayInfoStack = new Array();
Scrutari.Overlay.closeTooltip = "Close";
Scrutari.Overlay.classPrefix = "scrutari-overlay";
Scrutari.Overlay.Info = function (overlayId, escapeClose, otherCloseKey) {
this.overlayId = overlayId;
this.escapeClose = escapeClose;
this.otherCloseKey = otherCloseKey;
this.afterEnd = null;
this.beforeEnd = null;
};
Scrutari.Overlay.addEscapeKeyHandler = function (target) {
$(target).on('keydown.overlay', function (event) {
var lastOverlayInfo = Scrutari.Overlay.getLastOverlayInfo();
if (lastOverlayInfo) {
let closeEvent = false;
if (lastOverlayInfo.escapeClose) {
if (event.key === "Escape") {
closeEvent = true;
}
}
if ((!closeEvent) && (lastOverlayInfo.otherCloseKey)) {
if (event.key === lastOverlayInfo.otherCloseKey) {
closeEvent = true;
}
}
if (closeEvent) {
event.preventDefault();
event.stopPropagation();
Scrutari.Overlay.end(lastOverlayInfo.overlayId);
}
}
});
};
Scrutari.Overlay.removeEscapeKeyHandler = function (target) {
$(target).off('keydown.overlay');
};
Scrutari.Overlay.getLastOverlayInfo = function () {
var length = Scrutari.Overlay.overlayInfoStack.length;
if (length > 0) {
return Scrutari.Overlay.overlayInfoStack[length - 1];
} else {
return null;
}
};
Scrutari.Overlay.getOverlayInfo = function (overlayId) {
for(let overlayInfo of Scrutari.Overlay.overlayInfoStack) {
if (overlayInfo.overlayId === overlayId) {
return overlayInfo;
}
}
return null;
};
Scrutari.Overlay.removeOverlayInfo = function (overlayId) {
for(let i = 0, len = Scrutari.Overlay.overlayInfoStack.length; i < len; i++) {
let overlayInfo = Scrutari.Overlay.overlayInfoStack[i];
if (overlayInfo.overlayId === overlayId) {
Scrutari.Overlay.overlayInfoStack.splice(i, 1);
break;
}
}
if (Scrutari.Overlay.overlayInfoStack.length === 0) {
Scrutari.Overlay.removeEscapeKeyHandler(document);
}
};
Scrutari.Overlay.addOverlayInfo = function (overlayInfo) {
if (Scrutari.Overlay.overlayInfoStack.length === 0) {
Scrutari.Overlay.addEscapeKeyHandler(document);
}
Scrutari.Overlay.overlayInfoStack.push(overlayInfo);
};
Scrutari.Overlay.start = function (settings) {
var closeTooltip = Scrutari.Overlay.closeTooltip;
if (settings.closeTooltip) {
closeTooltip = settings.closeTooltip;
}
var overlayIdNumber = Scrutari.Overlay.idNumber;
Scrutari.Overlay.idNumber++;
var overlayId = "overlay_" + overlayIdNumber;
var overlayInfo = new Scrutari.Overlay.Info(overlayId, _checkSetting("escapeClose", true));
Scrutari.Overlay.addOverlayInfo(overlayInfo);
var $overlayBlocker = $(_getDiv("blocker")).attr("data-overlay-role", "blocker").attr("tabindex", "-1");
var $overlayDialog = $(_getDiv("dialog")).appendTo($overlayBlocker);
$("body")
.append($overlayBlocker)
.css('overflow','hidden');
var overlayBody = _getDiv("header") + _getDiv("content") + _getDiv("footer");
var includeForm = false;
if (settings.formAttrs || settings.ajaxForm || settings.formSubmit) {
includeForm = true;
var $form = $("");
if (settings.formAttrs) {
for(var prop in settings.formAttrs) {
$form.attr(prop, settings.formAttrs[prop]);
}
}
if (settings.ajaxForm) {
var initialBeforeSubmit = settings.ajaxForm.beforeSubmit;
settings.ajaxForm.beforeSubmit = function (arr, $form, options) {
if ((initialBeforeSubmit) && (initialBeforeSubmit(arr, $form, options) === false)) {
return false;
}
_startWaiting();
};
var initialSuccess = settings.ajaxForm.success;
settings.ajaxForm.success = function (data, textStatus, jqXHR, $form) {
_endWaiting();
initialSuccess(data, textStatus, jqXHR, $form);
};
$form.ajaxForm(settings.ajaxForm);
} else if (settings.formSubmit) {
$form.submit(function () {
return settings.formSubmit($(this));
});
}
$overlayDialog.append($form.html(overlayBody));
$form.data("overlayId", overlayId);
} else {
$overlayDialog.html(overlayBody);
}
_setContent("header", settings.header);
_setContent("content", settings.content);
_setContent("footer", settings.footer);
var clickClose = _checkSetting("clickClose", true);
var showClose = _checkSetting("showClose", true);
$overlayBlocker
.click(function() {
if (clickClose) {
Scrutari.Overlay.end(overlayId);
}
})
.css("z-index", 10000 + overlayIdNumber);
overlayInfo.beforeEnd = settings.beforeEnd;
overlayInfo.afterEnd = settings.afterEnd;
if (showClose) {
$overlayDialog
.append("")
.on("click.overlay", "[data-overlay-role='close']", function () {
Scrutari.Overlay.end(overlayId);
});
}
$overlayDialog
.click(function (event) {
event.stopPropagation();
});
if (settings.isWaiting) {
_startWaiting();
}
$overlayBlocker.fadeIn(function () {
$overlayDialog.show();
if (settings.afterStart) {
settings.afterStart(overlayId, _endWaiting);
} else if (includeForm) {
$overlayDialog.find(":input").filter("[type!='hidden']").first().trigger("focus");
}
setTimeout(function () {
overlayInfo.otherCloseKey = _checkSetting("closeKey", null);
}, 300);
});
return overlayId;
function _checkSetting(propName, defaultValue) {
if (settings.hasOwnProperty(propName)) {
return settings[propName];
}
return defaultValue;
}
function _setContent (name, content) {
let $element = $("#" + _getId(name));
if (!content) {
$element.remove();
} else if (content.jquery) {
$element.empty().append(content);
} else {
$element.empty().html(content);
}
}
function _startWaiting() {
$overlayBlocker.find("[type='submit']").prop("disabled", true);
$overlayBlocker.addClass(Scrutari.Overlay.classPrefix + "-Waiting");
}
function _endWaiting() {
$overlayBlocker.find("[type='submit']").prop("disabled", false);
$overlayBlocker.removeClass(Scrutari.Overlay.classPrefix + "-Waiting");
}
function _getDiv(name) {
return "";
}
function _getId(name) {
return overlayId + "_" + name;
}
function _getClass(suffix) {
if ((settings.classes) && (settings.classes.hasOwnProperty(suffix))) {
return settings.classes[suffix];
}
let prefix = Scrutari.Overlay.classPrefix + "-Component_";
if (settings.classPrefix) {
prefix = settings.classPrefix;
}
if ((settings.supplementaryClasses) && (settings.supplementaryClasses.hasOwnProperty(suffix))) {
return prefix + suffix + " " + settings.supplementaryClasses[suffix];
} else {
return prefix + suffix;
}
}
};
Scrutari.Overlay.end = function (overlayId, callback) {
if ((overlayId) && (overlayId.jquery)) {
overlayId = overlayId.data("overlayId");
}
if (!overlayId) {
return;
}
var overlayInfo = Scrutari.Overlay.getOverlayInfo(overlayId);
if (!overlayInfo) {
return;
}
if (overlayInfo.beforeEnd) {
var result = overlayInfo.beforeEnd(overlayId);
if (result === false) {
return;
}
}
var afterEnd = overlayInfo.afterEnd;
Scrutari.Overlay.removeOverlayInfo(overlayId);
$("#" + overlayId + "_blocker").empty().fadeOut(function() {
$("#" + overlayId + "_blocker").remove();
if ($("body").children("[data-overlay-role='blocker']").length === 0) {
$("body").css('overflow','');
}
if (afterEnd) {
afterEnd();
}
if (callback) {
callback();
}
});
};
Scrutari.FilterState = function () {
this.empty = true;
this.langOnly = true;
this.all = {
category: true,
base: true,
corpus: true,
lang: true
};
this.maps = {
category: {},
base: {},
corpus: {},
lang: {}
};
this.titles = {
category: [],
base: [],
corpus: [],
lang: []
};
};
Scrutari.FilterState.prototype.contains = function (type, key) {
if (this.all[type]) {
return true;
}
key = Scrutari.Utils.checkKey(type, key);
return this.maps[type].hasOwnProperty(key);
};
Scrutari.FilterState.prototype.add = function (type, key, title) {
this.all[type] = false;
this.empty = false;
if (type !== "lang") {
this.langOnly = false;
}
key = Scrutari.Utils.checkKey(type, key);
if (!this.maps[type].hasOwnProperty(key)) {
if (!title) {
title = key;
}
this.maps[type][key] = title;
this.titles[type].push(title);
}
};
Scrutari.Stats = function (scrutariMeta) {
this.unitArray = new Array();
var maps = {
category: {},
base: {},
corpus: {},
lang: {}
};
this.maps = maps;
this.filterState = null;
for(let corpus of scrutariMeta.getCorpusArray()) {
let langArray = corpus.stats.langArray;
let category = scrutariMeta.getCategoryForCorpus(corpus.codecorpus);
let categoryName = "";
if (category) {
categoryName = category.name;
}
for(let lang of langArray) {
let unit = new Scrutari.Stats.Unit(categoryName, corpus.codebase, corpus.codecorpus, lang.lang, lang.fiche);
this.unitArray.push(unit);
_addInMap("category", unit, categoryName);
_addInMap("base", unit, "code_" + corpus.codebase);
_addInMap("corpus", unit, "code_" + corpus.codecorpus);
_addInMap("lang", unit, lang.lang);
}
}
function _addInMap(type, unit, key) {
var map = maps[type];
if (!map.hasOwnProperty(key)) {
map[key] = new Array();
}
map[key].push(unit);
}
};
Scrutari.Stats.prototype.update = function (filterState) {
this.filterState = filterState;
};
Scrutari.Stats.prototype.getFicheCount = function (type, key) {
key = Scrutari.Utils.checkKey(type, key);
var map = this.maps[type];
if (!map.hasOwnProperty(key)) {
return 0;
}
var count = 0;
for(let unit of map[key]) {
count += unit.check(this.filterState);
}
return count;
};
Scrutari.Stats.Unit = function (category, base, corpus, lang, value) {
this.category = category;
this.base = base;
this.corpus = corpus;
this.lang = lang;
this.value = value;
};
Scrutari.Stats.Unit.prototype.check = function (filterState) {
if (!filterState) {
return this.value;
}
if (!filterState.contains("category", this.category)) {
return 0;
}
if (!filterState.contains("base", this.base)) {
return 0;
}
if (!filterState.contains("corpus", this.corpus)) {
return 0;
}
if (!filterState.contains("lang", this.lang)) {
return 0;
}
return this.value;
};
Scrutari.History = function (client) {
this.client = client;
this.currentSearchUnit = null;
this.mainCurrentSearchUnit = null;
this._historyNumber = 0;
this._searchUnitMap = new Map();
};
Scrutari.History.prototype.addSearchUnit = function (searchUnit) {
var history = this;
var client = this.client;
var searchOrigin = searchUnit.searchOrigin;
this.currentSearchUnit = searchUnit;
if (searchOrigin === "mainsearch") {
history.mainCurrentSearchUnit = searchUnit;
_addToHistory();
} else if (searchOrigin === "subsearch") {
let subsearchText = "+ " + Scrutari.Utils.formatSearchSequence(client, searchUnit) + " = " + searchUnit.getFicheCount();
if (history.currentHistoryName) {
client.$component(client.$block(history.currentHistoryName), "subsearch").text(subsearchText);
}
}
function _addToHistory () {
let $historyListBlock = client.$block("historyList");
if (!Scrutari.jQuery.exists($historyListBlock)) {
return;
}
if (history.currentHistoryName) {
var $historyBlock = client.$block(history.currentHistoryName);
$historyBlock.removeClass(client.cssClasses.activeHistory);
client.$component($historyBlock, "subsearch").empty();
}
let historyName = "history_" + history.newHistoryNumber();
history.updateCurrent(historyName);
history.storeSearchUnit(historyName, searchUnit);
let contextObj = {
searchUnit: searchUnit,
name: historyName,
fichestat: searchUnit.getFicheCount(),
sequence: Scrutari.Utils.formatSearchSequence(client, searchUnit)
};
let html = client.render("history", contextObj);
if (client.options.historyAtLast) {
$historyListBlock.append(html);
} else {
$historyListBlock.prepend(html);
}
}
};
Scrutari.History.prototype.removeHistory = function (historyName) {
this.unstoreSearchUnit(historyName);
this.client.$block(historyName).remove();
};
Scrutari.History.prototype.loadHistory = function (historyName) {
var history = this;
var client = this.client;
var historySearchUnit = history.getSearchUnit(historyName);
if (historySearchUnit) {
let $historyBlock = client.$block(historyName);
history.currentSearchUnit = historySearchUnit;
history.mainCurrentSearchUnit = historySearchUnit;
history.updateCurrent(historyName);
$historyBlock.addClass(client.cssClasses.activeHistory);
client.displaySearchUnit(historySearchUnit, false);
if (client.functions.searchCallbacks.mainsearch) {
client.functions.searchCallbacks.mainsearch(client, historySearchUnit);
}
}
};
Scrutari.History.prototype.updateCurrent = function (historyName) {
var client = this.client;
if (this.currentHistoryName) {
let $historyBlock = client.$block(this.currentHistoryName);
$historyBlock.removeClass(client.cssClasses.activeHistory);
client.$component($historyBlock, "subsearch").empty();
}
this.currentHistoryName = historyName;
};
Scrutari.History.prototype.newHistoryNumber = function () {
this._historyNumber++;
return this._historyNumber;
};
Scrutari.History.prototype.storeSearchUnit = function (historyName, searchUnit) {
this._searchUnitMap.set(historyName, searchUnit);
};
Scrutari.History.prototype.unstoreSearchUnit = function (historyName) {
this._searchUnitMap.delete(historyName);
};
Scrutari.History.prototype.getSearchUnit = function (historyName) {
return this._searchUnitMap.get(historyName);
};
Scrutari.History.prototype.clear = function () {
this._searchUnitMap.clear();
this.client.$block("historyList").empty();
};
Scrutari.Client = function (api, clientId) {
this.api = api;
this.scrutariConfig = api;
this.clientId = clientId;
this.history = new Scrutari.History(this);
this.scrutariMeta = null;
this.completor = null;
this.stats = null;
this.isWaiting = false;
this.options = {
withCorpus: false,
baseSort: "fiche-count",
corpusSort: "fiche-count",
categorySort: "rank",
langSort: "code",
initialQuery: "",
initialQId: "",
initialFilters: null,
permalinkPattern: null,
ficheTarget: "_blank",
ignoreIcon: false,
ignoreThumbnail: false,
ficheBodyList: null,
mainTitle: null,
historyAtLast: false,
hooks: {},
functions: {
uiInit: null
},
cssClasses: {
},
structureOptions: {
}
};
this.functions = {
actionHandler: Scrutari.DefaultUi.actionHandler,
buildSearchRequestParameters: Scrutari.DefaultUi.buildSearchRequestParameters,
buildFilterState: Scrutari.DefaultUi.buildFilterState,
changeHandler: Scrutari.DefaultUi.changeHandler,
checkInitialQuery: Scrutari.DefaultUi.checkInitialQuery,
displayError: Scrutari.DefaultUi.displayError,
endLoading: Scrutari.DefaultUi.endLoading,
ignoreElement: Scrutari.DefaultUi.ignoreElement,
initFilterByQuery: Scrutari.DefaultUi.initFilterByQuery,
initForms: Scrutari.DefaultUi.initForms,
isFilterEnable: Scrutari.DefaultUi.isFilterEnable,
modalAction: Scrutari.DefaultUi.modalAction,
newSearchDisplay: Scrutari.DefaultUi.newSearchDisplay,
startLoading: Scrutari.DefaultUi.startLoading
};
this.searchCallbacks = {
mainsearch: Scrutari.DefaultUi.mainsearchCallback,
qidsearch: Scrutari.DefaultUi.qidsearchCallback,
subsearch: Scrutari.DefaultUi.subsearchCallback
};
this.errorCallbacks = {
mainsearch: null,
qidsearch: null,
subsearch: null
};
this.cssClasses = {
disabled: "scrutari-Disabled",
excluded: "scrutari-Excluded",
hidden: "scrutari-Hidden",
mark: "scrutari-Mark",
on: "scrutari-On",
activeHistory: "scrutari-history-Active",
activePanel: "scrutari-panel-Active",
filterStat: "scrutari-stats-Filter",
noneStat: "scrutari-stats-None"
};
this._locInstance = new Scrutari.Loc();
this._ignoreArray = new Array();
this._ficheBodyTemplateArray = [
"fiche_mtitre",
"fiche_msoustitre",
"fiche_year",
"fiche_primaryattributearray",
"fiche_mcomplementarray",
"fiche_secondaryattributearray",
"fiche_motclearray",
"fiche_bythesaurusarray"
];
this._structureMap = new Map();
this._templateMap = new Map();
this._paginationMap = new Map();
if (typeof SCRUTARI_L10N !== 'undefined') {
this._locInstance.putAll(SCRUTARI_L10N);
}
if (typeof SCRUTARI_HTML !== 'undefined') {
this._htmlObject = SCRUTARI_HTML;
}
};
Scrutari.Client.prototype.loc = function (locKey) {
return this._locInstance.loc(locKey);
};
Scrutari.Client.prototype.toPermalink = function (qId) {
if (this.options.permalinkPattern) {
return this.api.getPermalinkUrl(qId, this.options.permalinkPattern);
}
return null;
};
Scrutari.Client.prototype.ignoreElement = function (elementName) {
for(let ignorable of this._ignoreArray) {
if (ignorable.mode === "start") {
if (elementName.startsWith(ignorable.token)) {
return true;
}
} else {
if (elementName === ignorable.token) {
return true;
}
}
}
if (this._ignoreArray.indexOf(elementName) > -1) {
return true;
}
if (this.functions.ignoreElement) {
if (this.functions.ignoreElement(elementName)) {
return true;
}
}
return false;
};
Scrutari.Client.prototype.getTemplate = function (templateName) {
var template = this.hook("getTemplate", templateName);
if (template) {
if (typeof template === "function") {
return template;
} else {
Scrutari.log("getTemplate hook does not return function for template name: " + templateName);
}
}
if (templateName.indexOf(":") === -1) {
templateName = "scrutari:" + templateName;
}
template = $.templates[templateName];
if (!template) {
return function () {
return "Unknown template : " + templateName;
};
} else {
return template;
}
};
Scrutari.Client.prototype.render = function (templateName, context, helpers) {
var templateFunction = this.getTemplate(templateName);
return templateFunction(context, helpers);
};
Scrutari.Client.prototype.hook = function (name) {
var hook = _getHook(this.options.hooks, name);
if (!hook) {
return;
}
if (typeof hook === "function") {
var newArgs = new Array();
var argLength = arguments.length;
if (argLength > 1) {
for(let i = 1; i < argLength; i++) {
newArgs.push(arguments[i]);
}
}
hook.apply(this, newArgs);
}
function _getHook(hooks, name) {
if (hooks.hasOwnProperty(name)) {
return hooks[name];
}
let alias;
switch(name) {
case "beforeSearchDisplay":
alias = ["showResult", "afterResultProcess"];
break;
case "afterSearchDisplay":
alias = ["beforeResultProcess"];
break;
case "afterPaginationChange":
alias = ["paginationChange"];
break;
}
if (alias) {
for (let al of alias) {
if (hooks.hasOwnProperty(al)) {
return hooks[al];
}
}
}
return false;
}
};
Scrutari.Client.prototype.getFicheBodyTemplateArray = function (fiche, ficheGroupName) {
var array = this.hook("getFicheBodyTemplateArray", fiche, ficheGroupName);
if (array) {
return array;
} else {
return this._ficheBodyTemplateArray;
}
};
Scrutari.Client.prototype.startOverlay = function (settings) {
return Scrutari.Overlay.start(settings);
};
Scrutari.Client.prototype.endOverlay = function (overlayId, callback) {
return Scrutari.Overlay.end(overlayId, callback);
};
Scrutari.Client.prototype.$ = function (properties) {
var $client = Scrutari.jQuery.find(this.clientId);
return Scrutari.jQuery.find($client, properties);
};
Scrutari.Client.prototype.$area = function (name, action) {
var $area = this.$({scrutariArea: name});
if (action) {
switch(action) {
case 'show':
this.show($area);
break;
case 'hide':
this.hide($area);
break;
}
}
return $area;
};
Scrutari.Client.prototype.$block = function (name, suffix) {
var $block;
if (suffix === '*') {
$block = this.$({"scrutariBlock|": name});
} else if (suffix) {
$block = this.$({scrutariBlock: name + "-" + suffix});
} else {
$block = this.$({scrutariBlock: name});
}
return $block;
};
Scrutari.Client.prototype.$action = function (name, target) {
if (target) {
return this.$({scrutariAction: name, scrutariTarget: target});
} else {
return this.$({scrutariAction: name});
}
};
Scrutari.Client.prototype.$component = function ($parent, name) {
return Scrutari.jQuery.find($parent, {scrutariComponent: name});
};
Scrutari.Client.prototype.$count = function (name, action, value) {
var $count = this.$({scrutariCount: name});
if (action) {
switch(action) {
case 'update':
if (!value) {
value = 0;
}
this.$component($count, "value").html(this.formatNumber(value));
break;
}
}
return $count;
};
Scrutari.Client.prototype.$form = function (name) {
return this.$({scrutariForm: name});
};
Scrutari.Client.prototype.$hidden = function (name, action) {
var $hidden = this.$({scrutariHidden: name});
if (action) {
switch(action) {
case 'show':
this.show ($hidden);
break;
case 'hide':
this.hide($hidden);
break;
}
}
return $hidden;
};
Scrutari.Client.prototype.$input = function (name, value) {
if (value) {
return this.$({_element: "input", _name: name, _value: value});
} else {
return this.$({_element: "input", _name: name});
}
};
Scrutari.Client.prototype.$input_checked = function (name, value) {
if (value) {
return this.$({_element: "input", _name: name, _value: value, _checked: true});
} else {
return this.$({_element: "input", _name: name, _checked: true});
}
};
Scrutari.Client.prototype.$label = function (name) {
return this.$({scrutariLabel: name});
};
Scrutari.Client.prototype.$link = function (name) {
return this.$({scrutariLink: name});
};
Scrutari.Client.prototype.$modal = function (name) {
return Scrutari.jQuery.find({scrutariModal: name});
};
Scrutari.Client.prototype.$panel = function (name, action) {
var $panel = this.$({scrutariPanel: name});
if (action) {
switch(action) {
case 'show':
this.show ($panel);
break;
case 'hide':
this.hide($panel);
break;
}
}
return $panel;
};
Scrutari.Client.prototype.show = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.removeClass(this.cssClasses.hidden);
};
Scrutari.Client.prototype.hide = function (jqArgument) {
var $elements = Scrutari.jQuery.convert(jqArgument);
$elements.addClass(this.cssClasses.hidden);
};
Scrutari.Client.prototype.scrollToResult = function () {
$(window).scrollTop(this.$area('result').offset().top);
};
Scrutari.Client.prototype.getStructureHtml = function (name) {
if (this._structureMap.has(name)) {
return this._structureMap.get(name);
} else {
Scrutari.log("Unknown structure: " + name);
return "";
}
};
Scrutari.Client.prototype.getStructureNameArray = function () {
var result = new Array();
for(let key of this._structureMap.keys()) {
result.push(key);
}
return result;
};
Scrutari.Client.prototype.compileStructure = function (name, options) {
var client = this;
var includedTexts = new Map();
var noLoc = false;
var withComment = false;
if (options) {
noLoc = options.noLoc;
withComment = options.withComment;
}
var html = _getText(name, "", "/");
if (!noLoc) {
html = html.replace(/_ [-_\.a-z0-9]+/g, function(match) {
return client.loc(match);
});
}
return html;
function _getText(name, indent, parent) {
if (name.endsWith('*')) {
return _getTextByPrefix(name.substring(0, name.length - 1), indent, parent);
}
if (includedTexts.has(name)) {
Scrutari.log("Already included: " + name);
return "";
} else if (client.ignoreElement(name)) {
return "";
}
includedTexts.set(name, true);
let result = "";
if (withComment) {
result += indent + "\n";
}
let text = client.getStructureHtml(name);
if (text.length > 0) {
let lines = text.split("\n");
for(let line of lines) {
if (line.trim().length === 0) {
continue;
}
let idx = line.indexOf("{{");
if (idx !== -1) {
let includedText = line.replace(/([ \t]*){{([-a-zA-z0-9_]+\*?)}}/g, function (match, p1, p2) {
let includeIndent = indent + p1;
return _getText(p2, includeIndent, parent + name + "/");
});
result += includedText;
if ((includedText.length > 0) && (!includedText.endsWith("\n"))) {
result += "\n";
}
} else {
result += indent + line + "\n";
}
}
}
if (withComment) {
result += indent + "\n";
}
return result;
}
function _getTextByPrefix(namePrefix, indent, parent) {
let result = "";
for(let name of client.getStructureNameArray()) {
if (name.startsWith(namePrefix)) {
result = result + _getText(name, indent, parent);
}
}
return result;
}
};
Scrutari.Client.prototype.checkInitialQuery = function () {
if (this.functions.checkInitialQuery) {
this.functions.checkInitialQuery(this);
}
};
Scrutari.Client.prototype.initForms = function () {
if (this.functions.initForms) {
this.functions.initForms(this);
}
};
Scrutari.Client.prototype.initActions = function () {
var client = this;
Scrutari.jQuery.find(client.clientId).on("click", "[data-scrutari-action]", function () {
let actionHandler;
if (client.functions.actionHandler) {
actionHandler = client.functions.actionHandler;
} else {
actionHandler = _noneHandler;
}
let button = this;
let action = this.dataset.scrutariAction;
let target = this.dataset.scrutariTarget;
let done = actionHandler(client, button, action, target);
if (!done) {
switch(action) {
case 'showModal':
if (client.functions.modalAction) {
client.functions.modalAction(client, target, 'show');
}
break;
case 'removeHistory':
client.history.removeHistory(target);
break;
case 'loadHistory':
client.history.loadHistory(target);
break;
case 'clearHistory':
client.history.clear();
break;
case 'ficheGroupTab':
_ficheGroupTab(target);
break;
case 'paginationTab':
_paginationTab(button);
break;
default:
Scrutari.log("Unknown action: " + action);
}
}
if ((this.tagName) && (this.tagName.toLowerCase() === 'a')) {
return false;
}
});
function _noneHandler() {
return false;
}
function _ficheGroupTab (target) {
let activeBlockName = "ficheGroup" + "-" + target;
client.$block("ficheGroup", "*").each(function (index, element) {
if (element.dataset.scrutariBlock === activeBlockName) {
client.show(element);
} else {
client.hide(element);
}
});
client.$action("ficheGroupTab").each(function (index, element) {
element.disabled = (element.dataset.scrutariTarget === target);
});
}
function _paginationTab (button) {
let newPaginationNumber = parseInt(button.dataset.scrutariNumber);
let pagination = client.getPagination(button.dataset.scrutariFicheGroupName);
if (pagination) {
pagination.change(newPaginationNumber);
if (button.dataset.scrutariPosition === "bottom") {
client.scrollToResult();
}
}
}
};
Scrutari.Client.prototype.initChangeListeners = function () {
var client = this;
Scrutari.jQuery.find(this.clientId).on("input", "input", function () {
let changeHandler;
if (client.functions.changeHandler) {
changeHandler = client.functions.changeHandler;
} else {
changeHandler = _noneHandler;
}
let element = this;
let name = this.name;
if (name) {
let done = changeHandler(client, element, name);
if (!done) {
switch(name) {
case 'q-mode':
if (this.value === 'operation') {
Scrutari.Utils.disable("input[name='wildchar']");
} else {
Scrutari.Utils.enable("input[name='wildchar']");
}
break;
}
}
}
});
function _noneHandler() {
return false;
}
};
Scrutari.Client.prototype.searchCallback = function (searchUnit) {
var client = this;
client.displaySearchUnit(searchUnit, true);
client.endLoading();
if (client.searchCallbacks.hasOwnProperty(searchUnit.searchOrigin)) {
client.searchCallbacks[searchUnit.searchOrigin](client, searchUnit);
}
};
Scrutari.Client.prototype.errorCallback = function (error, searchOrigin) {
var client = this;
if (client.functions.displayError) {
client.functions.displayError(client, error, searchOrigin);
}
client.endLoading();
if (client.errorCallbacks.hasOwnProperty(searchOrigin)) {
client.errorCallbacks[searchOrigin](client, error);
}
};
Scrutari.Client.prototype.buildSearchRequestParameters = function (customParameters) {
if (this.functions.buildSearchRequestParameters) {
return this.functions.buildSearchRequestParameters(this, customParameters);
} else if (customParameters) {
return Object.assign({}, customParameters);
} else {
return {};
}
};
Scrutari.Client.prototype.buildFilterState = function () {
if (this.functions.buildFilterState) {
return this.functions.buildFilterState(this);
} else {
return new Scrutari.FilterState();
}
};
Scrutari.Client.prototype.getTemplateHtml = function (name) {
if (this._templateMap.has(name)) {
return this._templateMap.get(name);
} else {
Scrutari.log("Unknown template: " + name);
return "";
}
};
Scrutari.Client.prototype.formatNumber = function (number) {
if (Number.prototype.toLocaleString) {
return number.toLocaleString(this.api.lang);
} else {
return number;
}
};
Scrutari.Client.prototype.completeFiche = function(searchUnit, fiche, ficheGroupName) {
if (fiche._isCompleted) {
return fiche;
}
var client = this;
var completor = client.completor;
var options = client.options;
completor.complementTitle(fiche);
completor.motcleArray(fiche, _motcleProvider);
completor.bythesaurusArray(fiche, _motcleProvider);
if (Scrutari.hasMarkedAttribute(fiche)) {
completor.markedAttributeArray(fiche, "primary");
completor.markedAttributeArray(fiche, "secondary");
}
if (!options.ignoreThumbnail) {
completor.thumbnail(fiche);
}
if (!options.ignoreIcon) {
completor.icon(fiche);
}
if (options.ficheTarget) {
completor.target(fiche, options.ficheTarget);
}
fiche._bodyTemplateArray = client.getFicheBodyTemplateArray(fiche, ficheGroupName);
fiche._isCompleted = true;
client.hook("completeFiche", searchUnit, fiche, ficheGroupName);
return fiche;
function _motcleProvider(code) {
return searchUnit.getMotcle(code);
}
};
Scrutari.Client.prototype.getPagination = function (ficheGroupName) {
if (!ficheGroupName) {
ficheGroupName = "";
}
return this._paginationMap.get(ficheGroupName);
};
Scrutari.Client.prototype.putPagination = function (ficheGroupName, pagination) {
if (!ficheGroupName) {
ficheGroupName = "";
}
this._paginationMap.set(ficheGroupName, pagination);
};
Scrutari.Client.prototype.clearPagination = function () {
this._paginationMap.clear();
};
Scrutari.Client.prototype.displaySearchUnit = function (searchUnit, addToHistory) {
var client = this;
var searchDisplay;
if (client.functions.newSearchDisplay) {
searchDisplay = client.functions.newSearchDisplay(client, searchUnit);
}
if (!searchDisplay) {
searchDisplay = new Scrutari.SearchDisplay(client, searchUnit);
}
if (addToHistory) {
client.history.addSearchUnit(searchUnit);
}
searchDisplay.run();
};
Scrutari.Client.prototype.startLoading = function () {
if (this.functions.startLoading) {
this.functions.startLoading(this);
}
};
Scrutari.Client.prototype.endLoading = function () {
if (this.functions.endLoading) {
this.functions.endLoading(this);
}
};
Scrutari.Client.init = function (api, clientId, options, callback) {
if (!$.templates) {
throw new Error("JsRender is not installed");
}
var uiInitFunction = Scrutari.DefaultUi.init;
api.initMeta(function (scrutariMeta) {
var client = new Scrutari.Client(api, clientId);
client.scrutariMeta = scrutariMeta;
client.completor = new Scrutari.Completor(scrutariMeta);
client.stats = new Scrutari.Stats(scrutariMeta);
_checkOptions(client, scrutariMeta);
_initHelpers(client);
_initMaps(client);
uiInitFunction(client);
if (callback) {
callback(client);
}
});
function _checkOptions (client, scrutariMeta) {
var defaultOptions = scrutariMeta.getDefaultOptions();
for(let key in defaultOptions) {
client.options[key] = defaultOptions[key];
}
if (options) {
for(let key in options) {
client.options[key] = options[key];
}
if (options.functions) {
for(let functionKey in options.functions) {
switch(functionKey) {
case "uiInit":
uiInitFunction = options.functions[functionKey];
break;
default:
client.functions[functionKey] = options.functions[functionKey];
}
}
}
if (options.searchCallbacks) {
for(let callbackKey in options.searchCallbacks) {
client.searchCallbacks[callbackKey] = options.searchCallbacks[callbackKey];
}
}
if (options.errorCallbacks) {
for(let callbackKey in options.errorCallbacks) {
client.errorCallbacks[callbackKey] = options.errorCallbacks[callbackKey];
}
}
if (options.cssClasses) {
for(let cssKey in options.cssClasses) {
client.cssClasses[cssKey] = options.cssClasses[cssKey];
}
}
if (options.locMap) {
client._locInstance.putAll(options.locMap);
}
if (options.ignoreList) {
let ignoreList = options.ignoreList;
let ignoreArray;
if (typeof ignoreList === "string") {
ignoreArray = ignoreList.split(",");
} else if (Array.isArray(ignoreList)) {
ignoreArray = ignoreList;
}
if (ignoreArray) {
for(let ignore of ignoreArray) {
let token = ignore.trim();
if (token.endsWith('*')) {
client._ignoreArray.push({token: token.substring(0, token.length - 1), mode:"start"})
} else {
client._ignoreArray.push({token: token, mode:"equal"})
}
}
}
}
if (options.ficheBodyList) {
let ficheBodyList = options.ficheBodyList;
let array1;
if (typeof ficheBodyList === "string") {
array1 = ficheBodyList.split(",");
} else if (Array.isArray(ficheBodyList)) {
array1 = ficheBodyList;
}
if (array1) {
let array2 = new Array();
for(let token of array1) {
token = token.trim();
if (token.length > 0) {
array2.push(token);
}
}
if (array2.length > 0) {
client._ficheBodyTemplateArray = array2;
}
}
}
}
}
function _initHelpers (client) {
$.views.helpers({
scrutari_client: client,
scrutari_loc: function(key, ...values) {
return client.loc(key, values);
},
scrutari_format: function(number) {
return client.formatNumber(number);
},
scrutari_mark: function (markArray) {
return Scrutari.Utils.mark(markArray, client.cssClasses.mark);
},
scrutari_unmark: function (markArray) {
return Scrutari.Utils.unmark(markArray);
}
});
}
function _initMaps (client) {
__initHtmlObject(client._htmlObject);
__initHtmlObject(options.htmlObject);
$("script[type='text/x-scrutari-structure']").each(function (index, element) {
client._structureMap.set(element.dataset.name, $(element).html());
});
$("script[type='text/x-scrutari-template']").each(function (index, element) {
client._templateMap.set(element.dataset.name, $(element).html());
});
for(let entries of client._templateMap.entries()) {
let templateText = entries[1];
templateText = templateText.replace(/tmpl=\"([-_0-9a-z]+)\"/g, 'tmpl="scrutari:$1"');
$.templates("scrutari:" + entries[0], templateText);
}
function __initHtmlObject (htmlObject) {
if (htmlObject) {
if (htmlObject.structure) {
for(let key in htmlObject.structure) {
client._structureMap.set(key, htmlObject.structure[key]);
}
}
if (htmlObject.templates) {
for(let key in htmlObject.templates) {
client._templateMap.set(key, htmlObject.templates[key]);
}
}
}
}
}
};
Scrutari.Pagination = function (client, source, ficheGroupName) {
this.client = client;
this.ficheGroupName = ficheGroupName;
this.paginationLength = client.api.options.paginationLength;
if (!source) {
throw new Error("name undefined");
}
if (source instanceof Scrutari.SearchUnit) {
this.searchUnit = source;
this.customFicheArray = null;
} else {
this.searchUnit = null;
this.customFicheArray = source;
}
};
Scrutari.Pagination.prototype.change = function (paginationNumber) {
var pagination = this;
var client = pagination.client;
var ficheGroupName = pagination.ficheGroupName;
var paginationLength = pagination.paginationLength;
var ficheCount, paginationFicheArray;
if (pagination.searchUnit) {
_fromSearchUnit();
} else {
_fromCustom();
}
var hookParams = _getHookParams();
if (!paginationFicheArray) {
return;
}
client.hook("beforePaginationChange", paginationFicheArray, hookParams);
client.$block("ficheList", ficheGroupName).html(client.render("fiche", paginationFicheArray));
_setTabs();
client.hook("afterPaginationChange", paginationFicheArray, hookParams);
function _fromSearchUnit() {
let searchUnit = pagination.searchUnit;
ficheCount = searchUnit.getFicheCount(ficheGroupName);
paginationFicheArray = pagination.extractPaginationFicheArray(searchUnit, paginationNumber);
}
function _fromCustom() {
ficheCount = pagination.customFicheArray.length;
paginationFicheArray = Scrutari.Utils.extractFicheArray(pagination.customFicheArray, paginationLength, paginationNumber);
}
function _getHookParams() {
if (ficheGroupName) {
return {
paginationNumber: paginationNumber,
ficheGroupName: ficheGroupName
};
} else {
return {
paginationNumber:paginationNumber
};
}
}
function _setTabs() {
var tabArray = Scrutari.Utils.getTabArray(ficheCount, paginationLength, paginationNumber);
var topBlock = "topTabs" ;
var bottomBlock = "bottomTabs";
var type = "unique";
if (ficheGroupName) {
topBlock = topBlock + "-" + ficheGroupName;
bottomBlock = bottomBlock + "-" + ficheGroupName;
type = "group";
}
var template = client.getTemplate("tabs");
client.$block(topBlock).html(template({
tabArray: tabArray,
type: type,
ficheGroupName: ficheGroupName,
position: "top"
}));
client.$block(bottomBlock).html(template({
tabArray: tabArray,
type: type,
ficheGroupName: ficheGroupName,
position: "bottom"
}));
}
};
Scrutari.Pagination.prototype.extractPaginationFicheArray = function (searchUnit, paginationNumber) {
var pagination = this;
var client = this.client;
var paginationArg = {
length: pagination.paginationLength,
number: paginationNumber
};
var ficheGroupName = this.ficheGroupName;
if (!searchUnit.isLoaded({pagination: paginationArg, ficheGroupName: ficheGroupName})) {
if (client.isWaiting) {
return;
}
client.$block("ficheList", ficheGroupName).html(client.render("loading", {searchUnit: searchUnit}));
client.isWaiting = true;
searchUnit.loadFiches({
pagination: paginationArg,
ficheGroupName: ficheGroupName,
callback:function () {
client.isWaiting = false;
pagination.change(paginationNumber);
}
});
return false;
}
return searchUnit.extractFicheArray({pagination: paginationArg, ficheGroupName: ficheGroupName});
};
Scrutari.SearchDisplay = function (client, searchUnit) {
this.client = client;
this.searchUnit = searchUnit;
};
Scrutari.SearchDisplay.prototype.run = function () {
var client = this.client;
var searchUnit = this.searchUnit;
client.hook("beforeSearchDisplay", searchUnit);
client.clearPagination();
var ficheCount = searchUnit.getFicheCount();
var $paginationBlock = this.getPaginationBlock();
if (!this.checkNotEmpty(ficheCount, $paginationBlock)) {
return;
}
this.checkThreshold(ficheCount);
this.updateLinks();
this.addPaginations($paginationBlock);
client.hook("afterSearchDisplay", searchUnit);
};
Scrutari.SearchDisplay.prototype.getPaginationBlock = function () {
var $paginationBlock = this.client.$block("paginationBlock");
$paginationBlock.empty();
return $paginationBlock;
};
Scrutari.SearchDisplay.prototype.checkNotEmpty = function (ficheCount, $paginationBlock) {
var client = this.client;
client.$hidden("start", 'show');
if (ficheCount === 0) {
this.processEmpty($paginationBlock);
return false;
} else {
this.client.$hidden("empty", 'show');
return true;
}
};
Scrutari.SearchDisplay.prototype.processEmpty = function ($paginationBlock) {
var client = this.client;
var searchUnit = this.searchUnit;
client.$hidden("empty", 'hide');
let withFilter;
if (this.searchOrigin === "subsearch") {
withFilter = true;
} else {
withFilter = Scrutari.Utils.hasFilter(searchUnit.requestParameters);
}
$paginationBlock.html(client.render("pagination_empty", {withFilter: withFilter, searchUnit: searchUnit}));
};
Scrutari.SearchDisplay.prototype.checkThreshold = function (ficheCount) {
var client = this.client;
if (ficheCount >= client.api.options.subsearchThreshold) {
client.$hidden("threshold", 'show');
} else {
client.$hidden("threshold", 'hide');
}
};
Scrutari.SearchDisplay.prototype.updateLinks = function () {
var client = this.client;
var qId = this.searchUnit.getQId();
var permalink = client.toPermalink(qId);
if (permalink) {
client.$link("permalink").attr("href", permalink);
client.$label("permalinkValue").html(permalink);
}
_updateDownloadHref("ods");
_updateDownloadHref("csv");
_updateDownloadHref("atom");
function _updateDownloadHref(extension) {
client.$link(extension).attr("href", client.api.getDownloadUrl(qId, extension));
}
};
Scrutari.SearchDisplay.prototype.addPaginations = function ($paginationBlock) {
if (this.searchUnit.getFicheGroupType() === 'category') {
this.addCategoryPaginations($paginationBlock);
} else {
this.addUniquePagination($paginationBlock);
}
};
Scrutari.SearchDisplay.prototype.addCategoryPaginations = function ($paginationBlock) {
var client = this.client;
var searchUnit = this.searchUnit;
var contextObj = {
searchUnit: searchUnit,
array: new Array()
};
let active = true;
for(let ficheGroup of searchUnit.ficheGroupArray) {
let category = ficheGroup.category;
let metaCategory = client.scrutariMeta.getCategory(category.name);
if (metaCategory) {
category = metaCategory;
} else {
category.phraseMap = {};
category.attrMap = {};
}
let description = "";
if (category.phraseMap.description) {
description = category.phraseMap.description;
}
contextObj.array.push({
category: category,
name: category.name,
title: category.title,
description: description,
active: active,
fichestat: ficheGroup.ficheCount
});
active = false;
}
$paginationBlock.html(client.render("pagination_groups", contextObj));
for(let group of contextObj.array) {
let ficheGroupName = group.name;
let pagination = new Scrutari.Pagination(client, searchUnit, ficheGroupName);
client.putPagination(ficheGroupName, pagination);
pagination.change(1);
}
};
Scrutari.SearchDisplay.prototype.addUniquePagination = function ($paginationBlock) {
var client = this.client;
var searchUnit = this.searchUnit;
$paginationBlock.html(client.render("pagination_unique", {searchUnit: searchUnit}));
let uniquePagination = new Scrutari.Pagination(client, searchUnit);
client.putPagination("", uniquePagination);
uniquePagination.change(1);
};
Scrutari.DefaultUi = {};
Scrutari.DefaultUi.init = function (client) {
var scrutariMeta = client.scrutariMeta;
$("#" + client.clientId).html(client.compileStructure("main", client.options.structureOptions));
client.initForms();
client.initActions();
client.initChangeListeners();
Scrutari.DefaultUi.initMainTitle(client);
client.$count('stats-global', 'update', scrutariMeta.getGlobalFicheCount());
client.$hidden('init', 'show');
client.show(client.$action('parametersDisplay'));
var locales = client.api.lang;
var langArray = scrutariMeta.getLangArray();
if ((langArray.length > 1) && (Scrutari.jQuery.exists(client.$panel('lang')))) {
for(let i = 0, len = langArray.length; i < len; i++) {
let title = "";
let code = langArray[i].lang;
let label = scrutariMeta.getLangLabel(code);
if (label !== code) {
title = label;
}
langArray[i].title = title;
}
let langSortFunction = Scrutari.Utils.getLangSortFunction(client.options.langSort, locales);
if (langSortFunction) {
langArray = langArray.sort(langSortFunction);
}
Scrutari.DefaultUi.initColumns(client, langArray,"lang");
}
if ((scrutariMeta.withCategory()) && (Scrutari.jQuery.exists(client.$panel('category')))) {
let categoryArray = scrutariMeta.getCategoryArray(Scrutari.Utils.getCategorySortFunction(client.options.categorySort, locales));
Scrutari.DefaultUi.initColumns(client, categoryArray, "category");
}
if (client.options.withCorpus) {
if (Scrutari.jQuery.exists(client.$panel('corpus'))) {
let corpusArray = scrutariMeta.getCorpusArray(Scrutari.Utils.getCorpusSortFunction(client.options.corpusSort, locales));
if (corpusArray.length > 1) {
Scrutari.DefaultUi.initColumns(client, corpusArray, "corpus");
}
}
} else {
if (Scrutari.jQuery.exists(client.$panel('base'))) {
let baseArray = scrutariMeta.getBaseArray(Scrutari.Utils.getBaseSortFunction(client.options.baseSort, locales));
if (baseArray.length > 1) {
Scrutari.DefaultUi.initColumns(client, baseArray, "base");
}
}
}
var initialFilters = client.options.initialFilters;
if (initialFilters) {
_initFilter("baselist", "base");
_initFilter("corpuslist","corpus");
_initFilter("categorylist", "category");
_initFilter("langlist", "lang");
}
client.checkInitialQuery(client);
function _initFilter (optionName, target) {
if (!initialFilters.hasOwnProperty(optionName)) {
return;
}
Scrutari.DefaultUi.initFilter(client, target, initialFilters[optionName].split(","));
}
};
Scrutari.DefaultUi.initFilterByQuery = function (client, searchUnit) {
var searchOptions = searchUnit.searchMeta.options;
if (searchOptions) {
_initFilterByQuery(searchOptions.baselist, "base");
_initFilterByQuery(searchOptions.corpuslist, "corpus");
_initFilterByQuery(searchOptions.categorylist, "category");
_initFilterByQuery(searchOptions.langlist, "lang");
}
function _initFilterByQuery (list, target) {
if (list) {
Scrutari.DefaultUi.initFilter(client, target, list.array);
}
}
};
Scrutari.DefaultUi.initForms = function (client) {
client.$form('mainsearch').submit(function () {
let q = _getQ(this);
if (q.length > 0) {
let requestParameters = client.buildSearchRequestParameters({
"log": "all",
"q": q
});
client.startLoading();
client.hook("newSearch", requestParameters, "mainsearch");
client.api.loadFicheSearch({
requestParameters: requestParameters,
callback: function (ficheSearchResult) {
let searchUnit = new Scrutari.SearchUnit({
api: client.api,
ficheSearchResult: ficheSearchResult,
requestParameters: requestParameters,
completeFicheFunction: Scrutari.DefaultUi.getCompleteFicheFunction(client),
groupSortFunction: client.api.options.groupSortFunction,
searchOrigin: "mainsearch"
});
client.searchCallback(searchUnit);
},
errorCallback: function (error) {
client.errorCallback(error, "mainsearch");
}
});
}
return false;
});
client.$form('subsearch').submit(function () {
let q = _getQ(this);
if ((q.length > 0) && (client.history.mainCurrentSearchUnit)) {
let requestParameters = client.buildSearchRequestParameters({
"q": q,
"flt-qid": client.history.mainCurrentSearchUnit.getQId()
});
client.startLoading();
client.hook("newSearch", requestParameters, "subsearch");
client.api.loadFicheSearch({
requestParameters: requestParameters,
callback: function (ficheSearchResult) {
let searchUnit = new Scrutari.SearchUnit({
api: client.api,
ficheSearchResult: ficheSearchResult,
requestParameters: requestParameters,
completeFicheFunction: Scrutari.DefaultUi.getCompleteFicheFunction(client),
groupSortFunction: client.api.options.groupSortFunction,
searchOrigin: "subsearch"
});
client.searchCallback(searchUnit);
},
errorCallback: function (error) {
client.errorCallback(error, "subsearch");
}
});
}
return false;
});
function _getQ(form) {
let qInput = form["q"];
if (!qInput) {
Scrutari.log("missing q input");
return "";
}
let q = qInput.value;
if (q) {
return q.trim();
} else {
return "";
}
};
};
Scrutari.DefaultUi.checkInitialQuery = function (client) {
var initialQuery = client.options.initialQuery;
var initialQId = client.options.initialQId;
if (initialQuery) {
var $mainSearchForm = client.$form('mainsearch');
if (Scrutari.jQuery.exists($mainSearchForm)) {
$mainSearchForm.find("input[name='q']").val(initialQuery);
$mainSearchForm.submit();
}
} else if (initialQId) {
var requestParameters = client.buildSearchRequestParameters({
"qid": initialQId
});
client.startLoading();
client.hook("newSearch", requestParameters, "qidsearch");
client.api.loadFicheSearch({
requestParameters: requestParameters,
callback: function (ficheSearchResult) {
let searchUnit = new Scrutari.SearchUnit({
api: client.api,
ficheSearchResult: ficheSearchResult,
requestParameters: requestParameters,
completeFicheFunction: Scrutari.DefaultUi.getCompleteFicheFunction(client),
groupSortFunction: client.api.options.groupSortFunction,
searchOrigin: "qidsearch"
});
let $mainSearchForm = client.$form('mainsearch');
$mainSearchForm.find("input[name='q']").val(searchUnit.searchMeta.q);
$mainSearchForm.find("input[name='q-mode'][value='operation']").click();
if (client.functions.initFilterByQuery) {
client.functions.initFilterByQuery(client, searchUnit);
}
client.searchCallback(searchUnit);
},
errorCallback: function (error) {
client.errorCallback(error, "qidsearch");
}
});
}
};
Scrutari.DefaultUi.getCompleteFicheFunction = function (client) {
return function (searchUnit, fiche, categoryName) {
client.completeFiche(searchUnit, fiche, categoryName);
};
};
Scrutari.DefaultUi.ignoreElement = function (client, name) {
switch(name) {
case "panel-base":
return (client.options.withCorpus);
case "panel-corpus":
return (!client.options.withCorpus);
case "result-share":
return (!client.options.permalinkPattern);
}
return false;
};
Scrutari.DefaultUi.isFilterEnable = function (client, target) {
return (client.$action("enablePanel", target).data("scrutariState") === "on");
};
Scrutari.DefaultUi.mainsearchCallback = function (client, searchUnit) {
client.$count("stats-result", 'update', searchUnit.getFicheCount());
var $parametersDisplayButton = client.$action('parametersDisplay');
if ($parametersDisplayButton.data("scrutariState") === "on") {
$parametersDisplayButton.click();
}
};
Scrutari.DefaultUi.qidsearchCallback = function (client, searchUnit) {
Scrutari.DefaultUi.mainsearchCallback(client, searchUnit);
};
Scrutari.DefaultUi.subsearchCallback = function (client, searchUnit) {
client.$count("stats-result", 'update', searchUnit.getFicheCount());
};
Scrutari.DefaultUi.displayError = function (client, error, searchOrigin) {
if (error.parameter !== "q") {
Scrutari.logError(error);
return;
}
var title = client.loc(error.key);
if (title !== error.key) {
var alertMessage = title;
if (error.hasOwnProperty("array")) {
alertMessage += client.loc('_ colon');
for(var i = 0; i < error.array.length; i++) {
alertMessage += "\n";
var obj = error.array[i];
alertMessage += "- ";
alertMessage += client.loc(obj.key);
if (obj.hasOwnProperty("value")) {
alertMessage += client.loc('_ colon');
alertMessage += " ";
alertMessage += obj.value;
}
}
}
alert(alertMessage);
} else {
Scrutari.logError(error);
}
};
Scrutari.DefaultUi.modalAction = function (client, name, action) {
var $modal = client.$modal(name);
if ($modal.length === 0) {
Scrutari.log("Unknown modal: " + name);
return;
}
switch(action) {
case 'show':
if (!$modal.data("overlayId")) {
var overlayId = client.startOverlay({
header: $modal.children("header").html(),
content: $modal.children("div").html(),
footer: $modal.children("footer").html(),
closeTooltip: client.loc("_ button_close"),
afterEnd: function () {
$modal.data("overlayId", null);
}
});
$modal.data("overlayId", overlayId);
}
break;
case 'hide':
client.endOverlay($modal.data("overlayId"));
break;
}
};
Scrutari.DefaultUi.startLoading = function (client) {
Scrutari.DefaultUi.modalAction(client, 'loading', 'show');
};
Scrutari.DefaultUi.endLoading = function (client) {
Scrutari.DefaultUi.modalAction(client, 'loading', 'hide');
};
Scrutari.DefaultUi.newSearchDisplay = function (client, searchUnit) {
return new Scrutari.SearchDisplay(client, searchUnit);
};
Scrutari.DefaultUi.actionHandler = function (client, button, action, target) {
var $button = $(button);
switch(action) {
case 'enablePanel':
_enablePanel();
break;
case 'checkAll':
_checkAll();
break;
case 'uncheckAll':
_uncheckAll();
break;
case 'parametersDisplay':
let state = Scrutari.Utils.toggle($button, "scrutariState");
Scrutari.Utils.toggle.classes($button, state, client.cssClasses.on, "");
if (state === 'on') {
client.$area('parameters', 'show');
} else {
client.$area('parameters', 'hide');
}
break;
default:
return false;
}
return true;
function _checkAll () {
Scrutari.Utils.check("input[name='" + target + "']");
Scrutari.DefaultUi.filterChange(client);
}
function _uncheckAll () {
Scrutari.Utils.uncheck("input[name='" + target + "']");
Scrutari.DefaultUi.filterChange(client);
}
function _enablePanel () {
var state = Scrutari.Utils.toggle($button, "scrutariState");
_enableChekButtons();
Scrutari.Utils.toggle.classes($button, state, client.cssClasses.on, "");
Scrutari.Utils.toggle.classes(client.$block("columnsBlock", target), state, "", client.cssClasses.disabled);
Scrutari.Utils.toggle.text($button.children("span"), "scrutariAlternate");
var $filterLabel = client.$label(target + "Filter");
Scrutari.Utils.toggle.text($filterLabel, "scrutariAlternate");
Scrutari.Utils.toggle.classes($filterLabel, state, client.cssClasses.activePanel, client.cssClasses.disabled);
Scrutari.DefaultUi.filterChange(client);
function _enableChekButtons () {
let disabled = false;
if (state === 'off') {
disabled = true;
}
client.$action("checkAll", target).prop('disabled', disabled);
client.$action("uncheckAll", target).prop('disabled', disabled);
}
}
};
Scrutari.DefaultUi.changeHandler = function (client, element, name) {
switch(name) {
case 'lang':
case 'category':
case 'base':
case 'corpus':
_checkClick(name);
return true;
default:
return false;
}
function _checkClick (target) {
var $button = client.$action("enablePanel", target);
if ($button.data('scrutariState') === 'off') {
$button.click();
$(this).focus();
} else {
Scrutari.DefaultUi.filterChange(client);
}
}
};
Scrutari.DefaultUi.initMainTitle = function (client) {
var html = "";
var mainTitle = client.options.mainTitle;
if ((mainTitle) || (mainTitle === "")) {
if (typeof mainTitle === "function") {
html = mainTitle(client);
} else {
html = mainTitle;
}
} else {
html += client.loc('_ title_main');
html += " – ";
var title = client.scrutariMeta.getTitle();
if (title) {
html += Scrutari.escape(title);
} else {
html += "[";
html += client.api.name;
html += "]";
}
}
client.$label('mainTitle').html(html);
};
Scrutari.DefaultUi.initFilter = function (client, target, checkedArray) {
var done = false;
for(var i = 0, len = checkedArray.length; i < len; i++) {
var $input = client.$input(target, checkedArray[i]);
if ($input.length > 0) {
$input.prop("checked", true);
done = true;
}
}
if (done) {
client.$action("enablePanel", target).click();
}
};
Scrutari.DefaultUi.initColumns = function (client, array, name) {
Scrutari.Utils.divideIntoColumns(array, client.$block("columnsBlock", name).children("div"), client.getTemplate(name));
client.$panel(name, 'show');
};
Scrutari.DefaultUi.filterChange = function (client) {
var globalFicheCount = client.scrutariMeta.getGlobalFicheCount();
var filterState = client.buildFilterState();
var filterFicheCount;
if (filterState.empty) {
filterFicheCount = client.scrutariMeta.getGlobalFicheCount();
} else {
filterFicheCount = -1;
}
client.stats.update(filterState);
if (!_checkFilterFicheCount("base")) {
if (!_checkFilterFicheCount("corpus")) {
if (!_checkFilterFicheCount("category")) {
_checkFilterFicheCount("lang");
}
}
}
_updateState("base");
_updateState("corpus");
_updateState("category");
_updateState("lang");
var filterTitlesArray = new Array();
_addFilterTitles("base", "_ label_base_one", "_ label_base_many");
_addFilterTitles("corpus", "_ label_corpus_one", "_ label_corpus_many");
_addFilterTitles("lang", "_ label_lang_one", "_ label_lang_many");
_addFilterTitles("category", "_ label_category_one", "_ label_category_many");
var $filterFicheCount = client.$count('stats-filter', 'update', filterFicheCount);
var $filterValue = client.$component($filterFicheCount, "value");
let filterClass = client.cssClasses.filterStat;
let noneClass = client.cssClasses.noneStat;
if (filterFicheCount === globalFicheCount) {
$filterValue.removeClass(filterClass).removeClass(noneClass);
client.$hidden('filter', 'hide');
} else if (filterFicheCount === 0) {
$filterValue.removeClass(filterClass).addClass(noneClass);
client.$hidden('filter', 'show');
} else {
$filterValue.addClass(filterClass).removeClass(noneClass);
client.$hidden('filter', 'show');
}
var $filterTitles = client.$component($filterFicheCount, "titles");
if (filterTitlesArray.length > 0) {
$filterTitles.html(filterTitlesArray.join(" | "));
} else {
$filterTitles.html("");
}
function _checkFilterFicheCount(type) {
var $stat = client.$({scrutariStatType: type});
if ($stat.length > 0) {
filterFicheCount = 0;
$stat.each(function (index, element) {
let key = element.dataset.scrutariStatKey;
filterFicheCount += client.stats.getFicheCount(type, key);
});
return true;
} else {
return false;
}
}
function _updateState(type) {
client.$({scrutariStatType: type}).each(function (index, element) {
var $el = $(element);
var key = element.dataset.scrutariStatKey;
var ficheCount = client.stats.getFicheCount(type, key);
var $statTitle = $el.parents(Scrutari.jQuery.toCssSelector({scrutariComponent: "stat-text"}));
let excludedClass = client.cssClasses.excluded;
if (ficheCount != element.dataset.scrutariStatDefault) {
if (ficheCount === 0) {
$el.html("");
$statTitle.addClass(excludedClass);
} else {
$statTitle.removeClass(excludedClass);
$el.html(client.formatNumber(ficheCount) + " / ");
}
} else {
$el.html("");
$statTitle.removeClass(excludedClass);
}
});
}
function _addFilterTitles(type, oneLocKey, manyLocKey) {
var array = filterState.titles[type];
if (array.length > 0) {
var locKey = (array.length === 1)?oneLocKey:manyLocKey;
filterTitlesArray.push(client.loc(locKey) + client.loc('_ colon') + " " + array.join(", "));
}
}
};
Scrutari.DefaultUi.buildSearchRequestParameters = function (client, customParameters) {
var requestParameters = new Object();
_checkFilter("baselist", "base");
_checkFilter("corpuslist", "corpus");
_checkFilter("categorylist", "category");
_checkFilter("langlist", "lang");
var qMode = _getVal(client.$input_checked("q-mode"));
if (qMode) {
requestParameters["q-mode"] = qMode;
}
var ponderation = _getVal(client.$input_checked("ponderation"));
if (ponderation === 'date') {
requestParameters.ponderation = '10,80,5,5';
}
var periode = _getVal(client.$input("periode"));
if (periode) {
requestParameters["flt-date"] = periode;
}
if (Scrutari.jQuery.exists(client.$input_checked("wildchar", "end"))) {
requestParameters.wildchar = "end";
} else {
requestParameters.wildchar = "none";
}
if (customParameters) {
for(let propKey in customParameters) {
requestParameters[propKey] = customParameters[propKey];
}
}
return requestParameters;
function _getVal($el) {
let val = $el.val();
if (val) {
return val.trim();
} else {
return "";
}
}
function _checkFilter (paramName, target) {
if ((client.functions.isFilterEnable) && (client.functions.isFilterEnable(client, target))) {
var $inputs = client.$input_checked(target);
var value = "";
for(let i = 0; i < $inputs.length; i++) {
if (i > 0) {
value += ",";
}
value += $inputs[i].value;
}
if (value.length > 0) {
requestParameters[paramName] = value;
}
}
}
};
Scrutari.DefaultUi.buildFilterState = function (client) {
var filterState = new Scrutari.FilterState();
_check("base");
_check("corpus");
_check("category");
_check("lang");
return filterState;
function _check (target) {
if (!((client.functions.isFilterEnable) && (client.functions.isFilterEnable(client, target)))) {
return;
}
client.$input_checked(target).each(function (index,element) {
filterState.add(target, element.value, element.dataset.scrutariTitle);
});
}
};