gecko-dev/toolkit/modules/CreditCard.jsm
Victor Porof b503616295 Bug 1561435 - Format toolkit/modules/, a=automatic-formatting
# ignore-this-changeset

Differential Revision: https://phabricator.services.mozilla.com/D36056

--HG--
extra : source : 2616392f26053ee376b9126fbca696de5d4bb15b
2019-07-05 11:15:43 +02:00

354 lines
8.5 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
var EXPORTED_SYMBOLS = ["CreditCard"];
// The list of known and supported credit card network ids ("types")
// This list mirrors the networks from dom/payments/BasicCardPayment.cpp
// and is defined by https://www.w3.org/Payments/card-network-ids
const SUPPORTED_NETWORKS = Object.freeze([
"amex",
"cartebancaire",
"diners",
"discover",
"jcb",
"mastercard",
"mir",
"unionpay",
"visa",
]);
class CreditCard {
/**
* A CreditCard object represents a credit card, with
* number, name, expiration, network, and CCV.
* The number is the only required information when creating
* an object, all other members are optional. The number
* is validated during construction and will throw if invalid.
*
* @param {string} name, optional
* @param {string} number
* @param {string} expirationString, optional
* @param {string|number} expirationMonth, optional
* @param {string|number} expirationYear, optional
* @param {string} network, optional
* @param {string|number} ccv, optional
* @param {string} encryptedNumber, optional
* @throws if number is an invalid credit card number
*/
constructor({
name,
number,
expirationString,
expirationMonth,
expirationYear,
network,
ccv,
encryptedNumber,
}) {
this._name = name;
this._unmodifiedNumber = number;
this._encryptedNumber = encryptedNumber;
this._ccv = ccv;
this.number = number;
let { month, year } = CreditCard.normalizeExpiration({
expirationString,
expirationMonth,
expirationYear,
});
this._expirationMonth = month;
this._expirationYear = year;
this.network = network;
}
set name(value) {
this._name = value;
}
set expirationMonth(value) {
if (typeof value == "undefined") {
this._expirationMonth = undefined;
return;
}
this._expirationMonth = CreditCard.normalizeExpirationMonth(value);
}
get expirationMonth() {
return this._expirationMonth;
}
set expirationYear(value) {
if (typeof value == "undefined") {
this._expirationYear = undefined;
return;
}
this._expirationYear = CreditCard.normalizeExpirationYear(value);
}
get expirationYear() {
return this._expirationYear;
}
set expirationString(value) {
let { month, year } = CreditCard.parseExpirationString(value);
this.expirationMonth = month;
this.expirationYear = year;
}
set ccv(value) {
this._ccv = value;
}
get number() {
return this._number;
}
/**
* Sets the number member of a CreditCard object. If the number
* is not valid according to the Luhn algorithm then the member
* will get set to the empty string before throwing an exception.
*
* @param {string} value
* @throws if the value is an invalid credit card number
*/
set number(value) {
if (value) {
let normalizedNumber = value.replace(/[-\s]/g, "");
// Based on the information on wiki[1], the shortest valid length should be
// 12 digits (Maestro).
// [1] https://en.wikipedia.org/wiki/Payment_card_number
normalizedNumber = normalizedNumber.match(/^\d{12,}$/)
? normalizedNumber
: "";
this._number = normalizedNumber;
} else {
this._number = "";
}
if (value && !this.isValidNumber()) {
this._number = "";
throw new Error("Invalid credit card number");
}
}
get network() {
return this._network;
}
set network(value) {
this._network = value || undefined;
}
// Implements the Luhn checksum algorithm as described at
// http://wikipedia.org/wiki/Luhn_algorithm
// Number digit lengths vary with network, but should fall within 12-19 range. [2]
// More details at https://en.wikipedia.org/wiki/Payment_card_number
isValidNumber() {
if (!this._number) {
return false;
}
// Remove dashes and whitespace
let number = this._number.replace(/[\-\s]/g, "");
let len = number.length;
if (len < 12 || len > 19) {
return false;
}
if (!/^\d+$/.test(number)) {
return false;
}
let total = 0;
for (let i = 0; i < len; i++) {
let ch = parseInt(number[len - i - 1], 10);
if (i % 2 == 1) {
// Double it, add digits together if > 10
ch *= 2;
if (ch > 9) {
ch -= 9;
}
}
total += ch;
}
return total % 10 == 0;
}
/**
* Returns true if the card number is valid and the
* expiration date has not passed. Otherwise false.
*
* @returns {boolean}
*/
isValid() {
if (!this.isValidNumber()) {
return false;
}
let currentDate = new Date();
let currentYear = currentDate.getFullYear();
if (this._expirationYear > currentYear) {
return true;
}
// getMonth is 0-based, so add 1 because credit cards are 1-based
let currentMonth = currentDate.getMonth() + 1;
return (
this._expirationYear == currentYear &&
this._expirationMonth >= currentMonth
);
}
get maskedNumber() {
return CreditCard.getMaskedNumber(this._number);
}
get longMaskedNumber() {
return CreditCard.getLongMaskedNumber(this._number);
}
/**
* Get credit card display label. It should display masked numbers and the
* cardholder's name, separated by a comma.
*/
static getLabel({ number, name }) {
let parts = [];
if (number) {
parts.push(CreditCard.getMaskedNumber(number));
}
if (name) {
parts.push(name);
}
return parts.join(", ");
}
static normalizeExpirationMonth(month) {
month = parseInt(month, 10);
if (isNaN(month) || month < 1 || month > 12) {
return undefined;
}
return month;
}
static normalizeExpirationYear(year) {
year = parseInt(year, 10);
if (isNaN(year) || year < 0) {
return undefined;
}
if (year < 100) {
year += 2000;
}
return year;
}
static parseExpirationString(expirationString) {
let rules = [
{
regex: "(\\d{4})[-/](\\d{1,2})",
yearIndex: 1,
monthIndex: 2,
},
{
regex: "(\\d{1,2})[-/](\\d{4})",
yearIndex: 2,
monthIndex: 1,
},
{
regex: "(\\d{1,2})[-/](\\d{1,2})",
},
{
regex: "(\\d{2})(\\d{2})",
},
];
for (let rule of rules) {
let result = new RegExp(`(?:^|\\D)${rule.regex}(?!\\d)`).exec(
expirationString
);
if (!result) {
continue;
}
let year, month;
if (!rule.yearIndex || !rule.monthIndex) {
month = parseInt(result[1], 10);
if (month > 12) {
year = parseInt(result[1], 10);
month = parseInt(result[2], 10);
} else {
year = parseInt(result[2], 10);
}
} else {
year = parseInt(result[rule.yearIndex], 10);
month = parseInt(result[rule.monthIndex], 10);
}
if (month < 1 || month > 12 || (year >= 100 && year < 2000)) {
continue;
}
return { month, year };
}
return { month: undefined, year: undefined };
}
static normalizeExpiration({
expirationString,
expirationMonth,
expirationYear,
}) {
// Only prefer the string version if missing one or both parsed formats.
let parsedExpiration = {};
if (expirationString && (!expirationMonth || !expirationYear)) {
parsedExpiration = CreditCard.parseExpirationString(expirationString);
}
return {
month: CreditCard.normalizeExpirationMonth(
parsedExpiration.month || expirationMonth
),
year: CreditCard.normalizeExpirationYear(
parsedExpiration.year || expirationYear
),
};
}
static formatMaskedNumber(maskedNumber) {
return {
affix: "****",
label: maskedNumber.replace(/^\**/, ""),
};
}
static getMaskedNumber(number) {
return "*".repeat(4) + " " + number.substr(-4);
}
static getLongMaskedNumber(number) {
return "*".repeat(number.length - 4) + number.substr(-4);
}
/*
* Validates the number according to the Luhn algorithm. This
* method does not throw an exception if the number is invalid.
*/
static isValidNumber(number) {
try {
new CreditCard({ number });
} catch (ex) {
return false;
}
return true;
}
static isValidNetwork(network) {
return SUPPORTED_NETWORKS.includes(network);
}
}
CreditCard.SUPPORTED_NETWORKS = SUPPORTED_NETWORKS;