oxygen-cli 1.40.1 → 1.40.2-beta.1

package/build/ox_modules/module-mongo.js

@@ -0,0 +1,302 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("source-map-support/register");
+
+var _OxygenModule = _interopRequireDefault(require("../core/OxygenModule"));
+
+var _OxygenError = _interopRequireDefault(require("../errors/OxygenError"));
+
+var _helper = _interopRequireDefault(require("../errors/helper"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+ * Copyright (C) 2015-current CloudBeat Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+const {
+  MongoClient
+} = require('mongodb');
+
+const MODULE_NAME = 'mongo';
+/**
+ * @name shell
+ * @description Provides methods for working with operating system shell.
+ */
+
+class MongoDbModule extends _OxygenModule.default {
+  constructor(options, context, rs, logger, modules, services) {
+    super(options, context, rs, logger, modules, services);
+    this._alwaysInitialized = false;
+    this._isInitialized = false;
+    this.client;
+    this.db;
+    this.collection;
+  }
+  /**
+   * @summary Initializes MongoDB session.
+   * @function init
+   * @param {string} hostOrUrl - Host name or full URL of the target MongoDB server.
+   * @param {string} dbName - Database name. You can change it later using "setDatabase" method.
+   * @param {string} [username] - Optional username for authentication.
+   * @param {string} [password] - Optional password for authentication.
+   * @param {string} [authSource=admin] - Optional authentication source. Default value is "admin".
+   * @param {number} [port=27017] - Optional MongoDB server port. Default value is 27017.
+   */
+
+
+  async init(hostOrUrl, dbName, username, password, authSource = 'admin', port = 27017) {
+    if (!hostOrUrl || typeof hostOrUrl !== 'string') {
+      throw new Error('MongoDB host name or full URL is not specified!');
+    } else if (!dbName) {
+      throw new Error('MongoDB database name is not specified!');
+    }
+
+    const isFullUrl = /^mongodb(\+srv)?:\/\//i.test(hostOrUrl);
+    const uri = isFullUrl ? hostOrUrl : (() => {
+      if (username) {
+        const encUsername = encodeURIComponent(username);
+        const encPassword = password ? encodeURIComponent(password) : undefined;
+        return `mongodb://${encUsername}:${encPassword || ''}@${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;
+      }
+
+      return `mongodb://${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;
+    })();
+    this.client = new MongoClient(uri, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true
+    });
+
+    try {
+      await this.client.connect();
+      this.db = this.client.db(dbName);
+      this._isInitialized = true;
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Sets the current database to perform further actions.
+   * @function setDatabase 
+   * @param {string} dbName - Database name.
+   */
+
+
+  setDatabase(dbName) {
+    this.db = this.client.db(dbName);
+  }
+  /**
+   * @summary Sets the current collection to perform further actions.
+   * @function setCollection 
+   * @param {string} collectionName - Collection name.
+   */
+
+
+  setCollection(collectionName) {
+    if (!this.db) {
+      return false;
+    }
+
+    this.collection = this.db.collection(collectionName);
+    return true;
+  }
+  /**
+   * @summary Finds documents in the current collection.
+   * @function find 
+   * @param {object} filter - The filter predicate.
+   * @param {object} options - Optional settings for the command.
+   * @return {object} A list of documents.
+   */
+
+
+  async find(filter, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.find(filter, options).toArray();
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Gets the number of documents matching the filter.
+   * @function countDocuments 
+   * @param {object} filter - The filter for the count.
+   * @param {object} options - Optional settings for the command.
+   * @return {number} Number of documents matching the filter.
+   */
+
+
+  async countDocuments(filter, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.countDocuments(filter, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Inserts a single document into a collection.
+   * @function insertOne 
+   * @param {object} doc - The document to insert.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async insertOne(doc, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.insertOne(doc, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Inserts an array of documents into a collection.
+   * @function insertMany 
+   * @param {object} docs - The documents to insert.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async insertMany(docs, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.insertMany(docs, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Update a single document in a collection.
+   * @function updateOne 
+   * @param {object} filter - The filter used to select the document to replace.
+   * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async updateOne(filter, update) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.updateOne(filter, update);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Update multiple documents in a collection.
+   * @function updateMany 
+   * @param {object} filter - The filter used to select the document to update.
+   * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async updateMany(filter, update, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.updateMany(filter, update, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Replace a document in a collection with another document.
+   * @function replaceOne 
+   * @param {object} filter - The filter used to select the document to replace.
+   * @param {object} doc - The Document that replaces the matching document.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async replaceOne(filter, doc) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.replaceOne(filter, doc);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Delete a document from a collection.
+   * @function deleteOne 
+   * @param {object} filter - The filter used to select the document to remove.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async deleteOne(filter) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.deleteOne(filter);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Delete multiple documents from a collection.
+   * @function deleteMany 
+   * @param {object} filter - The filter used to select the documents to remove.
+   * @param {object} options - Optional settings for the command.
+   */
+
+
+  async deleteMany(filter) {
+    if (!this.collection) {
+      return undefined;
+    }
+
+    try {
+      return await this.collection.deleteMany(filter);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Gets module name
+   * @function name
+   * @return {String} Constant value "shell".
+   */
+
+
+  get name() {
+    return MODULE_NAME;
+  }
+
+}
+
+exports.default = MongoDbModule;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_modules/module-mongo.js"],"names":["MongoClient","require","MODULE_NAME","MongoDbModule","OxygenModule","constructor","options","context","rs","logger","modules","services","_alwaysInitialized","_isInitialized","client","db","collection","init","hostOrUrl","dbName","username","password","authSource","port","Error","isFullUrl","test","uri","encUsername","encodeURIComponent","encPassword","undefined","useNewUrlParser","useUnifiedTopology","connect","e","OxError","errHelper","errorCode","MONGODB_ERROR","message","setDatabase","setCollection","collectionName","find","filter","toArray","countDocuments","insertOne","doc","insertMany","docs","updateOne","update","updateMany","replaceOne","deleteOne","deleteMany","name"],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2015-current CloudBeat Limited\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n */\nconst { MongoClient } = require('mongodb');\nimport OxygenModule from '../core/OxygenModule';\nimport OxError from '../errors/OxygenError';\nimport errHelper from '../errors/helper';\n\nconst MODULE_NAME = 'mongo';\n\n/**\n * @name shell\n * @description Provides methods for working with operating system shell.\n */\nexport default class MongoDbModule extends OxygenModule {\n    constructor(options, context, rs, logger, modules, services) {\n        super(options, context, rs, logger, modules, services);\n        this._alwaysInitialized = false;\n        this._isInitialized = false;\n        this.client;\n        this.db;\n        this.collection;\n    }\n    /**\n     * @summary Initializes MongoDB session.\n     * @function init\n     * @param {string} hostOrUrl - Host name or full URL of the target MongoDB server.\n     * @param {string} dbName - Database name. You can change it later using \"setDatabase\" method.\n     * @param {string} [username] - Optional username for authentication.\n     * @param {string} [password] - Optional password for authentication.\n     * @param {string} [authSource=admin] - Optional authentication source. Default value is \"admin\".\n     * @param {number} [port=27017] - Optional MongoDB server port. Default value is 27017.\n     */\n    async init(\n        hostOrUrl,\n        dbName,\n        username,\n        password,\n        authSource = 'admin',\n        port = 27017,\n    ) {\n        if (!hostOrUrl || typeof hostOrUrl !== 'string') {\n            throw new Error('MongoDB host name or full URL is not specified!');\n        }\n        else if (!dbName) {\n            throw new Error('MongoDB database name is not specified!');\n        }\n        const isFullUrl = /^mongodb(\\+srv)?:\\/\\//i.test(hostOrUrl);\n        const uri = isFullUrl\n            ? hostOrUrl\n            : (() => {\n                if (username) {\n                    const encUsername = encodeURIComponent(username);\n                    const encPassword = password ? encodeURIComponent(password) : undefined;\n                    return `mongodb://${encUsername}:${encPassword || ''}@${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;\n                }\n                return `mongodb://${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;\n            })();\n        this.client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });\n        try {\n            await this.client.connect();\n            this.db = this.client.db(dbName);\n            this._isInitialized = true;\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Sets the current database to perform further actions.\n     * @function setDatabase \n     * @param {string} dbName - Database name.\n     */\n    setDatabase(dbName) {\n        this.db = this.client.db(dbName);\n    }\n\n    /**\n     * @summary Sets the current collection to perform further actions.\n     * @function setCollection \n     * @param {string} collectionName - Collection name.\n     */\n    setCollection(collectionName) {\n        if (!this.db) {\n            return false;\n        }\n        this.collection = this.db.collection(collectionName);\n        return true;\n    }\n\n    /**\n     * @summary Finds documents in the current collection.\n     * @function find \n     * @param {object} filter - The filter predicate.\n     * @param {object} options - Optional settings for the command.\n     * @return {object} A list of documents.\n     */\n    async find(filter, options) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.find(filter, options).toArray();\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Gets the number of documents matching the filter.\n     * @function countDocuments \n     * @param {object} filter - The filter for the count.\n     * @param {object} options - Optional settings for the command.\n     * @return {number} Number of documents matching the filter.\n     */\n    async countDocuments(filter, options) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.countDocuments(filter, options);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Inserts a single document into a collection.\n     * @function insertOne \n     * @param {object} doc - The document to insert.\n     * @param {object} options - Optional settings for the command.\n     */\n    async insertOne(doc, options) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.insertOne(doc, options);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Inserts an array of documents into a collection.\n     * @function insertMany \n     * @param {object} docs - The documents to insert.\n     * @param {object} options - Optional settings for the command.\n     */\n    async insertMany(docs, options) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.insertMany(docs, options);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Update a single document in a collection.\n     * @function updateOne \n     * @param {object} filter - The filter used to select the document to replace.\n     * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.\n     * @param {object} options - Optional settings for the command.\n     */\n    async updateOne(filter, update) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.updateOne(filter, update);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Update multiple documents in a collection.\n     * @function updateMany \n     * @param {object} filter - The filter used to select the document to update.\n     * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.\n     * @param {object} options - Optional settings for the command.\n     */\n    async updateMany(filter, update, options) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.updateMany(filter, update, options);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Replace a document in a collection with another document.\n     * @function replaceOne \n     * @param {object} filter - The filter used to select the document to replace.\n     * @param {object} doc - The Document that replaces the matching document.\n     * @param {object} options - Optional settings for the command.\n     */\n    async replaceOne(filter, doc) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.replaceOne(filter, doc);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Delete a document from a collection.\n     * @function deleteOne \n     * @param {object} filter - The filter used to select the document to remove.\n     * @param {object} options - Optional settings for the command.\n     */\n    async deleteOne(filter) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.deleteOne(filter);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n    /**\n     * @summary Delete multiple documents from a collection.\n     * @function deleteMany \n     * @param {object} filter - The filter used to select the documents to remove.\n     * @param {object} options - Optional settings for the command.\n     */\n    async deleteMany(filter) {\n        if (!this.collection) {\n            return undefined;\n        }\n        try {\n            return await this.collection.deleteMany(filter);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\n        }\n    }\n\n    /**\n     * @summary Gets module name\n     * @function name\n     * @return {String} Constant value \"shell\".\n     */\n    get name() {\n        return MODULE_NAME;\n    }\n}"]}

package/build/ox_modules/module-pdf.js

@@ -6,18 +6,18 @@ var _OxygenError = _interopRequireDefault(require("../errors/OxygenError"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/*
- * Copyright (C) 2019-present CloudBeat Limited
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+/*
+ * Copyright (C) 2019-present CloudBeat Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  */
 
-/**
- * @name pdf
- * @description Provides generic methods for working with PDF files.
+/**
+ * @name pdf
+ * @description Provides generic methods for working with PDF files.
  */
 const errHelper = require('../errors/helper');
 
@@ -220,14 +220,14 @@ module.exports = function (options, context, rs, logger, modules, services) {
   module.isInitialized = function () {
     return true;
   };
-  /**
-   * @summary Asserts that text is present in a PDF file
-   * @function assert
-   * @param {String} pdfFilePath - Relative or absolute path to the PDF file.
-   * @param {String} text - Text to assert.
-   * @param {Number=} pageNum - Page number.
-   * @param {String=} message - Message to throw if assertion fails.
-   * @param {Boolean=} reverse - Check also reverse variant of string.
+  /**
+   * @summary Asserts that text is present in a PDF file
+   * @function assert
+   * @param {String} pdfFilePath - Relative or absolute path to the PDF file.
+   * @param {String} text - Text to assert.
+   * @param {Number=} pageNum - Page number.
+   * @param {String=} message - Message to throw if assertion fails.
+   * @param {Boolean=} reverse - Check also reverse variant of string.
    */
 
 
@@ -259,14 +259,14 @@ module.exports = function (options, context, rs, logger, modules, services) {
       throw error;
     }
   };
-  /**
-   * @summary Asserts that text is not present in a PDF file
-   * @function assertNot
-   * @param {String} pdfFilePath - Relative or absolute path to the pdf file.
-   * @param {String} text - Text to assert.
-   * @param {Number=} pageNum - Page number.
-   * @param {String=} message - Message to throw if assertion fails.
-   * @param {Boolean=} reverse - Check also reverse variant of string.
+  /**
+   * @summary Asserts that text is not present in a PDF file
+   * @function assertNot
+   * @param {String} pdfFilePath - Relative or absolute path to the pdf file.
+   * @param {String} text - Text to assert.
+   * @param {Number=} pageNum - Page number.
+   * @param {String=} message - Message to throw if assertion fails.
+   * @param {Boolean=} reverse - Check also reverse variant of string.
    */
 
 
@@ -298,14 +298,14 @@ module.exports = function (options, context, rs, logger, modules, services) {
       throw error;
     }
   };
-  /**
-   * @summary Count the number of times specified text is present in a PDF file.
-   * @function count
-   * @param {String} pdfFilePath - Relative or absolute path to the pdf file.
-   * @param {String} text - Text to count.
-   * @param {Number=} pageNum - Page number.
-   * @param {Boolean=} reverse - Check also reverse variant of string.
-   * @return {Number} Number of times the specified text was found.
+  /**
+   * @summary Count the number of times specified text is present in a PDF file.
+   * @function count
+   * @param {String} pdfFilePath - Relative or absolute path to the pdf file.
+   * @param {String} text - Text to count.
+   * @param {Number=} pageNum - Page number.
+   * @param {Boolean=} reverse - Check also reverse variant of string.
+   * @return {Number} Number of times the specified text was found.
    */
 
 
@@ -325,4 +325,4 @@ module.exports = function (options, context, rs, logger, modules, services) {
 
   return module;
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_modules/module-pdf.js"],"names":["errHelper","require","path","PDFParser","countRows","searchStr","rows","reverse","result","strRegex","RegExp","reverseStrRegex","split","join","Object","keys","sort","y1","y2","parseFloat","some","y","line","replace","count","match","length","checkRows","inludes","reverseSearchStr","includes","assertion","pdfFilePath","text","pageNum","Promise","resolve","reject","pdfParser","on","err","errorMessage","parserError","OxError","errorCode","ASSERT_ERROR","pdfData","totalPages","formImage","Pages","SCRIPT_ERROR","processText","Texts","isFound","p","loadPDF","texts","t","item","decodeURIComponent","R","T","push","totalCount","validateString","arg","name","trim","validatePageNum","validateMessage","validateReverse","resolvePath","options","map","idx","charCodeAt","process","env","HOME","slice","cwd","rootPath","module","exports","context","rs","logger","modules","services","isInitialized","assert","message","error","ret","msg","e","assertNot","PDF_ERROR"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2019-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * @name pdf\r\n * @description Provides generic methods for working with PDF files.\r\n */\r\n\r\nimport OxError from '../errors/OxygenError';\r\nconst errHelper = require('../errors/helper');\r\nconst path = require('path');\r\nvar PDFParser = require('pdf2json/pdfparser');\r\n\r\nfunction countRows(searchStr, rows, reverse) {\r\n    let result = 0;\r\n    var strRegex = new RegExp(searchStr, 'g');\r\n    var reverseStrRegex = reverse ? new RegExp(searchStr.split('').reverse().join(''), 'g') : null;\r\n\r\n    Object.keys(rows) // => array of y-positions (type: float)\r\n        .sort((y1, y2) => parseFloat(y1) - parseFloat(y2)) // sort float positions\r\n        .some(y => {\r\n            var line = (rows[y] || []).join('').replace(/\\s/g, '');\r\n\r\n            var count = (line.match(strRegex) || []).length;\r\n            if (count === 0 && reverseStrRegex) {\r\n                count = (line.match(reverseStrRegex) || []).length;\r\n            }\r\n            result += count;\r\n        });\r\n\r\n    return result;\r\n}\r\n\r\nfunction checkRows(searchStr, rows, reverse) {\r\n    let result = false;\r\n\r\n    Object.keys(rows) // => array of y-positions (type: float)\r\n        .sort((y1, y2) => parseFloat(y1) - parseFloat(y2)) // sort float positions\r\n        .some(y => {\r\n\r\n            var line = (rows[y] || []).join('').replace(/\\s/g, '');\r\n\r\n            let inludes;\r\n\r\n            if (reverse) {\r\n                const reverseSearchStr = searchStr.split('').reverse().join('');\r\n                inludes = line.includes(searchStr) || line.includes(reverseSearchStr);\r\n            } else {\r\n                inludes = line.includes(searchStr);\r\n            }\r\n\r\n            if (inludes) {\r\n                result = true;\r\n                return true;\r\n            }\r\n        });\r\n\r\n    return result;\r\n}\r\n\r\nfunction assertion(pdfFilePath, text, pageNum = 0, reverse = false) {\r\n    let rows = {}; // indexed by y-position\r\n\r\n    return new Promise(function(resolve, reject) {\r\n        const searchStr = text.replace(/\\s/g, '');\r\n\r\n        let pdfParser = new PDFParser();\r\n        pdfParser.on('pdfParser_dataError', function(err) {\r\n            let errorMessage = err.parserError ? err.parserError : 'Error parsing the PDF.';\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, errorMessage);\r\n        });\r\n\r\n        pdfParser.on('pdfParser_dataReady', function (pdfData) {\r\n            var totalPages = pdfData.formImage.Pages.length;\r\n            if (pageNum && totalPages < pageNum - 1) {\r\n                throw new OxError(errHelper.errorCode.SCRIPT_ERROR, `Invalid argument - 'pageNum' is ${pageNum}, but PDF contains only ${totalPages} pages`);\r\n            }\r\n\r\n            // locate on a specific page\r\n            if (pageNum) {\r\n                processText(rows, pdfData.formImage.Pages[pageNum-1].Texts);\r\n                let isFound = checkRows(searchStr, rows, reverse);\r\n                resolve(!!isFound);\r\n                return;\r\n            }\r\n\r\n            // locate on any page\r\n            for (let p in pdfData.formImage.Pages) {\r\n                processText(rows, pdfData.formImage.Pages[p].Texts);\r\n                let isFound = checkRows(searchStr, rows, reverse);\r\n                if (isFound) {\r\n                    resolve(true);\r\n                    break;\r\n                }\r\n                rows = {}; // clear rows for next page\r\n            }\r\n\r\n            resolve(false);\r\n        });\r\n        pdfParser.loadPDF(pdfFilePath, 0);\r\n    });\r\n}\r\n\r\nfunction processText(rows, texts) {\r\n    for (var t in texts) {\r\n        var item = texts[t];\r\n        var text = decodeURIComponent(item.R[0].T);\r\n        // accumulate text items into rows object, per line\r\n        (rows[item.y] = rows[item.y] || []).push(text);\r\n    }\r\n}\r\n\r\nfunction count(pdfFilePath, text, pageNum = 0, reverse = false) {\r\n    let rows = {}; // indexed by y-position\r\n    let totalCount = 0;\r\n\r\n    return new Promise(function(resolve, reject) {\r\n        const searchStr = text.replace(/\\s/g, '');\r\n\r\n        let pdfParser = new PDFParser();\r\n        pdfParser.on('pdfParser_dataError', function(err) {\r\n            let errorMessage = err.parserError ? err.parserError : 'Error parsing the PDF.';\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, errorMessage);\r\n        });\r\n\r\n        pdfParser.on('pdfParser_dataReady', function (pdfData) {\r\n            let totalPages = pdfData.formImage.Pages.length;\r\n            if (pageNum && totalPages < pageNum - 1) {\r\n                throw new OxError(errHelper.errorCode.SCRIPT_ERROR, `Invalid argument - 'pageNum' is ${pageNum}, but PDF contains only ${totalPages} pages`);\r\n            }\r\n\r\n            // count on a specific page\r\n            if (pageNum) {\r\n                processText(rows, pdfData.formImage.Pages[pageNum-1].Texts);\r\n                let count = countRows(searchStr, rows, reverse);\r\n                resolve(count);\r\n                return;\r\n            }\r\n\r\n            // count on all pages\r\n            for (var p in pdfData.formImage.Pages) {\r\n                processText(rows, pdfData.formImage.Pages[p].Texts);\r\n                let count = countRows(searchStr, rows, reverse);\r\n                if (count > 0) {\r\n                    totalCount += count;\r\n                }\r\n                rows = {}; // clear rows for next page\r\n            }\r\n\r\n            resolve(totalCount);\r\n        });\r\n        pdfParser.loadPDF(pdfFilePath, 0);\r\n    });\r\n}\r\n\r\nfunction validateString(arg, name) {\r\n    if (arg && typeof arg === 'string' && arg.trim().length > 0) {\r\n        // text is correct\r\n    } else {\r\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-empty string.\");\r\n    }\r\n}\r\n\r\nfunction validatePageNum(arg, name) {\r\n    if (arg === null || (arg && typeof arg === 'number' && arg > 0)) {\r\n        // pageNum is correct\r\n    } else {\r\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-negative number.\");\r\n    }\r\n}\r\n\r\nfunction validateMessage(arg, name) {\r\n    if (arg === null || (arg && typeof arg === 'string' && arg.trim().length > 0)) {\r\n        // pageNum is correct\r\n    } else {\r\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-empty string.\");\r\n    }\r\n}\r\n\r\nfunction validateReverse(arg, name) {\r\n    if (arg === null || (typeof arg !== 'undefined' && typeof arg === 'boolean')) {\r\n        // pageNum is correct\r\n    } else {\r\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a boolean\");\r\n    }\r\n}\r\n\r\nfunction resolvePath(pdfFilePath, options) {\r\n\r\n    pdfFilePath = pdfFilePath.trim().split('').map((item, idx) => {\r\n        return ![8206, 8296].includes(pdfFilePath.charCodeAt(idx)) ? item : null;\r\n    }).join('');\r\n\r\n    if (pdfFilePath[0] === '~') {\r\n        // resolve path relative to home directory\r\n        return path.join(process.env.HOME, pdfFilePath.slice(1));\r\n    } else {\r\n        let cwd = process.cwd();\r\n\r\n        if (options && options.cwd) {\r\n            cwd = options.cwd;\r\n        }\r\n\r\n        if (options && options.rootPath) {\r\n            cwd = options.rootPath;\r\n        }\r\n\r\n        cwd = cwd.trim();\r\n\r\n        return path.resolve(cwd, pdfFilePath);\r\n    }\r\n}\r\n\r\nmodule.exports = function(options, context, rs, logger, modules, services) {\r\n\r\n    module.isInitialized = function() {\r\n        return true;\r\n    };\r\n\r\n    /**\r\n     * @summary Asserts that text is present in a PDF file\r\n     * @function assert\r\n     * @param {String} pdfFilePath - Relative or absolute path to the PDF file.\r\n     * @param {String} text - Text to assert.\r\n     * @param {Number=} pageNum - Page number.\r\n     * @param {String=} message - Message to throw if assertion fails.\r\n     * @param {Boolean=} reverse - Check also reverse variant of string.\r\n     */\r\n    module.assert = async function(pdfFilePath, text, pageNum = null, message = null, reverse = false) {\r\n        validateString(pdfFilePath, 'pdfFilePath');\r\n        validateString(text, 'text');\r\n        validatePageNum(pageNum, 'pageNum');\r\n        validateMessage(message, 'message');\r\n        validateReverse(reverse, 'reverse');\r\n\r\n        pdfFilePath = resolvePath(pdfFilePath, options);\r\n\r\n        let error;\r\n        try {\r\n            const ret = await assertion(pdfFilePath, text, pageNum, reverse);\r\n\r\n            if (!ret) {\r\n                if (message) {\r\n                    throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n                }\r\n\r\n                let msg = `\"${text}\" is not found in the PDF ${pageNum ? 'on page ' + pageNum : ''}`;\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, msg);\r\n            }\r\n\r\n        } catch (e) {\r\n            error = new OxError(errHelper.errorCode.ASSERT_ERROR, e.message);\r\n        }\r\n\r\n        if (error) {\r\n            throw error;\r\n        }\r\n\r\n    };\r\n\r\n    /**\r\n     * @summary Asserts that text is not present in a PDF file\r\n     * @function assertNot\r\n     * @param {String} pdfFilePath - Relative or absolute path to the pdf file.\r\n     * @param {String} text - Text to assert.\r\n     * @param {Number=} pageNum - Page number.\r\n     * @param {String=} message - Message to throw if assertion fails.\r\n     * @param {Boolean=} reverse - Check also reverse variant of string.\r\n     */\r\n    module.assertNot = async function(pdfFilePath, text, pageNum = null, message = null, reverse = false) {\r\n        validateString(pdfFilePath, 'pdfFilePath');\r\n        validateString(text, 'text');\r\n        validatePageNum(pageNum, 'pageNum');\r\n        validateMessage(message, 'message');\r\n        validateReverse(reverse, 'reverse');\r\n\r\n        pdfFilePath = resolvePath(pdfFilePath, options);\r\n\r\n        let error;\r\n        try {\r\n            const ret = await assertion(pdfFilePath, text, pageNum, reverse);\r\n\r\n            if (ret) {\r\n                if (message) {\r\n                    throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\r\n                }\r\n\r\n                let msg = `\"${text}\" is found in the PDF ${pageNum ? 'on page ' + pageNum : ''}`;\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, msg);\r\n            }\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, e.message);\r\n        }\r\n\r\n        if (error) {\r\n            throw error;\r\n        }\r\n    };\r\n\r\n    /**\r\n     * @summary Count the number of times specified text is present in a PDF file.\r\n     * @function count\r\n     * @param {String} pdfFilePath - Relative or absolute path to the pdf file.\r\n     * @param {String} text - Text to count.\r\n     * @param {Number=} pageNum - Page number.\r\n     * @param {Boolean=} reverse - Check also reverse variant of string.\r\n     * @return {Number} Number of times the specified text was found.\r\n     */\r\n    module.count = async function(pdfFilePath, text, pageNum = null, reverse = false) {\r\n        validateString(pdfFilePath, 'pdfFilePath');\r\n        validateString(text, 'text');\r\n        validatePageNum(pageNum, 'pageNum');\r\n        validateReverse(reverse, 'reverse');\r\n\r\n        pdfFilePath = resolvePath(pdfFilePath, options);\r\n\r\n        try {\r\n            return await count(pdfFilePath, text, pageNum, reverse);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.PDF_ERROR, e.message || e);\r\n        }\r\n    };\r\n\r\n    return module;\r\n};\r\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_modules/module-pdf.js"],"names":["errHelper","require","path","PDFParser","countRows","searchStr","rows","reverse","result","strRegex","RegExp","reverseStrRegex","split","join","Object","keys","sort","y1","y2","parseFloat","some","y","line","replace","count","match","length","checkRows","inludes","reverseSearchStr","includes","assertion","pdfFilePath","text","pageNum","Promise","resolve","reject","pdfParser","on","err","errorMessage","parserError","OxError","errorCode","ASSERT_ERROR","pdfData","totalPages","formImage","Pages","SCRIPT_ERROR","processText","Texts","isFound","p","loadPDF","texts","t","item","decodeURIComponent","R","T","push","totalCount","validateString","arg","name","trim","validatePageNum","validateMessage","validateReverse","resolvePath","options","map","idx","charCodeAt","process","env","HOME","slice","cwd","rootPath","module","exports","context","rs","logger","modules","services","isInitialized","assert","message","error","ret","msg","e","assertNot","PDF_ERROR"],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2019-present CloudBeat Limited\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n */\n\n/**\n * @name pdf\n * @description Provides generic methods for working with PDF files.\n */\n\nimport OxError from '../errors/OxygenError';\nconst errHelper = require('../errors/helper');\nconst path = require('path');\nvar PDFParser = require('pdf2json/pdfparser');\n\nfunction countRows(searchStr, rows, reverse) {\n    let result = 0;\n    var strRegex = new RegExp(searchStr, 'g');\n    var reverseStrRegex = reverse ? new RegExp(searchStr.split('').reverse().join(''), 'g') : null;\n\n    Object.keys(rows) // => array of y-positions (type: float)\n        .sort((y1, y2) => parseFloat(y1) - parseFloat(y2)) // sort float positions\n        .some(y => {\n            var line = (rows[y] || []).join('').replace(/\\s/g, '');\n\n            var count = (line.match(strRegex) || []).length;\n            if (count === 0 && reverseStrRegex) {\n                count = (line.match(reverseStrRegex) || []).length;\n            }\n            result += count;\n        });\n\n    return result;\n}\n\nfunction checkRows(searchStr, rows, reverse) {\n    let result = false;\n\n    Object.keys(rows) // => array of y-positions (type: float)\n        .sort((y1, y2) => parseFloat(y1) - parseFloat(y2)) // sort float positions\n        .some(y => {\n\n            var line = (rows[y] || []).join('').replace(/\\s/g, '');\n\n            let inludes;\n\n            if (reverse) {\n                const reverseSearchStr = searchStr.split('').reverse().join('');\n                inludes = line.includes(searchStr) || line.includes(reverseSearchStr);\n            } else {\n                inludes = line.includes(searchStr);\n            }\n\n            if (inludes) {\n                result = true;\n                return true;\n            }\n        });\n\n    return result;\n}\n\nfunction assertion(pdfFilePath, text, pageNum = 0, reverse = false) {\n    let rows = {}; // indexed by y-position\n\n    return new Promise(function(resolve, reject) {\n        const searchStr = text.replace(/\\s/g, '');\n\n        let pdfParser = new PDFParser();\n        pdfParser.on('pdfParser_dataError', function(err) {\n            let errorMessage = err.parserError ? err.parserError : 'Error parsing the PDF.';\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, errorMessage);\n        });\n\n        pdfParser.on('pdfParser_dataReady', function (pdfData) {\n            var totalPages = pdfData.formImage.Pages.length;\n            if (pageNum && totalPages < pageNum - 1) {\n                throw new OxError(errHelper.errorCode.SCRIPT_ERROR, `Invalid argument - 'pageNum' is ${pageNum}, but PDF contains only ${totalPages} pages`);\n            }\n\n            // locate on a specific page\n            if (pageNum) {\n                processText(rows, pdfData.formImage.Pages[pageNum-1].Texts);\n                let isFound = checkRows(searchStr, rows, reverse);\n                resolve(!!isFound);\n                return;\n            }\n\n            // locate on any page\n            for (let p in pdfData.formImage.Pages) {\n                processText(rows, pdfData.formImage.Pages[p].Texts);\n                let isFound = checkRows(searchStr, rows, reverse);\n                if (isFound) {\n                    resolve(true);\n                    break;\n                }\n                rows = {}; // clear rows for next page\n            }\n\n            resolve(false);\n        });\n        pdfParser.loadPDF(pdfFilePath, 0);\n    });\n}\n\nfunction processText(rows, texts) {\n    for (var t in texts) {\n        var item = texts[t];\n        var text = decodeURIComponent(item.R[0].T);\n        // accumulate text items into rows object, per line\n        (rows[item.y] = rows[item.y] || []).push(text);\n    }\n}\n\nfunction count(pdfFilePath, text, pageNum = 0, reverse = false) {\n    let rows = {}; // indexed by y-position\n    let totalCount = 0;\n\n    return new Promise(function(resolve, reject) {\n        const searchStr = text.replace(/\\s/g, '');\n\n        let pdfParser = new PDFParser();\n        pdfParser.on('pdfParser_dataError', function(err) {\n            let errorMessage = err.parserError ? err.parserError : 'Error parsing the PDF.';\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, errorMessage);\n        });\n\n        pdfParser.on('pdfParser_dataReady', function (pdfData) {\n            let totalPages = pdfData.formImage.Pages.length;\n            if (pageNum && totalPages < pageNum - 1) {\n                throw new OxError(errHelper.errorCode.SCRIPT_ERROR, `Invalid argument - 'pageNum' is ${pageNum}, but PDF contains only ${totalPages} pages`);\n            }\n\n            // count on a specific page\n            if (pageNum) {\n                processText(rows, pdfData.formImage.Pages[pageNum-1].Texts);\n                let count = countRows(searchStr, rows, reverse);\n                resolve(count);\n                return;\n            }\n\n            // count on all pages\n            for (var p in pdfData.formImage.Pages) {\n                processText(rows, pdfData.formImage.Pages[p].Texts);\n                let count = countRows(searchStr, rows, reverse);\n                if (count > 0) {\n                    totalCount += count;\n                }\n                rows = {}; // clear rows for next page\n            }\n\n            resolve(totalCount);\n        });\n        pdfParser.loadPDF(pdfFilePath, 0);\n    });\n}\n\nfunction validateString(arg, name) {\n    if (arg && typeof arg === 'string' && arg.trim().length > 0) {\n        // text is correct\n    } else {\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-empty string.\");\n    }\n}\n\nfunction validatePageNum(arg, name) {\n    if (arg === null || (arg && typeof arg === 'number' && arg > 0)) {\n        // pageNum is correct\n    } else {\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-negative number.\");\n    }\n}\n\nfunction validateMessage(arg, name) {\n    if (arg === null || (arg && typeof arg === 'string' && arg.trim().length > 0)) {\n        // pageNum is correct\n    } else {\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a non-empty string.\");\n    }\n}\n\nfunction validateReverse(arg, name) {\n    if (arg === null || (typeof arg !== 'undefined' && typeof arg === 'boolean')) {\n        // pageNum is correct\n    } else {\n        throw new OxError(errHelper.errorCode.SCRIPT_ERROR, \"Invalid argument - '\" + name + \"' should be a boolean\");\n    }\n}\n\nfunction resolvePath(pdfFilePath, options) {\n\n    pdfFilePath = pdfFilePath.trim().split('').map((item, idx) => {\n        return ![8206, 8296].includes(pdfFilePath.charCodeAt(idx)) ? item : null;\n    }).join('');\n\n    if (pdfFilePath[0] === '~') {\n        // resolve path relative to home directory\n        return path.join(process.env.HOME, pdfFilePath.slice(1));\n    } else {\n        let cwd = process.cwd();\n\n        if (options && options.cwd) {\n            cwd = options.cwd;\n        }\n\n        if (options && options.rootPath) {\n            cwd = options.rootPath;\n        }\n\n        cwd = cwd.trim();\n\n        return path.resolve(cwd, pdfFilePath);\n    }\n}\n\nmodule.exports = function(options, context, rs, logger, modules, services) {\n\n    module.isInitialized = function() {\n        return true;\n    };\n\n    /**\n     * @summary Asserts that text is present in a PDF file\n     * @function assert\n     * @param {String} pdfFilePath - Relative or absolute path to the PDF file.\n     * @param {String} text - Text to assert.\n     * @param {Number=} pageNum - Page number.\n     * @param {String=} message - Message to throw if assertion fails.\n     * @param {Boolean=} reverse - Check also reverse variant of string.\n     */\n    module.assert = async function(pdfFilePath, text, pageNum = null, message = null, reverse = false) {\n        validateString(pdfFilePath, 'pdfFilePath');\n        validateString(text, 'text');\n        validatePageNum(pageNum, 'pageNum');\n        validateMessage(message, 'message');\n        validateReverse(reverse, 'reverse');\n\n        pdfFilePath = resolvePath(pdfFilePath, options);\n\n        let error;\n        try {\n            const ret = await assertion(pdfFilePath, text, pageNum, reverse);\n\n            if (!ret) {\n                if (message) {\n                    throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\n                }\n\n                let msg = `\"${text}\" is not found in the PDF ${pageNum ? 'on page ' + pageNum : ''}`;\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, msg);\n            }\n\n        } catch (e) {\n            error = new OxError(errHelper.errorCode.ASSERT_ERROR, e.message);\n        }\n\n        if (error) {\n            throw error;\n        }\n\n    };\n\n    /**\n     * @summary Asserts that text is not present in a PDF file\n     * @function assertNot\n     * @param {String} pdfFilePath - Relative or absolute path to the pdf file.\n     * @param {String} text - Text to assert.\n     * @param {Number=} pageNum - Page number.\n     * @param {String=} message - Message to throw if assertion fails.\n     * @param {Boolean=} reverse - Check also reverse variant of string.\n     */\n    module.assertNot = async function(pdfFilePath, text, pageNum = null, message = null, reverse = false) {\n        validateString(pdfFilePath, 'pdfFilePath');\n        validateString(text, 'text');\n        validatePageNum(pageNum, 'pageNum');\n        validateMessage(message, 'message');\n        validateReverse(reverse, 'reverse');\n\n        pdfFilePath = resolvePath(pdfFilePath, options);\n\n        let error;\n        try {\n            const ret = await assertion(pdfFilePath, text, pageNum, reverse);\n\n            if (ret) {\n                if (message) {\n                    throw new OxError(errHelper.errorCode.ASSERT_ERROR, message);\n                }\n\n                let msg = `\"${text}\" is found in the PDF ${pageNum ? 'on page ' + pageNum : ''}`;\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, msg);\n            }\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, e.message);\n        }\n\n        if (error) {\n            throw error;\n        }\n    };\n\n    /**\n     * @summary Count the number of times specified text is present in a PDF file.\n     * @function count\n     * @param {String} pdfFilePath - Relative or absolute path to the pdf file.\n     * @param {String} text - Text to count.\n     * @param {Number=} pageNum - Page number.\n     * @param {Boolean=} reverse - Check also reverse variant of string.\n     * @return {Number} Number of times the specified text was found.\n     */\n    module.count = async function(pdfFilePath, text, pageNum = null, reverse = false) {\n        validateString(pdfFilePath, 'pdfFilePath');\n        validateString(text, 'text');\n        validatePageNum(pageNum, 'pageNum');\n        validateReverse(reverse, 'reverse');\n\n        pdfFilePath = resolvePath(pdfFilePath, options);\n\n        try {\n            return await count(pdfFilePath, text, pageNum, reverse);\n        }\n        catch (e) {\n            throw new OxError(errHelper.errorCode.PDF_ERROR, e.message || e);\n        }\n    };\n\n    return module;\n};\n"]}