From 6926b3f6a268760acbee01e4f07f67fab90cb152 Mon Sep 17 00:00:00 2001
From: epollinger <e.pollinger@adito.de>
Date: Fri, 22 Jun 2018 11:35:20 +0200
Subject: [PATCH] =?UTF-8?q?[Projekt:=20xRM-Basic][TicketNr.:=201018365][li?=
=?UTF-8?q?b=5Futil=20und=20lib=5Fsql=20=C3=BCbernehmen=20in=205.1=20inkl.?=
=?UTF-8?q?=20neuer=20Struktur]?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
adopted lib_util in Util_lib
Changed to Objects
---
process/Util_lib/process.js | 770 +++++++++++++++++++++++++++---------
1 file changed, 575 insertions(+), 195 deletions(-)
diff --git a/process/Util_lib/process.js b/process/Util_lib/process.js
index 352016f068..7c06f9b1fe 100644
--- a/process/Util_lib/process.js
+++ b/process/Util_lib/process.js
@@ -21,6 +21,7 @@ import("lib_user");
*/
function ImageUtils()
{
+ var that = this;
/**
* reads a picture depending on description and icon_type from ASYS_ICONS
* @param {String} pIconType requ ICON_TYPE of ASYS_ICONS
@@ -29,7 +30,7 @@ function ImageUtils()
*
* @return {String} BINDATA of ASYS_ICONS
*
- * @memberof ImageUtils
+ *
*/
this.getIcon = function(pIconType, pDescription, pBase64)
{
@@ -44,7 +45,7 @@ function ImageUtils()
* @param {Boolean} pBase64 opt true: BINDATA or false/undefined: ID
*
* @return {String[][]} Key: Description, Value: ID
- * @memberof ImageUtils
+ *
*/
this.getImageObject = function (pIconType, pBase64)
{
@@ -65,16 +66,20 @@ function ImageUtils()
*/
function UrlUtils()
{
- /* Extrahiert einen QueryParameter aus einer URL
+ var that = this;
+ /**
+ * Extracts a query param from an URL
*
- * @param {String} pURL der Text, in welchem der Wert extrahiert werden soll
- * @param {String} pParameter der Name, mit welchem der zu extrahierende Wert in der URL gekennzeichnet ist/ das Attribut
+ * @param {String} pURL the text from which the parameter should be read
+ * @param {String} pParameter Name of the parameter
* (Messaging mit Default Trenner:
* - im.internal: "id=", "title_ack=", "title_dcl=", "text_ack=", "text_dcl=", "desc=", "name=", "result=", "decidable=", "icon=", "icon_ack=", "icon_dcl="
* - im.file: "id=", "size=", "result=", "requestor=")
- * @param {String} pSplit opt der String Wert, der das Ende des auszulesenden Wertes kennzeichnet, als Standard wird der IM-Trenner '&' verwendet
+ * @param {String} pSplit opt der String, which marks the end of the param value, standard is '&'
*
- * @return {String} den extrahierten Wert aus der URL oder null, falls dieses Attribut nicht vorhanden ist in der URL
+ * @return {String} the extracted value or null if param not existent
+ *
+ *
*/
this.extractBlock = function(pURL, pParameter, pSplit)
{
@@ -89,15 +94,17 @@ function UrlUtils()
return pURL.substring(idLeft + pParameter.length, idRight);
}
- /*
- * öffnet den Internetbrowser
+ /**
+ * opens the browser
*
* @param {String} pUrl req
- * @param {String} pBrowserType opt Typ des Browsers. 1 = Native (Internet Explorer Rendering Engine)
- * ,2 = JavaFX (WebKit Rendering Engine), 3 = Native, falls möglich.
- * default ist 2;
+ * @param {String} pBrowserType opt Browser type 1 = Native (Internet Explorer Rendering Engine)
+ * ,2 = JavaFX (WebKit Rendering Engine), 3 = Native, if possible.
+ * default is 2;
*
* @return {void}
+ *
+ *
*/
this.openUrl = function(pUrl, pBrowserType)
{
@@ -118,9 +125,11 @@ function UrlUtils()
/**
* Class containing String utility functions
* @class
+ *
*/
function StringUtils()
{
+ var that = this;
/**
* validates if a string is a UUID according to versions 1 through 5 of RFC4122
* @param {String} pUUID String to be validated
@@ -128,9 +137,9 @@ function StringUtils()
*
* @return {Boolean} ob es sich um eine UUID handelt
*
- * @memberof StringUtils
+ *
*/
- this.isValidUUID = fucntion(pUUID, pIgnoreCase)
+ this.isValidUUID = function(pUUID, pIgnoreCase)
{
if (pIgnoreCase)
{
@@ -139,78 +148,52 @@ function StringUtils()
return new RegExp(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/).test(pUUID);
}
- /*
- * Gibt an, ob ein String mit einem anderen String beginnt
- * @param pString String, in dem gesucht wird
- * @param pStringToSearch String, nach dem gesucht wird
+ /**
+ * Returns wether a string starts with given string or not.
+ * @param pString String, which is being searched in
+ * @param pStringToSearch String, which is being searched
+ *
+ * @return {Boolean}
+ *
+ *
*/
this.stringStatrsWith = function(pString, pStringToSearch)
{
return pString.indexOf(pStringToSearch) === 0;
}
- /*
- * Strasse und Hausnummer trennen
+ /**
+ * Splits street and buildingnumber
*
- * @param {String} pAddress req Addresse
+ * @param {String} pAddress req Address
*
- * @return {String []} [ Streed, BildingNr ]
+ * @return {Array} [ Street, BuildingNr ]
+ *
+ *
*/
this.splitAddress = function(pAddress)
{
var ret = ["",""];
- if ( pAddress != "" )
+ if(pAddress != "")
{
var arr = pAddress.match( /^[^0-9]+|[0-9]+.*$/g);
ret[0] = arr[0].trim();
- if ( arr[1] ) ret[1] = arr[1].trim();
+ if(arr[1])
+ ret[1] = arr[1].trim();
}
return ret;
}
/**
- * Dient als Comparator für die Methode Array.sort(stringComparison) und
- * definiert, wie Characters verglichen werden sollen.
- * Ignoriert Groß- Kleinschreibung und sortiert Umlaute
- * zu den entsprtechenden Selbstlauten.
- * (ä == a, ß == s, usw.)
- *
- * Bei eindimensionalen Arrays kann dies direkt an die Javscript Funktion Array.Sort() als Parameter übergeben werden.
- * Bei mehrdimensionalen Arrays macht die Jdito Funktion Sortarray Sinn, in der diese Funktion verwendet wird.
+ * Generates the string which shows, who created the dataset and who edited it
*
- * @param a erstes Argument
- * @param b zweites Argument
+ * @param {String} pDateNew req Date of creation
+ * @param {String} pUserNew req name of the user, who created the dataset
+ * @param {String} pDateEdit req date of the last change
+ * @param {String} pUserEdit req name of last editor
*
- * @return 0, wenn beide Argumente gleich sind
- * -1, wenn a größer als b ist
- * 1, sonst
- */
- this.stringComparison = function(a, b) {
-
- a = a.toLowerCase();
- a = a.replace(/ä/g,"ae");
- a = a.replace(/ö/g,"oe");
- a = a.replace(/ü/g,"ue");
- a = a.replace(/ß/g,"ss");
-
- b = b.toLowerCase();
- b = b.replace(/ä/g,"ae");
- b = b.replace(/ö/g,"oe");
- b = b.replace(/ü/g,"ue");
- b = b.replace(/ß/g,"ss");
-
- return( a == b ) ? 0 : ( a > b ) ? 1 : -1;
- }
-
- /*
- * Erzeugt einen String, der angibt wann das Element von wem erstellt und wann
- * sowie wann und von wem es zuletzt editiert wurde.
- *
- * @param {String} pDateNew req Datum der Neuerstellung
- * @param {String} pUserNew req Name des Erstellers
- * @param {String} pDateEdit req Datum der letzten Änderung
- * @param {String} pUserEdit req Name des letzten Editierers
- *
- * @return {String} erzeugte String
+ * @return {String}
+ *
+ *
*/
this.label_new_edit = function(pDateNew, pUserNew, pDateEdit, pUserEdit)
{
@@ -218,21 +201,47 @@ function StringUtils()
if (pDateEdit != undefined && pDateEdit != "") retst += " | " + translate.withArguments("geändert %0 von %1", [ datetime.toDate(pDateEdit, translate.text("dd.MM.yyyy")), pUserEdit]);
return(retst)
}
-}
+
+ /**
+ * uses the right translate method, depending on the parameters
+ *
+ * @param {String} pText string to be translated
+ * @param {String} pLocale locale for translating
+ *
+ * @return {String}
+ *
+ *
+ */
+ this.translateStr = function( pText, pLocale )
+ {
+ if ( pLocale == undefined )
+ return translate.text(pText);
+ else
+ return translate.text(pText, pLocale)
+ }
+
+}
+/**
+ * Class containing utility functions for use with arrays
+ * @class
+ */
function DataUtils()
{
+ var that = this;
/**
- * Sortiert ein mehrdimensionales Array nach einem bestimmten Index.
+ * sorts a two dim array by the given index
*
- * @param {[]} pArray req das zu sortierende Array
- * @param {String} pIndex req der Index, nach dem sortiert werden soll
- * @param {Boolean} pUp req TRUE sortiert aufsteigend, FALSE sortiert absteigend
- * @param {Boolean} isNumber TRUE sortiert numerisch, FALSE oder undefined sortiert alpha
+ * @param {Array} pArray req the Array to be sorted
+ * @param {String} pIndex req the index of the field to sort by
+ * @param {Boolean} pUp req TRUE sorts ascending, FALSE sorts decending
+ * @param {Boolean} isNumber TRUE sorts numerical, FALSE or undefined sorts alphanumerical
*
* @return void
*
- * @throws {Error} wenn der Index ausserhalb des Arrays liegt
+ * @throws {Error} if index is outside pArray.length
+ *
+ *
*/
this.array_mDimSort = function(pArray, pIndex, pUp, isNumber)
{
@@ -246,12 +255,14 @@ function DataUtils()
throw new Error("Index Out Of Bounds: " + pIndex + " >= " + pArray[0].length);
/*
- * Die eigentliche Sortierfunktion
+ * the sort function
*
- * @param {String} x req Wert 1
- * @param {String} y req Wert 2
+ * @param {String} x req value 1
+ * @param {String} y req value 2
*
* @return {Integer}
+ *
+ * @memberof array_mDimSort
*/
function array_mDimSorter(x, y)
{
@@ -290,10 +301,10 @@ function DataUtils()
pArray.sort(array_mDimSorter);
}
- /*
+ /**
* sorts an array up to 6 columns with sortorder
*
- * @param {[]} pArray req the array with data
+ * @param {Array} pArray req the array with data
* @param {Integer} us req the Sortorder for Column 1 = Param u (1=asc, -1=desc)
* @param {Integer} u req the 1 Column
* @param {Integer} vs opt the Sortorder for Column 2 = Param v (1=asc, -1=desc)
@@ -307,26 +318,22 @@ function DataUtils()
* @param {Integer} zs opt the Sortorder for Column 6 = Param z (1=asc, -1=desc)
* @param {Integer} z opt the 6 Column
*
- * @example [
- * sortArray(myArray, -1, 0, 1, 1, -1, 2);
- * kein Rückgabewert !
- *]
- *
* @return {void}
+ *
+ *
*/
-
this.sortArray = function(pArray, us, u, vs, v, ws, w, xs, x, ys, y, zs, z)
{
pArray.sort(Sortmulti);
/*
- * Sortieren eines mehrdimensionalen Arrays (bis zu 6 Spalten)
- *
- * @param {String} a req Wert 1, ein Element eines Arrays
- * @param {String} b req Wert 2, zweites Element eines Arrays
- *
- * @return {Integer} -1 - a unter b setzen, 0 - gleichwertig, 1 - b unter a setzen : für sort
- */
- function Sortmulti(a, b) // liefert <0, wenn b unter a zu sortieren, =0 wenn gleichwertig, >0 wenn b über a zu sortieren
+ * sort of a two dim array, up to 6 columns
+ *
+ * @param {String} a req value 1, first compared element
+ * @param {String} b req value 2, sencond compared element
+ *
+ * @return {Integer} -1 - set a below b, 0 - equal, 1 - set b below a
+ */
+ function Sortmulti(a, b)
{
var stringComparison = function(a, b)
{
@@ -348,11 +355,11 @@ function DataUtils()
var swap=0;
- if (isNaN(a[u] - b[u])) // wenn es sich nicht um eine Zahl, sondern einen String handelt an der zuerst zu sortierenden Stelle u
- if( isNaN(a[u]) && isNaN(b[u]) ) // wenn beides ein String ist,
- swap = stringComparison(a[u], b[u]); // dann: true - false = 1; false - true = -1
+ if (isNaN(a[u] - b[u])) // if there is a string in the first compared element
+ if( isNaN(a[u]) && isNaN(b[u]) ) // if both are strings,
+ swap = stringComparison(a[u], b[u]); // then: true - false = 1; false - true = -1
else
- swap = (isNaN(a[u]) ? 1 : -1); // wenn das erste ein String ist, dann werden die Zahlen danach aufgereiht, analog andersrum
+ swap = (isNaN(a[u]) ? 1 : -1);
else
swap = (a[u] - b[u]);
@@ -416,48 +423,54 @@ function DataUtils()
}
- /*
- * Entfernt aus einem Array ein Element.
+ /**
+ * removes an element from an array
*
- * @param {[]} pArray req Array aus dem das Elemte entfernt werden soll
- * @param {String} pElement req Element das entfernt werden soll
+ * @param {Array} pArray req Array from which the element should be removed
+ * @param {String} pElement req index of the element which should be removed
*
- * @return {[]} ohne das entfernte Element
+ * @return {Array} array without the removed element
+ *
+ *
*/
this.removeElement = function(pArray, pElement)
{
return pArray.splice(pElement, 1);
}
- /*
- * Liefert alle aus pSource, die nicht in pReference sind.
+ /**
+ * returns all elemtens not in pSource
*
- * @param {[]} pSource req diese Elemente werden gesucht
- * @param {[]} pReference req in diesem Array wird gesucht
+ * @param {Array} pSource req this elements are being searched
+ * @param {Array} pReference req in this array the search is done
* @param {Boolean} pIgnoreCase opt
*
- * @return {[]} resultIn
+ * @return {Array[]} resultIn
+ *
+ *
*/
this.notIn = function(pSource, pReference, pIgnoreCase)
{
var resultIn = new Array();
for (var i = 0; i < pSource.length; i++)
{
- if (!hasElement(pReference, pSource[i], pIgnoreCase))
+ if (!that.hasElement(pReference, pSource[i], pIgnoreCase))
resultIn.push(pSource[i]);
}
return resultIn;
}
- /*
- * Liefert zurück, ob ein Element in einem Array enthalten ist.
+ /**
+ * returns if an element is in an array.
*
- * @param {[]} pArray req Array in dem nach dem Element gesucht werden soll
- * @param {String} pElement req Elemant nach dem gesucht werden soll
+ * @param {Array} pArray req array which should be searched in
+ * @param {String} pElement req Element which should looked for
* @param {Boolean} pIgnoreCase opt
*
- * @return {Boolean} TRUE wenn dies der Fall ist
+ * @return {Boolean} true if it has the element
+ *
+ *
*/
this.hasElement = function(pArray, pElement, pIgnoreCase)
{
@@ -466,78 +479,98 @@ function DataUtils()
if ( pIgnoreCase != undefined && pIgnoreCase )
{
if (pArray[i].toLowerCase() == pElement.toLowerCase())
- return true;
+ return true;
}
else
- if (pArray[i] == pElement) return true;
+ if (pArray[i] == pElement)
+ return true;
}
return false;
}
-
- /*
- * liefert eine sortierte liste der übersetzten laender;
- * DE, AT und CH sind an den Anfang sortiert wenn die Daten automatisch geladen werden
- *
- * @param {String} pLanguage opt Sprache
- * @param {String[][]} pData opt Wenn die Daten nicht automatisch geladen werden sollen,
- * können diese hier angegeben werden
- * So kann man bspw. Länder aus der AOSYS_LOCATION-Tabelle übersetzen
- *
- * @return {String[][]} aus ISO2 Kürzel und Name
- *
- */
- this.getCountries = function(pLanguage, pData)
+
+ /**
+ * concats arrays column by column
+ * see example for more details
+ * logging.show(JSON.stringify(concatArrayColumns(a, b)));
+ * //[["a","A"],["b","B"],["c","C"]]
+ *
+ * logging.show(JSON.stringify(a.concat(b)));
+ * //["a","b","c","A","B","C"]
+ * @param {Array} pArray1 req you have to pass at least 2 Arrays that shall be concated but you can pass as many as you want
+ * @param {Array} pArrayN req you have to pass at least 2 Arrays that shall be concated but you can pass as many as you want
+ *
+ *
+ *
+ * @return {Array} Beschreibung
+ *
+ *
+ */
+ this.concatArrayColumns = function(pArray1, pArrayN)
{
- var data, temp;
- if(pData == undefined)
- {
- data = [ ["DE", "Deutschland"], ["AT", "Österreich"], ["CH", "Schweiz"] ];
- temp = db.table("select COUNTRYINFO.ISO2, COUNTRYINFO.NAME_DE "
- + "from COUNTRYINFO "
- + "where COUNTRYINFO.ISO2 not in ('DE', 'AT', 'CH')");
- }
- else
- {
- data = [];
- temp = pData;
- }
+ var res = [];
- for(var i = 0; i < data.length; i++)
- data[i][1] = translateStr(data[i][1], pLanguage);
- for(let i = 0; i < temp.length; i++)
- temp[i][1] = translateStr(temp[i][1], pLanguage).trim();
-
- //Sortierung nach der Ãœbersetzung
- array_mDimSort(temp, 1, true, false);
+ for (var i = 0, l = arguments.length; i < l; i++)//this function can handle an "unlimited" amount of functionparams
+ {
+ var inpArr = arguments[i];
+ for (var ii = 0, ll = inpArr.length; ii < ll; ii++)
+ {
+ if (res[ii] == undefined)
+ res[ii] = [];
- return data.concat(temp);
+ res[ii] = res[ii].concat(inpArr[ii]);
+ }
+ }
+ return res;
+ }
+
+ /**
+ * function to determine, if an object is truly an Array
+ * @param {Object} pArray
+ * @return {Boolean} returns wether an Object is an Array (true) or not (false)
+ *
+ *
+ */
+ this.isArray = function(pArray)
+ {
+ return (pArray && typeof pArray === "object" && typeof pArray.length === "number" && !(pArray.propertyIsEnumerable('length')))
}
}
-
+/**
+ * Class containing utility functions for table components
+ * @class
+ */
function TableUtils()
{
- /*
- * Sortiert Tabelle
+ var that = this;
+ /**
+ * Moving Tablerows Sort field up or down a step
*
* @param {String} pTable req Table
- * @param {String} pTableComp req Name der TabellenComponente
- * @param {String} pCountField req Feldname z.B. 'SORT'
+ * @param {String} pTableComp req name of the table comp
+ * @param {String} pCountField req sort field name z.B. 'SORT'
* @param {String} pDirection req 'up' oder 'down'
* @param {String} pCondition opt
*
* @return {void}
+ *
+ *
*/
this.moveRow = function(pTable, pTableComp, pCountField, pDirection, pCondition)
{
- sortRow(pTable, pCountField, pCondition);
- if (pCondition == undefined || pCondition == "") pCondition = "";
- else pCondition = " and " + pCondition;
+ that.sortRow(pTable, pCountField, pCondition);
+
+ if (pCondition == undefined || pCondition == "")
+ pCondition = "";
+ else
+ pCondition = " and " + pCondition;
+
var id = text.decodeFirst(vars.getString(pTableComp));
var col = [pCountField];
var nextval;
var typ = db.getColumnTypes( pTable, col);
var oldval = db.cell("select " + pCountField + " from " + pTable + " where " + pTable + "ID = '" + id + "'");
+
if (pDirection == "up")
{
nextval = db.cell("select max(" + pCountField + ") from " + pTable
@@ -548,74 +581,64 @@ function TableUtils()
nextval = db.cell("select min(" + pCountField + ") from " + pTable
+ " where " + pCountField + " > " + oldval + pCondition);
}
- if ( nextval == "" ) nextval = 0;
+ if ( nextval == "" )
+ nextval = 0;
var nextID = db.cell("select " + pTable + "ID from " + pTable + " where " + pCountField + " = " + nextval + pCondition);
db.updateData(pTable, col, typ, [oldval], pTable + "ID = '" + nextID + "'")
db.updateData(pTable, col, typ, [nextval], pTable + "ID = '" + id + "'")
}
- /*
- * aktiviert up/Down-Buttons
+ /**
+ * activates Up/Down buttons
*
* @param {String} pTable req Table
- * @param {String} pTableComp req Name der TabellenComponente
- * @param {String} pSortfield req Feldname z.B. 'SORT'
- * @param {String} pDirection req 'up' oder 'down'
+ * @param {String} pTableComp req name of the table comp
+ * @param {String} pSortfield req sort field name z.B. 'SORT'
+ * @param {String} pDirection req 'up' or 'down'
* @param {String} pCondition opt
*
- * @return {Boolean} true wenn aktiv
+ * @return {Boolean} true if active
+ *
+ *
*/
this.moveActive = function(pTable, pTableComp, pSortfield, pDirection, pCondition)
{
var oldval = "min";
- var minmax = "min";
+ var minmax = "min";
var id = text.decodeFirst(vars.getString(pTableComp));
- if (pCondition == undefined || pCondition == "") pCondition = "";
- else pCondition = " where " + pCondition;
+ if (pCondition == undefined || pCondition == "")
+ pCondition = "";
+ else
+ pCondition = " where " + pCondition;
+
if (id != "" && swing.getTableDataByAttribute(pTableComp, swing.INSERTED ).length == 0 && vars.getString("$sys.workingmode") == swing.FRAMEMODE_EDIT )
{
oldval = db.cell("select " + pSortfield + " from " + pTable + " where " + pTable + "ID = '" + id + "'");
- if (pDirection == "down") minmax = "max";
+
+ if(pDirection == "down")
+ minmax = "max";
+
minmax = db.cell("select " + minmax + "(" + pSortfield + ") from " + pTable + pCondition);
}
- return(oldval != minmax || oldval == "" || minmax == "" )
- }
-
- /*
- * Sortiert Tabelle neu
- *
- * @param {String} pTable req Table
- * @param {String} pCountField req Feldname z.B. 'SORT'
- * @param {String} pCondition opt
- * @param {Boolean} pSort opt auf alle Fälle
- *
- * @return {void}
- */
- this.sortRow = function(pTable, pCountField, pCondition, pSort)
- {
- if (pCondition == undefined || pCondition == "") pCondition = "";
- else pCondition = " where " + pCondition;
- if ( pSort == undefined ) pSort = false;
-
- if ( db.cell("select count(*) from " + pTable + pCondition + " group by " + pCountField + " having count(*) > 1 ") > 0 || pSort )
- {
- var col = [pCountField];
- var typ = db.getColumnTypes( pTable, col);
- var ids = db.cell("select " + pTable + "ID from " + pTable + pCondition + " order by " + pCountField);
- for ( var i = 0; i < ids.length; i++ ) db.updateData(pTable, col, typ, [i+1], pTable + "ID = '" + ids[i] + "'")
- }
+ return (oldval != minmax || oldval == "" || minmax == "" )
}
}
-
+/**
+ * Class containing utility functions for use with base64 and binaries
+ * @class
+ */
function BinaryUtils()
{
- /*
+ var that = this;
+ /**
* decodes 64Based String
*
* @param {String} input req the string
*
* @return {String} decoded String
+ *
+ *
*/
this.decode64 = function(input)
{
@@ -625,4 +648,361 @@ function BinaryUtils()
charset = "ISO-8859-15";
return util.decodeBase64String(input, charset);
}
+ /**
+ * returns the original size of a B64 coded String in bytes
+ *
+ * @param {String} pBase64str req base64 encoded string
+ *
+ * @return {Number} size of the string in bytes
+ *
+ *
+ */
+ this.getBase64lengthBytes = function(pBase64str)
+ {
+ var res = pBase64str.length;
+ res = eMath.divDec(res, 4);
+ res = Math.ceil(res);
+ res = eMath.mulInt(3, res);
+
+ return +res;//cast und return
+ }
+
+ /**
+ * sanitizes the filelist gotten from Drag&Drop and returns it.
+ *
+ * @param {String[]} pFilelist req Die Filelist als Stringarray.
+ *
+ *
+ */
+ this.sanitizeFilelist = function(pFilelist)
+ {
+ var sanitized = [];
+
+ if(pFilelist != undefined && pFilelist.length > 0)
+ {
+ for(let i = 0; i < pFilelist.length; i++)
+ {
+ if(swing.doClientIntermediate(swing.CLIENTCMD_FILEIO_ISDIRECTORY, [pFilelist[i]]) == "false")
+ sanitized.push(pFilelist[i]);
+ }
+ }
+
+ return sanitized;
+ }
+ /**
+ * reads the folders in a filelist and returns their contained files
+ *
+ * @param {String[]} pFilelist req Die Filelist als Stringarray.
+ *
+ *
+ */
+ this.resolveSubfolders = function(pFilelist)
+ {
+ //read systemconfig for D&D
+ var cfg = new Configuration();
+ var filesize = (cfg.getOption("dnd.maxFileSize") *1000 *1000 );
+ var fileamount = 30;
+ var files = [];
+ var folders = [];
+
+ if(pFilelist != undefined && pFilelist.length > 0)
+ {
+ //separate files and folders
+ for (let i = 0; i < pFilelist.length; i++)
+ {
+ if(swing.doClientIntermediate(swing.CLIENTCMD_FILEIO_ISDIRECTORY, [pFilelist[i]]) == "false")
+ files.push(pFilelist[i]);
+ else
+ folders.push(pFilelist[i]);
+ }
+
+ //resovle Files in Folders
+ if(folders.length > 0)
+ {
+ for (let j = 0; j < folders.length; j++)
+ {
+ var resolvedFiles = swing.doClientIntermediate(swing.CLIENTCMD_FILEIO_LISTFILES, [folders[j]]);
+ if(resolvedFiles.length > 0)
+ {
+ for (let k = 0; k < resolvedFiles.length; k++) resolvedFiles[k] = folders[j] + "\\" + resolvedFiles[k];
+ files = files.concat(resolvedFiles);
+ }
+ }
+ }
+
+ //recursive call, cause more subfolders may be present
+ if( that.hasSubfolders(files) )
+ files = that.resolveSubfolders(files);
+ }
+
+ //filter out files, that exceed the size limit
+ var retfiles = [];
+ for (let m = 0; m < files.length; m++)
+ {
+ if(retfiles.length == fileamount)
+ break;
+
+ if(swing.doClientIntermediate(swing.CLIENTCMD_FILEIO_GETLENGTH, [files[m]]) <= filesize)
+ retfiles.push(files[m]);
+ }
+
+ logging.log(retfiles)
+ return retfiles;
+ }
+ /**
+ * Checks if subfolders are present in a filelist
+ *
+ * @param {String[]} pFilelist req the file list as string array
+ *
+ *
+ */
+ this.hasSubfolder = function(pFilelist)
+ {
+ var ret = false;
+ if(pFilelist != undefined && pFilelist.length > 0)
+ {
+ for (let i = pFilelist.length; i >= 0; i--)
+ {
+ if(swing.doClientIntermediate(swing.CLIENTCMD_FILEIO_ISDIRECTORY, [pFilelist[i]]) == "true")
+ {
+ ret = true;
+ break;
+ }
+
+ }
+ }
+ return ret;
+ }
+
+}
+/**
+ * Class containing miscellaneous utiltiy function extending JDito
+ * @class
+ */
+function JDitoUtils()
+{
+ /**
+ * A wrapper for process.executeScript
+ *
+ * @param {String} pIdentifier req The identifier for the script (for better error logging)
+ * @param {String} pScript req The script to execute
+ * @param {Object} pLocalVariables opt The local variables which can be accessed within the script
+ * @param {Array} pImports opt To add additional imports which will be prepended to the script
+ * @param {Boolean} pWrapIntoResult opt To wrap pScript into 'result.string("***")'
+ * @param {String} pAlias opt The alias to use within the script
+ *
+ * @return {Object} The result of the script
+ *
+ */
+ this.evalScript = function(pIdentifier, pScript, pLocalVariables, pImports, pWrapIntoResult, pAlias)
+ {
+ var defaultImports = ["system.result", "system.vars"];
+ var importsToPrepend = [];
+
+ // add pImports to to defaultImports
+ if (pImports != undefined) defaultImports = defaultImports.concat(pImports);
+
+ // go trough all defaultImports an check if they already exists
+ for (var i = 0; i < defaultImports.length; i++ )
+ {
+ var cImport = "import(\"" + defaultImports[i] + "\");";
+
+ if (pScript.indexOf(cImport) == -1)
+ {
+ // If the current default import was not found within the script it will be prepended
+ importsToPrepend.push(cImport);
+ }
+ }
+
+ // join the imports to prepend and place them in front of a new variable
+ var script2Execute = importsToPrepend.join("\r\n") + (importsToPrepend.length > 0 ? "\r\n" : "");
+
+ // Check if the script needs to be wrapped into result.string() (e.g. (function(){return "result";})())
+ if (pWrapIntoResult)
+ script2Execute += "\r\nresult.string(" + pScript + ");\r\n"; // Wrap into 'result.string("***")'
+ else
+ script2Execute += pScript; // Just add the script after the prepended imports
+
+ return process.executeScript("[evalScript]" + pIdentifier, script2Execute, (pLocalVariables != undefined && pLocalVariables != null ? pLocalVariables : {}), (pAlias != undefined && pAlias != null ? pAlias : null));
+ }
+
+ /**
+ * Returns a list of aliasNames with a given type
+ * ignores errors when an alias is not confgiured (empty)
+ *
+ * @param {project.DATASOURCE_} pAliasType opt the type of the aliases to load
+ *
+ * @return {String[]} Array of aliasNames
+ */
+ this.getAliasListByType = function(pAliasType)
+ {
+ pAliasType = pAliasType || project.DATASOURCE_DB;
+
+ var allDbAliases = project.getDataModels(project.DATAMODEL_KIND_ALIAS);
+ var dbAliases = [];
+
+ for (var i = 0, j = allDbAliases.length; i < j; i++)
+ {
+ var aliasName = allDbAliases[i][0];
+ var alias = null;
+ try
+ {
+ alias = project.getAliasModel(aliasName);
+ }
+ catch(ex)
+ {
+ logging.log(translate.withArguments("Der Alias \"%0\" konnte nicht geladen werden. Eventuell wurde er nicht konfiguriert", [aliasName]));
+ logging.log(ex);
+ }
+
+ if (alias != null && alias[project.ALIAS_DATASOURCETYPE] == pAliasType)
+ dbAliases.push(aliasName);
+ }
+
+ return dbAliases;
+ }
+
+ /**
+ * returns a sorted and translated list of countries ;
+ * DE, AT and CH are at the beginning of the list, if pData is undefined
+ *
+ * @param {String} pLanguage opt Sprache
+ * @param {String[][]} pData opt if the data should not be gathered automatically
+ * it can be given to this parameter.
+ * with this, the function can be used to translate country names
+ *
+ * @return {String[][]} consisting of ISO2 and Name
+ *
+ *
+ */
+ this.getCountries = function(pLanguage, pData)
+ {
+ var data, temp;
+ if(pData == undefined)
+ {
+ data = [ ["DE", "Deutschland"], ["AT", "Österreich"], ["CH", "Schweiz"] ];
+ temp = db.table("select COUNTRYINFO.ISO2, COUNTRYINFO.NAME_DE "
+ + "from COUNTRYINFO "
+ + "where COUNTRYINFO.ISO2 not in ('DE', 'AT', 'CH')");
+ }
+ else
+ {
+ data = [];
+ temp = pData;
+ }
+
+ for(var i = 0; i < data.length; i++)
+ data[i][1] = translateStr(data[i][1], pLanguage);
+ for(let i = 0; i < temp.length; i++)
+ temp[i][1] = translateStr(temp[i][1], pLanguage).trim();
+
+ //Sortierung nach der Ãœbersetzung
+ array_mDimSort(temp, 1, true, false);
+
+ return data.concat(temp);
+ }
+}
+/**
+ * Class containing utility functions for use with JSON
+ * @class
+ */
+function JSONUtils()
+{
+ /**
+ * A custom JSON.stringify() to
+ * - keep the functions as string
+ * - stringify JavaArrays
+ * - stringify undefined as undefined and not as null
+ *
+ * @param {Object} pObj req The object to stringify
+ *
+ * @return {String} The stringified string
+ *
+ *
+ */
+ this.stringifyJSON = function(pObj)
+ {
+ //stringify part from JSON polyfill: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON
+ var toString = Object.prototype.toString;
+ var escMap = {'"': '\\"', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t'};
+ var escFunc = function (m) { return escMap[m] || '\\u' + (m.charCodeAt(0) + 0x10000).toString(16).substr(1); };
+ var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g;
+
+ var stringify = function (value){
+ //because: "undefined == null" is true
+ if (value === undefined) {
+ return 'undefined';
+ } else if (value == null) {
+ return 'null';
+ } else if (typeof value === 'number') {
+ return isFinite(value) ? value.toString() : 'null';
+ } else if (typeof value === 'boolean') {
+ return value.toString();
+ } else if (typeof value === 'object')
+ {
+ //check with "hasOwnProperty" because in JavaArrays using value.toJSON would cause an exception
+ if (toString.call(value) != '[object Map]' && value.hasOwnProperty("toJSON") && typeof value.toJSON === 'function') {
+ return value.toString();
+ } else if (toString.call(value) === '[object Array]') {
+ var res = '[';
+ for (var i = 0; i < value.length; i++)
+ res += (i ? ', ' : '') + stringify(value[i]);
+ return res + ']';
+ } else if (toString.call(value) === '[object Object]' || toString.call(value) === '[object Map]') {
+ var tmp = [];
+ for (var k in value) {
+ if (hasOwnProperty.call(value, k))
+ tmp.push(stringify(k) + ': ' + stringify(value[k]));
+ }
+ return '{' + tmp.join(', ') + '}';
+ //custom addition to stringify Rhino JavaArrays
+ } else if (toString.call(value) === '[object JavaArray]') {
+ return value.toSource().toString();
+ }
+ }
+ //custom addition for function transform
+ //JSON.stringify returns null on functions (default)
+ //instead return source code of funciton for callback-functions
+ else if (typeof value === 'function')
+ {
+ return value.toString();
+ }
+
+ return '"' + value.toString().replace(escRE, escFunc) + '"';
+ }
+
+ return stringify(pObj);
+ }
+ /**
+ * checks if pStr is JSON
+ *
+ * @param {pStr}
+ *
+ * @return false or parsed JSON
+ *
+ *
+ */
+ this.isJSON = function(pStr)
+ {
+ if (typeof(pStr) != "string")
+ return false;
+
+ if (pStr[0] != "{")
+ return false;
+
+ if (pStr[pStr.length-1] != "}")
+ return false;
+
+ try
+ {
+ var parse = JSON.parse(pStr);
+ return parse;
+ }
+ catch (ex)
+ {
+ return false;
+ }
+
+ return parse;
+ }
}
\ No newline at end of file
--
GitLab