x25 3.0.0 → 17.0.0

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

@@ -1,176 +0,0 @@
-// @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

@@ -1,105 +0,0 @@
-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

@@ -1,44 +0,0 @@
-// @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

@@ -1,216 +0,0 @@
-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);
-        });
-    })
-));