x25 3.0.0 → 17.0.0

package/utility/validation/validate/bank-test.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _bank = require("./bank");
+
+var valid = true,
+    notValid = false;
+
+var wrong = ["", "1", "111", "RO", "RO14CECEGR", "RO14CECEGR0201RON0269170",
+// "RO14CECEGR0201RON0269171", -- it is good
+"RO14CECEGR0201RON0269172", "RO14CECEGR0201RON0269173", "RO14CECEGR0201RON0269174", "RO14CECEGR0201RON0269175", "RO14CECEGR0201RON0269176", "RO14CECEGR0201RON0269177", "RO14CECEGR0201RON0269178", "RO14CECEGR0201RON0269179"];
+
+wrong.map(function (iban) {
+  return describe("given the wrong IBAN " + iban, function () {
+    it("should not be valid", function () {
+      expect((0, _bank.isValidBankAccount)(iban)).toBe(notValid);
+    });
+  });
+});
+
+var good = ["RO74RZBR0000060001635742", "RO20RNCB0146009062650001", "RO51BRDE190SV09770651900", "RO19RZBR0000060014507080", "RO14CECEGR0201RON0269171", "RO89RNCB0146009060300001", "RO69RNCB0146009053910001", "RO32RNCB0148009659280001", "RO32RZBR0000060008527863", "RO35BRDE190SV17599841900", "RO35BRDE190SV17599841900", "RO79RZBR0000060013901108", "RO61RZBR0000060005489107", "RO41CECEGR0230RON0350215", "RO25RZBR0000060008522848", "RO35RNCB0146127215140001", "RO50RZBR0000060006249397", "RO74rzbr0000060001635742",
+
+// other countries
+"AD12 0001 2030 2003 5910 0100", "AE07 0331 2345 6789 0123 456", "AL47 2121 1009 0000 0002 3569 8741", "AT61 1904 3002 3457 3201", "AZ21 NABZ 0000 0000 1370 1000 1944", "BA39 1290 0794 0102 8494", "BE62 5100 0754 7061", "BG80 BNBG 9661 1020 3456 78", "BH67 BMAG 0000 1299 1234 56", "CH93 0076 2011 6238 5295 7", "CY17 0020 0128 0000 0012 0052 7600", "CZ65 0800 0000 1920 0014 5399", "DE89 3704 0044 0532 0130 00", "DK50 0040 0440 1162 43", "EE38 2200 2210 2014 5685", "ES80 2310 0001 1800 0001 2345", "FI21 1234 5600 0007 85", "FO97 5432 0388 8999 44", "FR14 2004 1010 0505 0001 3M02 606",
+
+/*
+ * "GB29 RBOS 6016 1331 9268 19",
+ * "GB99 RBOS 1234 5612 3456 78",
+ */
+"GE29 NB00 0000 0101 9049 17", "GI75 NWBK 0000 0000 7099 453", "GL56 0444 9876 5432 10", "GR16 0110 1250 0000 0001 2300 695", "HR12 1001 0051 8630 0016 0", "HU42 1177 3016 1111 1018 0000 0000", "IE29 AIBK 9311 5212 3456 78", "IL62 0108 0000 0009 9999 999", "IS14 0159 2600 7654 5510 7303 39", "IT40 S054 2811 1010 0000 0123 456",
+// "JO94 CBJO 0010 0000 0000 0131 0003 02",
+"KW81 CBKU 0000 0000 0000 1234 5601 01", "LB62 0999 0000 0001 0019 0122 9114", "LI21 0881 0000 2324 013A A", "LT12 1000 0111 0100 1000", "LU28 0019 4006 4475 0000", "LV80 BANK 0000 4351 9500 1", "MC93 2005 2222 1001 1223 3M44 555", "MD24 AG00 0225 1000 1310 4168", "ME25 5050 0001 2345 6789 51", "MK072 5012 0000 0589 84", "MT84 MALT 0110 0001 2345 MTLC AST0 01S", "MU17 BOMM 0101 1010 3030 0200 000M UR", "NL39 RABO 0300 0652 64", "NO93 8601 1117 947", "PK36 SCBL 0000 0011 2345 6702", "PL60 1020 1026 0000 0422 7020 1111", "PT50 0002 0123 1234 5678 9015 4",
+// "QA58 DOHB 0000 1234 5678 90AB CDEF G",
+"RO49 AAAA 1B31 0075 9384 0000", "RS35 2600 0560 1001 6113 79", "SA03 8000 0000 6080 1016 7519", "SE35 5000 0000 0549 1000 0003", "SI56 1910 0000 0123 438", "SK31 1200 0000 1987 4263 7541", "SM86 U032 2509 8000 0000 0270 100", "TN59 1000 6035 1835 9847 8831", "TR33 0006 1005 1978 6457 8413 26"];
+
+good.map(function (iban) {
+  return describe("given good IBAN " + iban, function () {
+    it("should be valid", function () {
+      expect((0, _bank.isValidBankAccount)(iban)).toBe(valid);
+    });
+  });
+});

package/utility/validation/validate/bank.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var isValidBankAccount = exports.isValidBankAccount = function isValidBankAccount(rawValue) {
+
+  // Remove spaces and to upper case
+  var checkPosition = 4,
+      iban = rawValue.replace(/ /g, "").toUpperCase(),
+      hasGoodCountryCode = function hasGoodCountryCode() {
+
+    if (iban.length <= 2) {
+      return false;
+    }
+
+    var 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;
+    }
+
+    var ibanregexp = new RegExp("^[A-Z]{2}\\d{2}" + bbanpattern + "$", "u");
+
+    // Invalid country specific format
+    return ibanregexp.test(iban);
+  },
+      hasGoodRest = function hasGoodRest() {
+    var getCheckDigits = function getCheckDigits() {
+
+      var getCheck = function getCheck() {
+        var first = String(iban.substring(checkPosition, iban.length)),
+            second = String(iban.substring(0, checkPosition));
+
+        return first + second;
+      },
+          ibancheck = getCheck();
+
+      var leadingZeroes = true,
+          value = "";
+
+      for (var index = 0; index < ibancheck.length; index += 1) {
+        var character = ibancheck.charAt(index);
+
+        if (character !== "0") {
+          leadingZeroes = false;
+        }
+
+        if (!leadingZeroes) {
+          value += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(character);
+        }
+      }
+
+      return value;
+    },
+        ibancheckdigits = getCheckDigits(),
+        nrToDevide = 97,
+        getOperator = function getOperator(_ref) {
+      var cRest = _ref.cRest,
+          cChar = _ref.cChar;
+
+      var rest = cRest === 0 ? "" : String(cRest);
+
+      return Number("" + rest + cChar);
+    };
+
+    var currentRest = 0;
+
+    for (var index = 0; index < ibancheckdigits.length; index += 1) {
+      var cChar = ibancheckdigits.charAt(index),
+          cOperator = getOperator({
+        cRest: currentRest,
+        cChar: 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/utility/validation/validate/cif-test.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _cif = require("./cif");
+
+var valid = true,
+    notValid = false;
+
+var 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(function (cif) {
+  return describe("given the wrong CIF " + cif, function () {
+    it("should not be valid", function () {
+      expect((0, _cif.isValidCIF)(cif)).toBe(notValid);
+    });
+  });
+});
+
+var 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(function (cif) {
+  return describe("given the good CIF " + cif, function () {
+    it("should be valid", function () {
+      expect((0, _cif.isValidCIF)(cif)).toBe(valid);
+    });
+  });
+});

package/utility/validation/validate/cif.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var isValidCIF = exports.isValidCIF = function isValidCIF(rawValue) {
+  var len = rawValue.length,
+      value = Number(rawValue),
+      ten = 10,
+      eleven = 11,
+      controlDigit1 = value % ten,
+      upperLimit = 10,
+      lowerLimit = 4,
+      getControlDigit2 = function getControlDigit2() {
+    var controlNumber = 753217532,
+        controlDigit2 = 0,
+        current = parseInt(value / ten, ten),
+        accumulator = 0;
+
+    while (current > 0) {
+      var 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/utility/validation/validate/cnp-test.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _cnp = require("./cnp");
+
+var valid = true,
+    notValid = false;
+
+var 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(function (cnp) {
+  return describe("given the wrong CNP " + cnp, function () {
+    it("should not be valid", function () {
+      expect((0, _cnp.isValidCNP)(cnp)).toBe(notValid);
+    });
+  });
+});
+
+var 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(function (cnp) {
+  return describe("given the good CNP " + cnp, function () {
+    it("should be valid", function () {
+      expect((0, _cnp.isValidCNP)(cnp)).toBe(valid);
+    });
+  });
+});

package/utility/validation/validate/cnp.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+/* eslint-disable no-magic-numbers, max-statements */
+
+var isValidCNP = exports.isValidCNP = function isValidCNP(rawValue) {
+
+  var decimalSystem = 10,
+      position = {
+    yearMillenium: 0,
+    sex: 0,
+
+    yearDecades: 1,
+    yearUnits: 2,
+
+    monthDecimals: 3,
+    monthUnits: 4,
+
+    dayDecimals: 5,
+    dayUnits: 6,
+
+    countyDecimals: 7,
+    countyUnits: 8,
+
+    numberHundreds: 9,
+    numberDecimals: 10,
+    numberUnits: 11,
+
+    controlDigit: 12
+  },
+      getCNP = function getCNP(raw) {
+
+    var hashResult = 0;
+
+    var hashTable = [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9],
+        normalLength = 13,
+        cnp = [];
+
+    var reduceHash = function reduceHash(rawHash) {
+      var nrOfDigits = 11,
+          reduced = parseInt(rawHash % nrOfDigits, decimalSystem);
+
+      if (reduced === 10) {
+        return 1;
+      }
+
+      return reduced;
+    };
+
+    if (raw.length !== normalLength) {
+      throw new Error("The length [actual:" + raw.length + "]\n        should be " + normalLength + " characters");
+    }
+
+    if (raw[0] === "0") {
+      throw new Error("The sex can not be 0");
+    }
+
+    var controlDigit = parseInt(raw.charAt(position.controlDigit), decimalSystem);
+
+    if (isNaN(controlDigit)) {
+      throw new Error("The control digit should be number");
+    }
+
+    for (var index = 0; index < 12; index += 1) {
+
+      var rawChar = raw.charAt(index),
+          parsedValue = parseInt(rawChar, decimalSystem),
+          correspondingHashNumber = hashTable[index];
+
+      if (isNaN(parsedValue)) {
+        throw new Error("The char at position " + index + " should be numeric");
+      }
+
+      cnp[index] = parsedValue;
+      hashResult += parsedValue * correspondingHashNumber;
+    }
+
+    if (controlDigit !== reduceHash(hashResult)) {
+      throw new Error("\n          The control digit is not good\n          [" + controlDigit + " === " + reduceHash(hashResult) + "]\n          ");
+    }
+
+    return cnp;
+  },
+      validate = function validate(cnp) {
+    var getCNPDigit = function getCNPDigit(currentPosition) {
+      return cnp[currentPosition];
+    },
+        isValidDate = function isValidDate() {
+      var getYear = function getYear() {
+        var computeYear = function computeYear() {
+          var yearMillenium = position.yearMillenium,
+              yearDecades = position.yearDecades,
+              yearUnits = position.yearUnits;
+
+
+          var year = getCNPDigit(yearDecades) * 10 + getCNPDigit(yearUnits);
+
+          switch (getCNPDigit(yearMillenium)) {
+            case 1:
+            case 2:
+              year += 1900;
+              break;
+            case 3:
+            case 4:
+              year += 1800;
+              break;
+            case 5:
+            case 6:
+              year += 2000;
+              break;
+
+            // 7,8,9
+            default:
+              {
+                year += 2000;
+
+                var today = new Date(),
+                    tempYear = parseInt(today.getYear(), 10) - 14;
+
+                if (year > tempYear) {
+                  year -= 100;
+                }
+              }
+              break;
+          }
+
+          return year;
+        },
+            year = computeYear();
+
+        if (year < 1800 || year > 2099) {
+          throw new Error("\n                Year [actual: " + String(year) + "] is not valid.\n                It should be between 1800 and 2099\n                ");
+        }
+
+        return year;
+      };
+
+      var year = getYear();
+
+      var monthDecimals = position.monthDecimals,
+          monthUnits = position.monthUnits,
+          dayDecimals = position.dayDecimals,
+          dayUnits = position.dayUnits,
+          month = getCNPDigit(monthDecimals) * 10 + getCNPDigit(monthUnits),
+          day = getCNPDigit(dayDecimals) * 10 + getCNPDigit(dayUnits),
+          jsMonth = month - 1,
+          date = new Date(year, jsMonth, day, 0, 0, 0, 0);
+
+
+      if (date.getFullYear() !== year || date.getMonth() !== jsMonth || date.getDate() !== day) {
+        throw new Error("\n                The given date\n                [\n                  year -> " + String(year) + "\n                  month -> " + String(month) + "\n                  day -> " + String(day) + "\n                ]");
+      }
+    },
+        isValidCounty = function isValidCounty() {
+      var countyDecimals = position.countyDecimals,
+          countyUnits = position.countyUnits,
+          lowerLimit = 1,
+          upperLimit = 52,
+          code = getCNPDigit(countyDecimals) * 10 + getCNPDigit(countyUnits);
+
+
+      if (code < lowerLimit || code > upperLimit) {
+        throw new Error("\n                  The country code is invalid [actual: " + code + "],\n                  should be between: " + lowerLimit + " <= " + code + " >= " + upperLimit + "\n                  ");
+      }
+    },
+        isValidNumber = function isValidNumber() {
+      var numberHundreds = position.numberHundreds,
+          numberDecimals = position.numberDecimals,
+          numberUnits = position.numberUnits,
+          number = getCNPDigit(numberHundreds) * 100 + getCNPDigit(numberDecimals) * 10 + getCNPDigit(numberUnits);
+
+
+      if (number === 0) {
+        throw new Error("The number should not be 0");
+      }
+    };
+
+    isValidDate();
+    isValidCounty();
+    isValidNumber();
+  };
+
+  try {
+    validate(getCNP(rawValue));
+
+    return true;
+  } catch (error) {
+    return false;
+  }
+};