@baravak/risloo-profile-cli 3.1.0

package/.yarnrc.yml

@@ -0,0 +1 @@
+yarnPath: .yarn/releases/yarn-1.22.19.cjs

package/README.md

@@ -0,0 +1,98 @@
+# Introduction
+
+**Risloo Profile CLI** is a library for creating profiles, reports and sheets for *psychological* samples.
+
+# Installation
+
+In order to install the package, you can write the code below in your terminal:
+
+```
+npm install -g risloo-profile-cli
+```
+
+# How Does It Work?
+
+This library is equipped with a CLI in order to create the profiles, reports and sheets you need for your samples.
+The structure of the CLI is as follows:
+
+### Main Structure
+
+```
+risloo [command]
+```
+
+### Commands
+
+```
+extract|D <sampleName> [sampleOutputs...] [options]
+gift|G [options]
+test|T [options]
+```
+
+### **extract** Command
+
+Using this command, you can draw extract profiles, reports and sheets out of psychological samples.
+
+```
+Arguments:
+  sampleName                          Name of the Sample
+  sampleOutputs                       Outputs To Be Extracted Out of Sample, Choices: {profile, report, sheet}, Default: ["profile"]
+
+Options:
+  -p, --profile-variant <variant>     Variant of the Profile, Choices: {both, raw, with-sidebar}, Default: both
+  -i, --input-type <type>             Type of Input, Choices: {local, remote, raw-json, stdin}, Default: local
+  -d, --input-data <data>             Input Data
+  -o, --output-type <type>            Type of Output, Choices: {local, remote}, Default: local
+  -a, --output-address <address>      Output Address
+  -n, --name <name>                   Name of Output Profile (Required in "stdin" Input Type)
+  -m, --measure                       Additional Feature for Measuring Dimensions and Distances, Default: false
+  -b, --benchmark                     Time Benchmarking of Command, Default: false
+```
+
+### **gift** Command
+
+Using this command, you can create special gifts for users and customers.
+
+```
+Options:
+  -s, --gift-status <status>          Gift Status, Choices: {both, open, expired}, Default: both
+  -i, --input-type <type>             Type of Input, Choices: {raw-json, local}, Default: raw-json
+  -d, --input-data <data>             Input Data
+  -a, --output-address <address>      Output Address
+  -b, --benchmark                     Time Benchmarking of Command, Default: false
+```
+
+# CLI Status Codes
+
+The **Status Codes** after entering a command is as follows:
+
+Profiles Status:
+
+  | Status Code | Label | Description |
+  | ----------- | ----- | ----------- |
+  | 0 | Success | Profiles Successfully Created! |
+  | 1 | Not Found | Input Data File Does Not Exist! |
+  | 2 | Profile JS Error | Error in Instantiating the Profile Object |
+  | 3 | Invalid Name | Profile Name Is Not Valid |
+  | 4 | Not Found | Profile Template File Does Not Exist |
+  | 5 | General Error | Something Went Wrong In The Input Data File! |
+  | 6 | General Error | Something Went Wrong In The JS Files! |
+
+Gifts Status:
+
+  | Status Code | Label | Description |
+  | ----------- | ----- | ----------- |
+  | 0 | Success | Gifts Successfully Created! |
+
+# Naming Variables Stratrgy
+
+This part is of great importance if you are going to develop and change the source code. We tried much to make code neat and clean, hence commented nearly completely, so that you on the role of developer are able to understand the code rationale as soon as possible!!
+
+The *rules* taken into account in the time of creating the variables are:
+
+1. ***items*** is the general term for array of data elements to be drawn inside the profile. An item might contain mark, label, numerical (and maybe non-numerical) values required for drawing (e.g. width, angle, point coordinate, color, opacity and ...).
+2. If there is the total data element and it has enough differences from other elements (so-called ***items***), we name it ***raw*** which is an object with properties identical to any element of *items*.
+3. If there is any scale or periodic graduation in the profile, we name it ***ticks*** which is an array including objects with tick number, numerical parameter required for drawing (e.g. coordinate, angle, width, height or ...).
+4. The ***s*** located at the end of a variable name denotes the array nature of that variable and there is no need for the matter to be emphasized with the suffix ***Arr***.
+5. Structure for the Dataset Score: `dataset.score = [{label: {eng, ...others}, mark}]`
+

package/bin/risloo.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+require("../src/cli")
+  .cli(process.argv)
+  .catch((err) => {console.error(err)});
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.log("Unhandled Rejection at:", promise, "reason:", reason);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@baravak/risloo-profile-cli",
+  "version": "3.1.0",
+  "description": "**Risloo Profile CLI** is a library for creating profiles, reports and sheets for *psychological* samples.",
+  "main": "bin/risloo.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "risloo": "bin/risloo.js"
+  },
+  "scripts": {
+    "bot": "node ./src/publish/bot.js",
+    "test": "node ./src/publish/test.js",
+    "prepublishOnly": "npm test",
+    "postpublish": "npm run bot",
+    "start": "node app"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baravak/risloo-extractor-app.git"
+  },
+  "author": "Mahdi Amirabadi",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.3",
+    "commander": "^8.3.0",
+    "dotenv": "^16.0.0",
+    "form-data": "^4.0.0",
+    "handlebars": "^4.7.7",
+    "moment": "^2.29.1",
+    "moment-jalaali": "^0.9.2",
+    "prettier": "^2.4.1",
+    "qrcode": "^1.5.0",
+    "sharp": "^0.30.1"
+  },
+  "packageManager": "yarn@1.22.19",
+  "bugs": {
+    "url": "https://github.com/baravak/risloo-extractor-app/issues"
+  },
+  "homepage": "https://github.com/baravak/risloo-extractor-app#readme",
+  "devDependencies": {}
+}

package/src/Gift.js

@@ -0,0 +1,29 @@
+const moment = require("moment-jalaali");
+
+moment.locale("fa");
+moment.loadPersian({ dialect: "persian-modern" });
+
+class Gift {
+  constructor(gift, avatar) {
+    this.name = gift.code;
+    this.title = gift.title || "-";
+    this.code = gift.code.slice(10) || "-";
+    this.type = gift.type || "-";
+    this.value = gift.value || "-";
+    (this.started_at = (gift.started_at && this._formatDate(gift.started_at)) || "-"),
+      (this.expires_at = (gift.expires_at && this._formatDate(gift.expires_at)) || ""),
+      (this.region = {
+        id: gift.region.id || "-",
+        type: gift.region.type,
+        title: gift.region.detail.title || "-",
+        avatarBase64: avatar && Buffer.from(avatar, "binary").toString("base64"),
+      });
+  }
+
+  // Convert Given Timestamp to Proper Format for Gift
+  _formatDate(timeStamp) {
+    return moment(timeStamp * 1000).format("jDD / jMM / jYYYY");
+  }
+}
+
+module.exports = Gift;

package/src/Profile.js

@@ -0,0 +1,405 @@
+const moment = require("moment-jalaali");
+const qrCodeGenerator = require("./qrcode/qrCodeGenerator");
+
+moment.locale("fa");
+moment.loadPersian({ dialect: "persian-modern" });
+
+// Implement String.prototype.format
+String.prototype.format = function () {
+  var args = arguments;
+  return this.replace(/{(\d+)}/g, function (match, number) {
+    return typeof args[number] != "undefined" ? args[number] : match;
+  });
+};
+
+class FS {
+  static calcDistance(pt1, pt2) {
+    return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
+  }
+
+  static toDegrees(rad) {
+    return rad * (180 / Math.PI);
+  }
+
+  static toRadians(deg) {
+    return deg * (Math.PI / 180);
+  }
+
+  static isOdd(n) {
+    return !!(n % 2);
+  }
+
+  // Create a Line Using the Two Points and Return It As A Function
+  static createLine(pt1, pt2) {
+    let m = (pt2.y - pt1.y) / (pt2.x - pt1.x);
+    let intercept = -m * pt1.x + pt1.y;
+
+    return function (point) {
+      return m * point + intercept;
+    };
+  }
+
+  // Create Arithmetic Sequence for Angles of Polygon
+
+  static createArithmeticSequence(a_0, d, n) {
+    let i;
+    let arr = [];
+    for (i = 0; i < n; i++) {
+      arr.push(a_0 + i * d);
+    }
+    return arr;
+  }
+
+  // Round to 2 Decimal Places
+  static roundTo2(n) {
+    return +n.toFixed(2);
+  }
+
+  // Rotate Axes of 2D Coordinate System for a Point (Counterclockwise)
+
+  static rotateAxes(pt, theta) {
+    return {
+      x: FS.roundTo2(pt.x * Math.cos(theta) - pt.y * Math.sin(theta)),
+      y: FS.roundTo2(pt.x * Math.sin(theta) + pt.y * Math.cos(theta)),
+    };
+  }
+
+  // Translate Axes of 2D Coordinate System for a Point
+
+  static translateAxes(pt, d) {
+    return { x: FS.roundTo2(pt.x - d.x), y: FS.roundTo2(pt.y - d.y) };
+  }
+
+  // Transform Axes of 2D Coordinate System for a Point
+
+  static transformAxes(pt, d, theta) {
+    return FS.rotateAxes(FS.translateAxes(pt, d), theta);
+  }
+
+  // Check Whether an Object is Empty
+  static isEmpty(obj) {
+    return Object.keys(obj).length === 0;
+  }
+
+  static isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+
+  static deepMerge(target, source) {
+    if (FS.isObject(target) && FS.isObject(source)) {
+      for (const key in source) {
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (FS.isObject(source[key]) && !(descriptor["get"] || descriptor["set"])) {
+          if (!target[key]) Object.assign(target, { [key]: {} });
+          FS.deepMerge(target[key], source[key]);
+        } else {
+          Object.defineProperties(target, {
+            [key]: descriptor,
+          });
+        }
+      }
+    }
+  }
+}
+
+// Classes
+
+class Canvas {
+  constructor(canvas, variant) {
+    this.width = canvas.width;
+    this.height = canvas.height;
+    this._init(canvas, variant);
+  }
+
+  _init(canvas, variant) {
+    this.profile = { width: this.width, height: this.height };
+    if (variant === "with-sidebar") {
+      this.header = canvas["sidebar-variant"].header;
+      this.sidebar = canvas["sidebar-variant"].sidebar;
+      this.profile = {
+        width: this.width - this.sidebar.width,
+        height: this.height - this.header.height,
+      };
+    }
+    this.profile["padding"] = canvas.profile.padding;
+  }
+}
+
+class Dataset {
+  // Default Sample Info for the Profile
+  defaultSample = {
+    questions: false,
+    defaultFields: true,
+    fields: [],
+  };
+
+  // Default Prerequisites to Be Shown in the Sidebar
+  defaultFields = ["gender", "age", "education", "marital_status"];
+
+  constructor(dataset, spec) {
+    // Getting Class Fields
+    const { defaultSample, defaultFields } = this;
+
+    // Destructure Required Info from Spec of the Profile
+    const { labels, sample = defaultSample, labelsPrefix } = spec;
+
+    // Specifying Prerequisites that are Going to Be Extracted
+    // *** Remember That You Should Get The Copy of Arrays Taken from Spec of the Profile
+    const requiredPreqs = sample.defaultFields ? [...defaultFields, ...sample.fields] : [...sample.fields];
+
+    this.info = {
+      id: dataset.id || "-",
+      title: dataset.scale?.title || "-",
+      clientName: dataset.client?.name || "-",
+      managerName: dataset.room?.manager?.name || "-",
+      centerTitle: dataset.room?.center?.detail?.title || "-",
+      started_at: (dataset.started_at && this._formatDate(dataset.started_at)) || "-",
+      closed_at: (dataset.closed_at && this._formatDate(dataset.closed_at)) || "-",
+      scored_at: (dataset.scored_at && this._formatDate(dataset.scored_at)) || "-",
+      time: this._formatTime(dataset.cornometer) || "-",
+      fields: dataset.prerequisites ? this._extractFields(dataset.prerequisites, requiredPreqs) : dataset.fields,
+    };
+
+    // Extract Questions if sample.questions === true
+    // *** Remember That You Should Get The Copy of Arrays Taken from Dataset
+    this.questions = sample.questions && [...dataset.items];
+
+    this.score = this._extractData(dataset.score, labels, labelsPrefix);
+  }
+
+  // Convert Given Timestamp to Proper Format for Profile
+  _formatDate(timeStamp) {
+    return moment(timeStamp * 1000).format("jYYYY.jMM.jDD  -  HH:mm");
+  }
+
+  // Convert Given Time to Proper Format for Profile
+  _formatTime(sec) {
+    const time = {
+      hour: Math.floor(sec / 60),
+      minute: sec % 60,
+    };
+
+    return (
+      (time.hour ? `${time.hour} ساعت` : "") +
+      (time.hour && time.minute ? " و " : "") +
+      (time.minute ? `${time.minute} دقیقه` : "")
+    );
+  }
+
+  // Extract Fields Using the Prerequisities Array
+  _extractFields(preqs, requiredPreqs) {
+    // "Fields" is the Output of the Method
+    const fields = [];
+
+    let field;
+
+    requiredPreqs.forEach((reqPreq) => {
+      if ((FS.isObject(reqPreq) && reqPreq["eng"]) || !FS.isObject(reqPreq)) field = this._extractField(preqs, reqPreq);
+      else field = this._mergeFields(preqs, reqPreq);
+      fields.push(field);
+    });
+
+    return fields;
+  }
+
+  _extractField(preqs, reqPreq) {
+    let engLabel = reqPreq.eng || reqPreq;
+    let preq = preqs?.find((item) => item.label === engLabel);
+    return { eng: engLabel, fr: reqPreq.fr || preq?.text || "-", value: this._extractValue(preq) };
+  }
+
+  _mergeFields(preqs, reqPreq) {
+    let values = reqPreq["merge"].map((label) => {
+      let preq = preqs.find((item) => item.label === label);
+      return this._extractValue(preq);
+    });
+    return { eng: reqPreq["merge"].join("+"), fr: reqPreq.fr, value: reqPreq.valueFormat.format(...values) };
+  }
+
+  _extractValue(preq) {
+    let val;
+
+    if (preq?.answer.type !== "select") val = preq?.user_answered || "-";
+    else val = preq?.answer.options[preq.user_answered - 1] || "-";
+
+    return val;
+  }
+
+  // Create Data Array with Label and Mark Taken from Dataset
+  _extractData(score, labels, labelsPrefix) {
+    return labels.map((label) => ({
+      label,
+      mark: score[label.eng] || score[`${labelsPrefix}_${label.eng}`],
+    }));
+  }
+
+  // Group By Special Property of the Label of the Dataset Score
+  groupBy(prop) {
+    const { score } = this;
+
+    const scoreGroups = score.reduce((groups, data, index) => {
+      const group = groups.find((group) => group[0].label[prop] === data.label[prop] && data.label[prop] !== "-");
+      if (group) group.push(data);
+      else groups.push([data]);
+      return groups;
+    }, []);
+
+    return scoreGroups;
+  }
+}
+
+class Mappings extends Array {
+  addMapping(range, value) {
+    this.push({ range, value });
+    return this;
+  }
+
+  map(val) {
+    const me = this;
+    for (let mapping of me) {
+      const splitted = mapping.range.split("-");
+      if (splitted.length === 1) {
+        if (+splitted[0] === val) return mapping.value;
+      } else if (+splitted[0] <= val && val <= +splitted[1]) {
+        return mapping.value;
+      }
+    }
+  }
+}
+
+class Ticks {
+  constructor(min, max, n) {
+    this.numbers = this._calcNumbers(min, max, n);
+  }
+
+  _calcNumbers(min, max, n) {
+    let output = [min];
+    const commonDiff = FS.roundTo2((max - min) / (n - 1));
+    output.push(...FS.createArithmeticSequence(min + commonDiff, commonDiff, n - 2), max);
+    return output;
+  }
+}
+
+class Spec {
+  constructor(config, profileSpec) {
+    this.parameters = {
+      canvas: {
+        width: 1123,
+        height: 794,
+        profile: {
+          padding: 20,
+        },
+        "sidebar-variant": {
+          header: {
+            height: 40,
+            paddingX: 20,
+          },
+          sidebar: {
+            width: 180,
+            height: 754,
+            iconPadding: 10,
+            padding: {
+              x: 20,
+              y: 20,
+            },
+            lineHeight: {
+              low: 19,
+              medium: 20,
+              high: 21,
+            },
+            icons: {
+              offsetY: 27,
+              paddingX: 7,
+              person: {
+                width: 14.22,
+                ratio: 16 / 18,
+              },
+              calender: {
+                width: 14.17,
+                ratio: 15 / 18,
+              },
+              clock: {
+                width: 14.53,
+                ratio: 16 / 16,
+              },
+            },
+            fields: {
+              lineHeight: 20,
+              offsetY: 46,
+              paddingX: 11,
+            },
+            qrcode: {
+              width: 80,
+              get height() {
+                return this.width;
+              },
+            },
+          },
+        },
+      },
+      ...profileSpec,
+    };
+    this._setConfig(config);
+  }
+
+  _setConfig(config) {
+    const { parameters } = this;
+
+    FS.deepMerge(parameters, config);
+  }
+}
+
+class Profile {
+  constructor() {
+    if (this.constructor.name === "Profile") throw new Error("Can't Instantiate Abstract Class");
+  }
+
+  _init(dataset, options, config) {
+    const { variant, measure } = options;
+    this.variant = variant;
+    this.measure = measure;
+
+    this.spec = new Spec(config, this.profileSpec);
+    const { canvas } = this.spec.parameters;
+    this.canvas = new Canvas(canvas, variant);
+
+    this.dataset = new Dataset(dataset, this.spec.parameters);
+
+    if (this.variant === "with-sidebar") this._generateQRCode();
+
+    this.contextArr = this._calcContext();
+  }
+
+  _generateQRCode() {
+    const { dataset, canvas } = this;
+    const width = canvas.sidebar?.qrcode?.width || 120;
+    const height = canvas.sidebar?.qrcode?.height || 120;
+    const data = `https://r1l.ir/${dataset.info.id}/?utm_source=risloo.ir&utm_medium=profile&utm_campaign=${dataset.info.id}`;
+    this.qrcode = { link: data, svg: qrCodeGenerator(data, { width, height }) };
+  }
+
+  getTemplateEngineParams() {
+    const {
+      variant,
+      measure,
+      canvas,
+      dataset,
+      spec: { parameters: spec },
+      qrcode,
+      contextArr,
+    } = this;
+
+    return contextArr.map((context, index) => ({
+      page: index + 1,
+      canvas,
+      dataset,
+      spec,
+      qrcode,
+      ...context,
+      variant,
+      measure,
+    }));
+  }
+}
+
+module.exports = { Profile, Dataset, FS, Ticks, Mappings };

package/src/cli-commands/Executor.js

@@ -0,0 +1,118 @@
+const { checkAndLoad, loadStdin, ensureDirExistence, createSVG, createPNG } = require("./utilities/BaseOps");
+const Handlebars = require("../handlebars/init");
+const path = require("path");
+const Benchmarker = require("./utilities/Benchmarker");
+const Response = require("./utilities/Response");
+
+class Executor {
+  constructor(options) {
+    this.command = options.command;
+    this.input = {
+      type: options.inputType,
+      data: options.inputData,
+    };
+    this.output = {
+      type: options.outputType,
+      address: options.outputAddress,
+    };
+    this.response = new Response();
+    if (options.benchmark) this._initBenchmarker();
+    this._initPromises();
+  }
+
+  _initBenchmarker() {
+    const { command: commandName } = this;
+
+    this.benchmarker = new Benchmarker();
+    this.benchmarker.start(`${commandName} Command`);
+  }
+
+  _initPromises() {
+    this.promises = {};
+
+    this._addInputPromise();
+    this._addOutputPromise();
+  }
+
+  _addInputPromise() {
+    const {
+      input: { type, data },
+    } = this;
+
+    let jsonPromise;
+
+    switch (type) {
+      case "local":
+        if (!data) throw new Error("No Input Data Provided");
+        jsonPromise = checkAndLoad(data);
+        break;
+      case "stdin":
+        jsonPromise = loadStdin("utf-8");
+        break;
+      case "raw-json":
+        if (!data) throw new Error("No Input Data Provided");
+        jsonPromise = Promise.resolve(data);
+        break;
+      case "remote":
+        break;
+    }
+
+    this.promises["input"] = jsonPromise.then((json) => Promise.resolve(JSON.parse(json)));
+  }
+
+  _addOutputPromise() {
+    const {
+      output: { type, address },
+    } = this;
+
+    switch (type) {
+      case "local":
+        this.promises["output"] = ensureDirExistence(address);
+        break;
+      case "raw-json":
+        break;
+    }
+  }
+
+  async _renderTemplate(ctx, templateBuffer) {
+    const template = (await Handlebars).compile(templateBuffer.toString(), "utf-8");
+    return template(ctx);
+  }
+
+  async _createOutput(xml, { address, fileName }, ext) {
+    const dir = path.join(address, `${fileName}.${ext}`);
+    return ext === "svg" ? createSVG(xml, dir) : ext === "png" ? createPNG(xml, dir) : Promise.resolve();
+  }
+
+  async _renderAndCreateOutput(ctx, templatePromise, fileName, extensions) {
+    const {
+      promises,
+      output: { address },
+    } = this;
+    let xml;
+
+    return templatePromise
+      .then(async (templateBuffer) => {
+        xml = await this._renderTemplate(ctx, templateBuffer);
+        return promises.output;
+      })
+      .then(() => Promise.all(extensions.map((ext) => this._createOutput(xml, { address, fileName }, ext))));
+  }
+
+  async _renderAndCreateOutputs(contexts, templatePromises, outputFileName, extensions) {
+    return Promise.all(
+      templatePromises.map((templatePromise, index) => {
+        let fileName = `${outputFileName}${index !== 0 ? ".page" + (index + 1) : ""}`;
+        return this._renderAndCreateOutput(contexts[index], templatePromise, fileName, extensions);
+      })
+    );
+  }
+
+  getFinalPromise() {
+    const { promises, response } = this;
+
+    return Promise.all(Object.values(promises)).finally(() => response.showOutput());
+  }
+}
+
+module.exports = Executor;