x25 2.9.2 → 3.0.0

package/src/utility/validation/validate/bank.js

@@ -0,0 +1,176 @@
+// @flow
+
+export const isValidBankAccount = (rawValue : string) : boolean => {
+
+  // Remove spaces and to upper case
+  const checkPosition = 4,
+    iban = rawValue.replace(/ /gu,
+      "").toUpperCase(),
+    hasGoodCountryCode = () : boolean => {
+
+      if (iban.length <= 2) {
+        return false;
+      }
+
+      const countrycode = iban.substring(0,
+          2),
+        bbancountrypatterns = {
+          "AD" : "\\d{8}[\\dA-Z]{12}",
+          "AE" : "\\d{3}\\d{16}",
+          "AL" : "\\d{8}[\\dA-Z]{16}",
+          "AT" : "\\d{16}",
+          "AZ" : "[\\dA-Z]{4}\\d{20}",
+          "BA" : "\\d{16}",
+          "BE" : "\\d{12}",
+          "BG" : "[A-Z]{4}\\d{6}[\\dA-Z]{8}",
+          "BH" : "[A-Z]{4}[\\dA-Z]{14}",
+          "BR" : "\\d{23}[A-Z][\\dA-Z]",
+          "CH" : "\\d{5}[\\dA-Z]{12}",
+          "CR" : "\\d{17}",
+          "CY" : "\\d{8}[\\dA-Z]{16}",
+          "CZ" : "\\d{20}",
+          "DE" : "\\d{18}",
+          "DK" : "\\d{14}",
+          "DO" : "[A-Z]{4}\\d{20}",
+          "EE" : "\\d{16}",
+          "ES" : "\\d{20}",
+          "FI" : "\\d{14}",
+          "FO" : "\\d{14}",
+          "FR" : "\\d{10}[\\dA-Z]{11}\\d{2}",
+          "GB" : "[A-Z]{4}\\d{14}",
+          "GE" : "[\\dA-Z]{2}\\d{16}",
+          "GI" : "[A-Z]{4}[\\dA-Z]{15}",
+          "GL" : "\\d{14}",
+          "GR" : "\\d{7}[\\dA-Z]{16}",
+          "GT" : "[\\dA-Z]{4}[\\dA-Z]{20}",
+          "HR" : "\\d{17}",
+          "HU" : "\\d{24}",
+          "IE" : "[\\dA-Z]{4}\\d{14}",
+          "IL" : "\\d{19}",
+          "IS" : "\\d{22}",
+          "IT" : "[A-Z]\\d{10}[\\dA-Z]{12}",
+          "KW" : "[A-Z]{4}[\\dA-Z]{22}",
+          "KZ" : "\\d{3}[\\dA-Z]{13}",
+          "LB" : "\\d{4}[\\dA-Z]{20}",
+          "LI" : "\\d{5}[\\dA-Z]{12}",
+          "LT" : "\\d{16}",
+          "LU" : "\\d{3}[\\dA-Z]{13}",
+          "LV" : "[A-Z]{4}[\\dA-Z]{13}",
+          "MC" : "\\d{10}[\\dA-Z]{11}\\d{2}",
+          "MD" : "[\\dA-Z]{2}\\d{18}",
+          "ME" : "\\d{18}",
+          "MK" : "\\d{3}[\\dA-Z]{10}\\d{2}",
+          "MR" : "\\d{23}",
+          "MT" : "[A-Z]{4}\\d{5}[\\dA-Z]{18}",
+          "MU" : "[A-Z]{4}\\d{19}[A-Z]{3}",
+          "NL" : "[A-Z]{4}\\d{10}",
+          "NO" : "\\d{11}",
+          "PK" : "[\\dA-Z]{4}\\d{16}",
+          "PL" : "\\d{24}",
+          "PS" : "[\\dA-Z]{4}\\d{21}",
+          "PT" : "\\d{21}",
+          "RO" : "[A-Z]{4}[\\dA-Z]{16}",
+          "RS" : "\\d{18}",
+          "SA" : "\\d{2}[\\dA-Z]{18}",
+          "SE" : "\\d{20}",
+          "SI" : "\\d{15}",
+          "SK" : "\\d{20}",
+          "SM" : "[A-Z]\\d{10}[\\dA-Z]{12}",
+          "TN" : "\\d{20}",
+          "TR" : "\\d{5}[\\dA-Z]{17}",
+          "VG" : "[\\dA-Z]{4}\\d{16}",
+        },
+        bbanpattern = bbancountrypatterns[countrycode];
+
+      /*
+       * As new countries will start using IBAN in the
+       * future, we only check if the countrycode is known.
+       * This prevents false negatives, while almost all
+       * false positives introduced by this, will be caught
+       * by the checksum validation below anyway.
+       * Strict checking should return FALSE for unknown
+       * countries.
+       */
+      if (typeof bbanpattern === "undefined") {
+        return false;
+      }
+
+      const ibanregexp = new RegExp(`^[A-Z]{2}\\d{2}${bbanpattern}$`,
+        "u");
+
+      // Invalid country specific format
+      return ibanregexp.test(iban);
+    },
+    hasGoodRest = () : boolean => {
+      const getCheckDigits = () => {
+
+          const getCheck = () : string => {
+              const first = String(iban.substring(checkPosition,
+                  iban.length)),
+                second = String(iban.substring(0,
+                  checkPosition));
+
+              return first + second;
+            },
+            ibancheck = getCheck();
+
+
+          let leadingZeroes = true,
+            value = "";
+
+          for (let index = 0; index < ibancheck.length; index += 1) {
+            const character = ibancheck.charAt(index);
+
+            if (character !== "0") {
+              leadingZeroes = false;
+            }
+
+            if (!leadingZeroes) {
+              value += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(character);
+            }
+          }
+
+          return value;
+        },
+        ibancheckdigits = getCheckDigits(),
+        nrToDevide = 97,
+        getOperator = ({ cRest, cChar } : { cRest: number, cChar : string}) => {
+          const rest = (cRest === 0) ? "" : String(cRest);
+
+          return Number(`${rest}${cChar}`);
+        };
+
+      let currentRest = 0;
+
+      for (let index = 0; index < ibancheckdigits.length; index += 1) {
+        const cChar = ibancheckdigits.charAt(index),
+          cOperator = getOperator({
+            cRest: currentRest,
+            cChar,
+          });
+
+        if (cOperator === "" || isNaN(cOperator)) {
+          return false;
+        }
+
+        currentRest = cOperator % nrToDevide;
+      }
+
+      return currentRest === 1;
+    };
+
+  // 1. Check the country code and find the country specific format
+
+  if (!hasGoodCountryCode()) {
+
+    return false;
+  }
+
+  // 2. Check the checksum{
+  if (!hasGoodRest()) {
+
+    return false;
+  }
+
+  return true;
+};

package/src/utility/validation/validate/cif-test.js

@@ -0,0 +1,105 @@
+import { isValidCIF } from "./cif";
+
+const valid = true,
+  notValid = false;
+
+const wrong = [
+
+  "adsasd",
+
+  // too short < 6
+  "00",
+
+  // too long > 10
+  "00000000001",
+
+  // contains other things
+  "aaaaaaaaaa",
+
+  "1450123",
+
+  "13880060",
+  "13880061",
+  "13880062",
+  // "51584214", // <-- this is good
+  "13880064",
+  "13880065",
+  "13880066",
+  "13880067",
+  "13880068",
+  "13880069",
+];
+
+wrong.map((cif) => (
+  describe(`given the wrong CIF ${cif}`,
+    () => {
+      it("should not be valid",
+        () => {
+          expect(isValidCIF(cif)).toBe(notValid);
+        });
+    })
+));
+
+const good = [
+
+  "4446651",
+  "3678190",
+  "4352719",
+  "3627676",
+  "7525881",
+  "4347666",
+  "3372840",
+  "5217524",
+  "4317819",
+  "4192600",
+  "4266928",
+  "4233815",
+  "4288004",
+  "4300787",
+  "4300574",
+  "4332134",
+  "3519380",
+  "4375178",
+  "4297924",
+  "3127336",
+  "11078781",
+  "3897033",
+  "4541874",
+  "4605609",
+  "4245518",
+  "4358002",
+  "4230436",
+  "4266898",
+  "2613486",
+  "4318113",
+  "2844154",
+  "4222310",
+  "2540830",
+  "4287378",
+  "3897343",
+  "4540062",
+  "5397247",
+  "4556140",
+  "4231881",
+  "4244393",
+  "4280213",
+  "4323179",
+  "4567890",
+  "6412248",
+  "4269304",
+  "4321658",
+  "4494721",
+  "4404613",
+
+  "51584214",
+];
+
+good.map((cif) => (
+  describe(`given the good CIF ${cif}`,
+    () => {
+      it("should be valid",
+        () => {
+          expect(isValidCIF(cif)).toBe(valid);
+        });
+    })
+));

package/src/utility/validation/validate/cif.js

@@ -0,0 +1,44 @@
+// @flow
+
+export const isValidCIF = (rawValue : string) : boolean => {
+  const len = rawValue.length,
+    value = Number(rawValue),
+    ten = 10,
+    eleven = 11,
+    controlDigit1 = value % ten,
+    upperLimit = 10,
+    lowerLimit = 4,
+    getControlDigit2 = () : number => {
+      let controlNumber = 753217532,
+        controlDigit2 = 0,
+        current = parseInt(value / ten,
+          ten),
+        accumulator = 0;
+
+      while (current > 0) {
+        const controlDigit = (controlNumber % ten);
+
+        accumulator += (current % ten) * controlDigit;
+
+        current = parseInt(current / ten,
+          ten);
+        controlNumber = parseInt(controlNumber / ten,
+          ten);
+      }
+
+      controlDigit2 = accumulator * ten % eleven;
+
+      if (controlDigit2 === ten) {
+        controlDigit2 = 0;
+      }
+
+      return controlDigit2;
+    };
+
+  if (isNaN(value) || len > upperLimit || len < lowerLimit) {
+    // console.warn("The length must be between 6 and 10 digits");
+    return false;
+  }
+
+  return controlDigit1 === getControlDigit2();
+};

package/src/utility/validation/validate/cnp-test.js

@@ -0,0 +1,216 @@
+import { isValidCNP } from "./cnp";
+
+const valid = true,
+  notValid = false;
+
+const wrongCNPs = [
+
+  // less than 13 characters
+  "000",
+
+  // more than 13 characters
+  "00000000000000",
+
+  // not all digits
+  "             ",
+  "a234567890123",
+  "1x34567890123",
+  "12y4567890123",
+  "123(567890123",
+  "1234*67890123",
+  "12345-7890123",
+  "123456+890123",
+  "1234567`90123",
+  "12345678!0123",
+  "123456789@123",
+  "12345678901&3",
+  "123456789012=",
+
+  // Digit 1 not 0
+  "0000000000000",
+
+  /*
+   * Wrong month
+   * Too small
+   */
+  "1230000000000",
+  // Too big
+  "1231300000000",
+  "1234500000000",
+  "1239900000000",
+
+  // Wrong date
+  "1000100000000",
+  "1000100000000",
+  "1231200000000",
+  "3431250000000",
+  "8430100000000",
+  "6431132000000",
+  "5160230000000",
+
+  /*
+   * Wrong County
+   * 0
+   */
+  "1930426000000",
+
+  // Too big
+  "1930426530000",
+  "1930426990000",
+
+  // Number - allowed only 001 --> 999
+  "1930426010000",
+
+  // Check controll all posible conbinations
+  "1930426450030",
+  "1930426450031",
+  "1930426450032",
+  "1930426450033",
+  "1930426450034",
+  // "1930426450035", // --> this is good
+  "1930426450036",
+  "1930426450037",
+  "1930426450038",
+  "1930426450039",
+
+  "1730513635451",
+];
+
+wrongCNPs.map((cnp) => (
+  describe(`given the wrong CNP ${cnp}`,
+    () => {
+      it("should not be valid",
+        () => {
+          expect(isValidCNP(cnp)).toBe(notValid);
+        });
+    })
+));
+
+const goodCNPs = [
+
+  "1601224522490",
+  // list from http://cnp-orange-young.blogspot.ro/
+  "1851021345131",
+  "1920617149053",
+  "1870505168646",
+  "1870619152998",
+  "1921204325416",
+  "1931011351347",
+  "1860601214764",
+  "1930114152084",
+  "1930729213031",
+  "1931110257176",
+  "1900806182888",
+  "1920201181713",
+  "1911202393786",
+  "1860114313017",
+  "1900129321797",
+  "1910319357474",
+  "1881110136241",
+  "1910313389932",
+  "1930324128027",
+  "1860713267955",
+  "1920110059921",
+  "1920323137670",
+  "1910524257786",
+  "1910219353588",
+  "1921113049026",
+  "1910510171180",
+  "1921219189118",
+  "1930614296921",
+  "1930408137659",
+  "1860525171600",
+  "1871008113318",
+  "1900809164551",
+  "1870418305339",
+  "1920622093590",
+  "1860228422041",
+  "1881024199710",
+  "1901119289825",
+  "1870623151354",
+  "1880717053385",
+  "1860331281263",
+  "1921127239892",
+  "1860726084246",
+  "1891209392109",
+  "1870610429939",
+  "1891101155151",
+  "1900515188610",
+  "1900817347850",
+  "1850603113108",
+  "1920219031621",
+  "1880716319353",
+  "1851123072213",
+  "1890503074079",
+  "1920929194685",
+  "1930604396824",
+  "1920721211943",
+  "1911125017410",
+  "1920328331453",
+  "1891012055602",
+  "1850412422567",
+  "1900830012030",
+  "1901109372453",
+  "1901119063169",
+  "1910801238953",
+  "1850126336642",
+  "1870619334654",
+  "1880930146221",
+  "1861019351849",
+  "1930502103999",
+  "1930425361934",
+  "1871108269030",
+  "1860622273209",
+  "1920723362204",
+  "1880919016077",
+  "1860627124609",
+  "1930210191367",
+  "1920306379899",
+  "1860621221169",
+  "1890514289320",
+  "1920421395061",
+  "1930426272907",
+  "1861224076805",
+  "1850204207530",
+  "1930726241832",
+  "1920229184105",
+  "1910318245177",
+  "1871225154992",
+  "1890425099446",
+
+  "1920918187490",
+  "1911017023863",
+  "1900514401426",
+  "1860117328230",
+  "1861019339785",
+  "1870119334824",
+  "1880316079025",
+  "1910216018631",
+  "1920425405811",
+  "1920904145205",
+  "1881201016278",
+  "1920731125084",
+  "1901003395568",
+
+  "1590512521591",
+  "1660418230010",
+  "1891119450065",
+  "1920310430037",
+  "1920504521696",
+  "1930426450035",
+  "2770926521590",
+  "2830111410090",
+  "2880330521699",
+  "2900117521690",
+  "2910825522143",
+];
+
+goodCNPs.map((cnp) => (
+  describe(`given the good CNP ${cnp}`,
+    () => {
+      it("should be valid",
+        () => {
+          expect(isValidCNP(cnp)).toBe(valid);
+        });
+    })
+));