@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/Eval/EvalFunctions.ts

@@ -0,0 +1,724 @@
+import * as moment from 'moment-business-days';
+import { EvalBase } from './EvalBase';
+import { NumberToLetter } from './NumbersToLetters';
+
+let holidays: string[] = [];
+
+/**
+ * Calculates list of french holidays for a given year
+ * @param year Year
+ */
+const frenchHolidays = (year: number): string[] => {
+  const JourAn = new Date(year, 0, 1);
+  const FeteTravail = new Date(year, 4, 1);
+  const Victoire1945 = new Date(year, 4, 8);
+  const FeteNationale = new Date(year, 6, 14);
+  const Assomption = new Date(year, 7, 15);
+  const Toussaint = new Date(year, 10, 1);
+  const Armistice = new Date(year, 10, 11);
+  const Noel = new Date(year, 11, 25);
+  // Aslace: const SaintEtienne = new Date(year, 11, 26);
+
+  const MF = Math.floor;
+  const G = year % 19;
+  const C = MF(year / 100);
+  const H = (C - MF(C / 4) - MF((8 * C + 13) / 25) + 19 * G + 15) % 30;
+  const I =
+    H - MF(H / 28) * (1 - MF(H / 28) * MF(29 / (H + 1)) * MF((21 - G) / 11));
+  const J = (year * 1 + MF(year / 4) + I + 2 - C + MF(C / 4)) % 7;
+  const L = I - J;
+  const MoisPaques = 3 + MF((L + 40) / 44);
+  const JourPaques = L + 28 - 31 * MF(MoisPaques / 4);
+  // Aslace: const VendrediSaint = new Date(year, MoisPaques - 1, JourPaques - 2);
+  const LundiPaques = new Date(year, MoisPaques - 1, JourPaques + 1);
+  const Ascension = new Date(year, MoisPaques - 1, JourPaques + 39);
+  const LundiPentecote = new Date(year, MoisPaques - 1, JourPaques + 50);
+
+  const formatDate = (date: Date): string => {
+    const dayIndex = date.getDate();
+    const monthIndex = date.getMonth();
+    const day = dayIndex < 10 ? `0${dayIndex.toString()}` : dayIndex;
+    const month =
+      monthIndex + 1 < 10 ? `0${(monthIndex + 1).toString()}` : monthIndex + 1;
+    return `${day}/${month}/${date.getFullYear()}`;
+  };
+
+  return [
+    JourAn,
+    LundiPaques,
+    FeteTravail,
+    Victoire1945,
+    LundiPentecote,
+    Ascension,
+    FeteNationale,
+    Assomption,
+    Toussaint,
+    Armistice,
+    Noel,
+  ].map((d) => formatDate(d));
+};
+
+/**
+ * Getting holidays from 2000 to 2050
+ */
+for (let i = 2000; i < 2050; i += 1) {
+  holidays = [...holidays, ...frenchHolidays(i)];
+}
+
+const dateStringRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/;
+const yearStringRegex = /^([0-9]{4})$/;
+const timestampRegex = /^([0-9]+)$/;
+const varTagRegex = /^\[var:([0-9]+)\]$/;
+
+export class EvalFunctions extends EvalBase {
+  holidays: string[] = holidays;
+
+  private parseVariableArgumentDate(varRef: string) {
+    let result: string | number = varRef;
+    if (varTagRegex.test(varRef)) result = this.getVariableValue(varRef, false);
+
+    return typeof result === 'number' ? result.toString() : result;
+  }
+
+  /**
+   * Affiche le jour de la date donné
+   * @param varRef Tag variable, date ou timestamp
+   */
+  afficherDate = (varRef: string): string => {
+    let result = '';
+    const date = this.parseVariableArgumentDate(varRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+    if (!dateStringRegex.test(date)) {
+      result = moment.unix(parseInt(date, 10)).utc().format('DD/MM/YYYY');
+    } else {
+      result = moment.utc(date, 'DD/MM/YYYY').utc().format('DD/MM/YYYY');
+    }
+
+    if (!dateStringRegex.test(result)) return '';
+
+    return `'${result}'`;
+  };
+
+  /**
+   * Afficher l'année de la date donné
+   * @param varRef Tag variable, date ou timestamp
+   */
+  afficherAnnee = (varRef: string): string => {
+    let result = '';
+    const date = this.parseVariableArgumentDate(varRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+    if (!dateStringRegex.test(date)) {
+      result = moment.unix(parseInt(date, 10)).utc().format('YYYY');
+    } else {
+      result = moment.utc(date, 'DD/MM/YYYY').utc().format('YYYY');
+    }
+
+    if (!yearStringRegex.test(result)) return '';
+
+    return `'${result}'`;
+  };
+
+  /**
+   * Convertie une date en timestamp
+   * @param varRef Tag variable, date ou timestamp
+   */
+  date = (varRef: string): number => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return 0;
+    }
+    return moment.utc(date, 'DD/MM/YYYY').unix();
+  };
+
+  /**
+   * Détermine si une date donnée est un jour ouvré ou pas,
+   * si c'est le cas elle retourne la date sinon elle
+   * retroune la date du jour ouvré suivant
+   * @param varRef Tag variable, date ou timestamp
+   */
+  jourOuvre = (varRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    let momentDate: moment.Moment;
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+    if (!dateStringRegex.test(date) && moment.unix(parseInt(date, 10))) {
+      momentDate = moment.unix(parseInt(date, 10)).utc();
+    } else {
+      momentDate = moment.utc(date, 'DD/MM/YYYY');
+    }
+
+    if (!momentDate.isBusinessDay()) {
+      momentDate = momentDate.nextBusinessDay();
+    }
+    return momentDate.utc().format('DD/MM/YYYY');
+  };
+
+  /**
+   * Détermine si une date donnée est un jour ouvrable ou pas,
+   * si c'est le cas elle retourne la date sinon elle
+   * retroune la date du jour ouvrable suivant
+   * @param varRef Tag variable, date ou timestamp
+   */
+  jourOuvrable = (varRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5, 6],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    let momentDate: moment.Moment;
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+    if (!dateStringRegex.test(date) && moment.unix(parseInt(date, 10))) {
+      momentDate = moment.unix(parseInt(date, 10)).utc();
+    } else {
+      momentDate = moment.utc(date, 'DD/MM/YYYY');
+    }
+
+    if (!momentDate.isBusinessDay()) {
+      momentDate = momentDate.nextBusinessDay();
+    }
+
+    return momentDate.utc().format('DD/MM/YYYY');
+  };
+
+  /**
+   * Ajouter un nombre donné de jours ouvrés à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param businessDaysRef Tag variable, Nombre de jours
+   */
+  ajouterJoursOuvres = (varRef: string, businessDaysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing business days if it's a variable
+    let businessDays = businessDaysRef;
+    if (varTagRegex.test(businessDays))
+      businessDays = this.parseVariableArgumentDate(businessDaysRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .businessAdd(parseInt(businessDays, 10))
+        .utc()
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .businessAdd(parseInt(businessDays, 10))
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Ajouter un nombre donné de jours ouvrables à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param businessDaysRef Tag variable, Nombre de jours
+   */
+  ajouterJoursOuvrables = (varRef: string, businessDaysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing business days if it's a variable
+    let businessDays = businessDaysRef;
+    if (varTagRegex.test(businessDays))
+      businessDays = this.parseVariableArgumentDate(businessDaysRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5, 6],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .businessAdd(parseInt(businessDays, 10))
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .businessAdd(parseInt(businessDays, 10))
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Ajouter un nombre donné de jours calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param daysRef Tag variable, Nombre de jours
+   */
+  ajouterJours = (varRef: string, daysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing days if it's a variable
+    let days = daysRef;
+    if (varTagRegex.test(days)) days = this.parseVariableArgumentDate(daysRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .add(days, 'd')
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .add(days, 'd')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Ajouter un nombre donné de mois calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param monthsRef Tag variable, Nombre de mois
+   */
+  ajouterMois = (varRef: string, monthsRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing months if it's a variable
+    let months = monthsRef;
+    if (varTagRegex.test(months))
+      months = this.parseVariableArgumentDate(monthsRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .add(months, 'M')
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .add(months, 'M')
+      .subtract(1, 'd')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Ajouter un nombre donné d'années calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param yearsRef Tag variable, Nombre d'années
+   */
+  ajouterAnnees = (varRef: string, yearsRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing years ref if it's a variable
+    let years = yearsRef;
+    if (varTagRegex.test(years))
+      years = this.parseVariableArgumentDate(yearsRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .add(years, 'y')
+        .utc()
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .add(years, 'y')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Enlève un nombre donné de jours ouvrables à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param businessDaysRef Tag variable, Nombre de jours
+   */
+  enleverJoursOuvrables = (varRef: string, businessDaysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing businessDaysRef if it's a variable
+    let businessDays = businessDaysRef;
+    if (varTagRegex.test(businessDays))
+      businessDays = this.parseVariableArgumentDate(businessDaysRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5, 6],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .businessSubtract(parseInt(businessDays, 10))
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .businessSubtract(parseInt(businessDays, 10))
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Enlève un nombre donné de jours ouvrés à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param businessDaysRef Tag variable, Nombre de jours
+   */
+  enleverJoursOuvres = (varRef: string, businessDaysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing businessDaysRef if it's a variable
+    let businessDays = businessDaysRef;
+    if (varTagRegex.test(businessDays))
+      businessDays = this.parseVariableArgumentDate(businessDaysRef);
+
+    // Defining business days
+    moment.updateLocale('en', {
+      workingWeekdays: [1, 2, 3, 4, 5],
+      holidays,
+      holidayFormat: 'DD/MM/YYYY',
+    });
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .businessSubtract(parseInt(businessDays, 10))
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .businessSubtract(parseInt(businessDays, 10))
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Enlève un nombre donné de jours calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param daysRef Tag variable, Nombre de jours
+   */
+  enleverJours = (varRef: string, daysRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing daysRef if it's a variable
+    let days = daysRef;
+    if (varTagRegex.test(days)) days = this.parseVariableArgumentDate(daysRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .subtract(days, 'd')
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .subtract(days, 'd')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Enlève un nombre donné de mois calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param monthsRef Tag variable, Nombre de mois
+   */
+  enleverMois = (varRef: string, monthsRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing monthsRef if it's a variable
+    let months = monthsRef;
+    if (varTagRegex.test(months))
+      months = this.parseVariableArgumentDate(monthsRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .subtract(months, 'M')
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .subtract(months, 'M')
+      .subtract(1, 'd')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Enlève un nombre donné d'années calendaires à une
+   * date donnée
+   * @param varRef Tag variable, date ou timestamp
+   * @param yearsRef Tag variable, Nombre d'années
+   */
+  enleverAnnees = (varRef: string, yearsRef: string): string => {
+    const date = this.parseVariableArgumentDate(varRef);
+
+    // Parsing yearsRef if it's a variable
+    let years = yearsRef;
+    if (varTagRegex.test(years))
+      years = this.parseVariableArgumentDate(yearsRef);
+
+    if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+      this.doNotEvaluate = true;
+      return '';
+    }
+
+    if (!dateStringRegex.test(date)) {
+      return moment
+        .unix(parseInt(date, 10))
+        .utc()
+        .subtract(years, 'y')
+        .format('DD/MM/YYYY');
+    }
+
+    return moment
+      .utc(date, 'DD/MM/YYYY')
+      .subtract(years, 'y')
+      .utc()
+      .format('DD/MM/YYYY');
+  };
+
+  /**
+   * Calcule le nombre de jours passés entre deux dates
+   * données
+   * @param varRefA Tag variable, date ou timestamp
+   * @param varRefB Tag variable, date ou timestamp
+   */
+  dureeJours = (varRefA: string, varRefB: string): number => {
+    const dateA = this.parseVariableArgumentDate(varRefA);
+    const dateB = this.parseVariableArgumentDate(varRefB);
+
+    if (
+      (!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+      (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))
+    ) {
+      this.doNotEvaluate = true;
+      return 0;
+    }
+
+    // Creating moment instance for date A
+    const dateAMoment = !dateStringRegex.test(dateA)
+      ? moment.unix(parseInt(dateA, 10)).utc()
+      : moment.utc(dateA, 'DD/MM/YYYY');
+
+    // Creating moment instance for date B
+    const dateBMoment = !dateStringRegex.test(dateB)
+      ? moment.unix(parseInt(dateB, 10)).utc()
+      : moment.utc(dateB, 'DD/MM/YYYY');
+
+    return dateBMoment.diff(dateAMoment, 'days');
+  };
+
+  /**
+   * Calcule le nombre de mois passés entre deux dates
+   * données
+   * @param varRefA Tag variable, date ou timestamp
+   * @param varRefB Tag variable, date ou timestamp
+   */
+  dureeMois = (varRefA: string, varRefB: string): number => {
+    const dateA = this.parseVariableArgumentDate(varRefA);
+    const dateB = this.parseVariableArgumentDate(varRefB);
+
+    if (
+      (!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+      (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))
+    ) {
+      this.doNotEvaluate = true;
+      return 0;
+    }
+
+    // Creating moment instance for date A
+    const dateAMoment = !dateStringRegex.test(dateA)
+      ? moment.unix(parseInt(dateA, 10)).utc()
+      : moment.utc(dateA, 'DD/MM/YYYY');
+
+    // Creating moment instance for date B
+    const dateBMoment = !dateStringRegex.test(dateB)
+      ? moment.unix(parseInt(dateB, 10)).utc()
+      : moment.utc(dateB, 'DD/MM/YYYY');
+
+    return dateBMoment.diff(dateAMoment, 'months', true);
+  };
+
+  /**
+   * Calcule le nombre d'années passées entre deux dates
+   * données
+   * @param varRefA Tag variable, date ou timestamp
+   * @param varRefB Tag variable, date ou timestamp
+   */
+  dureeAnnees = (varRefA: string, varRefB: string): number => {
+    const dateA = this.parseVariableArgumentDate(varRefA);
+    const dateB = this.parseVariableArgumentDate(varRefB);
+
+    if (
+      (!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+      (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))
+    ) {
+      this.doNotEvaluate = true;
+      return 0;
+    }
+
+    // Creating moment instance for date A
+    const dateAMoment = !dateStringRegex.test(dateA)
+      ? moment.unix(parseInt(dateA, 10)).utc()
+      : moment.utc(dateA, 'DD/MM/YYYY');
+
+    // Creating moment instance for date B
+    const dateBMoment = !dateStringRegex.test(dateB)
+      ? moment.unix(parseInt(dateB, 10)).utc()
+      : moment.utc(dateB, 'DD/MM/YYYY');
+
+    return dateBMoment.diff(dateAMoment, 'years', true);
+  };
+
+  /**
+   * Renvoie la date du jour
+   */
+  today = (): string =>
+    moment
+      .utc()
+      .set({
+        hour: 0,
+        minute: 0,
+        second: 0,
+        millisecond: 0,
+      })
+      .format('DD/MM/YYYY');
+
+  /**
+   * Retourne la somme de valeurs d'une variable
+   * multiple
+   */
+  somme = (varRef: string): number => {
+    if (!varTagRegex.test(varRef)) return 0;
+
+    // Getting variable value
+    const values = this.getVariableValue(varRef, true).map((value) => {
+      if (typeof value === 'number') return value;
+      if (!Number.isNaN(parseFloat(value))) return parseFloat(value);
+      return 0;
+    });
+
+    return values.reduce((p, c) => p + c, 0);
+  };
+
+  /**
+   * Convertis un chiffre en lettres
+   */
+  lettres = (varRef: string): string => {
+    if (!varTagRegex.test(varRef) && /[0-9]+/.test(varRef)) return '';
+
+    let result: string | number = varRef;
+    if (varTagRegex.test(varRef)) result = this.getVariableValue(varRef, false);
+
+    // Converting number
+    try {
+      result = NumberToLetter.French(result);
+    } catch (e) {
+      result = '';
+    }
+
+    return `D=${result}`;
+  };
+}