@tomerh2001/israeli-bank-scrapers 6.3.11

package/lib/scrapers/base-isracard-amex.js

@@ -0,0 +1,324 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _moment = _interopRequireDefault(require("moment"));
+var _constants = require("../constants");
+var _definitions = require("../definitions");
+var _dates = _interopRequireDefault(require("../helpers/dates"));
+var _debug = require("../helpers/debug");
+var _fetch = require("../helpers/fetch");
+var _transactions = require("../helpers/transactions");
+var _waiting = require("../helpers/waiting");
+var _transactions2 = require("../transactions");
+var _baseScraperWithBrowser = require("./base-scraper-with-browser");
+var _errors = require("./errors");
+var _browser = require("../helpers/browser");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const RATE_LIMIT = {
+  SLEEP_BETWEEN: 1000,
+  TRANSACTIONS_BATCH_SIZE: 10
+};
+const COUNTRY_CODE = '212';
+const ID_TYPE = '1';
+const INSTALLMENTS_KEYWORD = 'תשלום';
+const DATE_FORMAT = 'DD/MM/YYYY';
+const debug = (0, _debug.getDebug)('base-isracard-amex');
+function getAccountsUrl(servicesUrl, monthMoment) {
+  const billingDate = monthMoment.format('YYYY-MM-DD');
+  const url = new URL(servicesUrl);
+  url.searchParams.set('reqName', 'DashboardMonth');
+  url.searchParams.set('actionCode', '0');
+  url.searchParams.set('billingDate', billingDate);
+  url.searchParams.set('format', 'Json');
+  return url.toString();
+}
+async function fetchAccounts(page, servicesUrl, monthMoment) {
+  const dataUrl = getAccountsUrl(servicesUrl, monthMoment);
+  debug(`fetching accounts from ${dataUrl}`);
+  const dataResult = await (0, _fetch.fetchGetWithinPage)(page, dataUrl);
+  if (dataResult && _lodash.default.get(dataResult, 'Header.Status') === '1' && dataResult.DashboardMonthBean) {
+    const {
+      cardsCharges
+    } = dataResult.DashboardMonthBean;
+    if (cardsCharges) {
+      return cardsCharges.map(cardCharge => {
+        return {
+          index: parseInt(cardCharge.cardIndex, 10),
+          accountNumber: cardCharge.cardNumber,
+          processedDate: (0, _moment.default)(cardCharge.billingDate, DATE_FORMAT).toISOString()
+        };
+      });
+    }
+  }
+  return [];
+}
+function getTransactionsUrl(servicesUrl, monthMoment) {
+  const month = monthMoment.month() + 1;
+  const year = monthMoment.year();
+  const monthStr = month < 10 ? `0${month}` : month.toString();
+  const url = new URL(servicesUrl);
+  url.searchParams.set('reqName', 'CardsTransactionsList');
+  url.searchParams.set('month', monthStr);
+  url.searchParams.set('year', `${year}`);
+  url.searchParams.set('requiredDate', 'N');
+  return url.toString();
+}
+function convertCurrency(currencyStr) {
+  if (currencyStr === _constants.SHEKEL_CURRENCY_KEYWORD || currencyStr === _constants.ALT_SHEKEL_CURRENCY) {
+    return _constants.SHEKEL_CURRENCY;
+  }
+  return currencyStr;
+}
+function getInstallmentsInfo(txn) {
+  if (!txn.moreInfo || !txn.moreInfo.includes(INSTALLMENTS_KEYWORD)) {
+    return undefined;
+  }
+  const matches = txn.moreInfo.match(/\d+/g);
+  if (!matches || matches.length < 2) {
+    return undefined;
+  }
+  return {
+    number: parseInt(matches[0], 10),
+    total: parseInt(matches[1], 10)
+  };
+}
+function getTransactionType(txn) {
+  return getInstallmentsInfo(txn) ? _transactions2.TransactionTypes.Installments : _transactions2.TransactionTypes.Normal;
+}
+function convertTransactions(txns, processedDate) {
+  const filteredTxns = txns.filter(txn => txn.dealSumType !== '1' && txn.voucherNumberRatz !== '000000000' && txn.voucherNumberRatzOutbound !== '000000000');
+  return filteredTxns.map(txn => {
+    const isOutbound = txn.dealSumOutbound;
+    const txnDateStr = isOutbound ? txn.fullPurchaseDateOutbound : txn.fullPurchaseDate;
+    const txnMoment = (0, _moment.default)(txnDateStr, DATE_FORMAT);
+    const currentProcessedDate = txn.fullPaymentDate ? (0, _moment.default)(txn.fullPaymentDate, DATE_FORMAT).toISOString() : processedDate;
+    const result = {
+      type: getTransactionType(txn),
+      identifier: parseInt(isOutbound ? txn.voucherNumberRatzOutbound : txn.voucherNumberRatz, 10),
+      date: txnMoment.toISOString(),
+      processedDate: currentProcessedDate,
+      originalAmount: isOutbound ? -txn.dealSumOutbound : -txn.dealSum,
+      originalCurrency: convertCurrency(txn.currentPaymentCurrency ?? txn.currencyId),
+      chargedAmount: isOutbound ? -txn.paymentSumOutbound : -txn.paymentSum,
+      chargedCurrency: convertCurrency(txn.currencyId),
+      description: isOutbound ? txn.fullSupplierNameOutbound : txn.fullSupplierNameHeb,
+      memo: txn.moreInfo || '',
+      installments: getInstallmentsInfo(txn) || undefined,
+      status: _transactions2.TransactionStatuses.Completed
+    };
+    return result;
+  });
+}
+async function fetchTransactions(page, options, companyServiceOptions, startMoment, monthMoment) {
+  const accounts = await fetchAccounts(page, companyServiceOptions.servicesUrl, monthMoment);
+  const dataUrl = getTransactionsUrl(companyServiceOptions.servicesUrl, monthMoment);
+  await (0, _waiting.sleep)(RATE_LIMIT.SLEEP_BETWEEN);
+  debug(`fetching transactions from ${dataUrl} for month ${monthMoment.format('YYYY-MM')}`);
+  const dataResult = await (0, _fetch.fetchGetWithinPage)(page, dataUrl);
+  if (dataResult && _lodash.default.get(dataResult, 'Header.Status') === '1' && dataResult.CardsTransactionsListBean) {
+    const accountTxns = {};
+    accounts.forEach(account => {
+      const txnGroups = _lodash.default.get(dataResult, `CardsTransactionsListBean.Index${account.index}.CurrentCardTransactions`);
+      if (txnGroups) {
+        let allTxns = [];
+        txnGroups.forEach(txnGroup => {
+          if (txnGroup.txnIsrael) {
+            const txns = convertTransactions(txnGroup.txnIsrael, account.processedDate);
+            allTxns.push(...txns);
+          }
+          if (txnGroup.txnAbroad) {
+            const txns = convertTransactions(txnGroup.txnAbroad, account.processedDate);
+            allTxns.push(...txns);
+          }
+        });
+        if (!options.combineInstallments) {
+          allTxns = (0, _transactions.fixInstallments)(allTxns);
+        }
+        if (options.outputData?.enableTransactionsFilterByDate ?? true) {
+          allTxns = (0, _transactions.filterOldTransactions)(allTxns, startMoment, options.combineInstallments || false);
+        }
+        accountTxns[account.accountNumber] = {
+          accountNumber: account.accountNumber,
+          index: account.index,
+          txns: allTxns
+        };
+      }
+    });
+    return accountTxns;
+  }
+  return {};
+}
+async function getExtraScrapTransaction(page, options, month, accountIndex, transaction) {
+  const url = new URL(options.servicesUrl);
+  url.searchParams.set('reqName', 'PirteyIska_204');
+  url.searchParams.set('CardIndex', accountIndex.toString());
+  url.searchParams.set('shovarRatz', transaction.identifier.toString());
+  url.searchParams.set('moedChiuv', month.format('MMYYYY'));
+  debug(`fetching extra scrap for transaction ${transaction.identifier} for month ${month.format('YYYY-MM')}`);
+  const data = await (0, _fetch.fetchGetWithinPage)(page, url.toString());
+  if (!data) {
+    return transaction;
+  }
+  const rawCategory = _lodash.default.get(data, 'PirteyIska_204Bean.sector') ?? '';
+  return {
+    ...transaction,
+    category: rawCategory.trim()
+  };
+}
+async function getExtraScrapAccount(page, options, accountMap, month) {
+  const accounts = [];
+  for (const account of Object.values(accountMap)) {
+    debug(`get extra scrap for ${account.accountNumber} with ${account.txns.length} transactions`, month.format('YYYY-MM'));
+    const txns = [];
+    for (const txnsChunk of _lodash.default.chunk(account.txns, RATE_LIMIT.TRANSACTIONS_BATCH_SIZE)) {
+      debug(`processing chunk of ${txnsChunk.length} transactions for account ${account.accountNumber}`);
+      const updatedTxns = await Promise.all(txnsChunk.map(t => getExtraScrapTransaction(page, options, month, account.index, t)));
+      await (0, _waiting.sleep)(RATE_LIMIT.SLEEP_BETWEEN);
+      txns.push(...updatedTxns);
+    }
+    accounts.push({
+      ...account,
+      txns
+    });
+  }
+  return accounts.reduce((m, x) => ({
+    ...m,
+    [x.accountNumber]: x
+  }), {});
+}
+async function getAdditionalTransactionInformation(scraperOptions, accountsWithIndex, page, options, allMonths) {
+  if (!scraperOptions.additionalTransactionInformation || scraperOptions.optInFeatures?.includes('isracard-amex:skipAdditionalTransactionInformation')) {
+    return accountsWithIndex;
+  }
+  return (0, _waiting.runSerial)(accountsWithIndex.map((a, i) => () => getExtraScrapAccount(page, options, a, allMonths[i])));
+}
+async function fetchAllTransactions(page, options, companyServiceOptions, startMoment) {
+  const futureMonthsToScrape = options.futureMonthsToScrape ?? 1;
+  const allMonths = (0, _dates.default)(startMoment, futureMonthsToScrape);
+  const results = await (0, _waiting.runSerial)(allMonths.map(monthMoment => () => {
+    return fetchTransactions(page, options, companyServiceOptions, startMoment, monthMoment);
+  }));
+  const finalResult = await getAdditionalTransactionInformation(options, results, page, companyServiceOptions, allMonths);
+  const combinedTxns = {};
+  finalResult.forEach(result => {
+    Object.keys(result).forEach(accountNumber => {
+      let txnsForAccount = combinedTxns[accountNumber];
+      if (!txnsForAccount) {
+        txnsForAccount = [];
+        combinedTxns[accountNumber] = txnsForAccount;
+      }
+      const toBeAddedTxns = result[accountNumber].txns;
+      combinedTxns[accountNumber].push(...toBeAddedTxns);
+    });
+  });
+  const accounts = Object.keys(combinedTxns).map(accountNumber => {
+    return {
+      accountNumber,
+      txns: combinedTxns[accountNumber]
+    };
+  });
+  return {
+    success: true,
+    accounts
+  };
+}
+class IsracardAmexBaseScraper extends _baseScraperWithBrowser.BaseScraperWithBrowser {
+  constructor(options, baseUrl, companyCode) {
+    super(options);
+    this.baseUrl = baseUrl;
+    this.companyCode = companyCode;
+    this.servicesUrl = `${baseUrl}/services/ProxyRequestHandler.ashx`;
+  }
+  async login(credentials) {
+    await this.page.setRequestInterception(true);
+    this.page.on('request', request => {
+      if (request.url().includes('detector-dom.min.js')) {
+        debug('force abort for request do download detector-dom.min.js resource');
+        void request.abort(undefined, _browser.interceptionPriorities.abort);
+      } else {
+        void request.continue(undefined, _browser.interceptionPriorities.continue);
+      }
+    });
+    await (0, _browser.maskHeadlessUserAgent)(this.page);
+    await this.navigateTo(`${this.baseUrl}/personalarea/Login`);
+    this.emitProgress(_definitions.ScraperProgressTypes.LoggingIn);
+    const validateUrl = `${this.servicesUrl}?reqName=ValidateIdData`;
+    const validateRequest = {
+      id: credentials.id,
+      cardSuffix: credentials.card6Digits,
+      countryCode: COUNTRY_CODE,
+      idType: ID_TYPE,
+      checkLevel: '1',
+      companyCode: this.companyCode
+    };
+    debug('logging in with validate request');
+    const validateResult = await (0, _fetch.fetchPostWithinPage)(this.page, validateUrl, validateRequest);
+    if (!validateResult || !validateResult.Header || validateResult.Header.Status !== '1' || !validateResult.ValidateIdDataBean) {
+      throw new Error('unknown error during login');
+    }
+    const validateReturnCode = validateResult.ValidateIdDataBean.returnCode;
+    debug(`user validate with return code '${validateReturnCode}'`);
+    if (validateReturnCode === '1') {
+      const {
+        userName
+      } = validateResult.ValidateIdDataBean;
+      const loginUrl = `${this.servicesUrl}?reqName=performLogonI`;
+      const request = {
+        KodMishtamesh: userName,
+        MisparZihuy: credentials.id,
+        Sisma: credentials.password,
+        cardSuffix: credentials.card6Digits,
+        countryCode: COUNTRY_CODE,
+        idType: ID_TYPE
+      };
+      debug('user login started');
+      const loginResult = await (0, _fetch.fetchPostWithinPage)(this.page, loginUrl, request);
+      debug(`user login with status '${loginResult?.status}'`, loginResult);
+      if (loginResult && loginResult.status === '1') {
+        this.emitProgress(_definitions.ScraperProgressTypes.LoginSuccess);
+        return {
+          success: true
+        };
+      }
+      if (loginResult && loginResult.status === '3') {
+        this.emitProgress(_definitions.ScraperProgressTypes.ChangePassword);
+        return {
+          success: false,
+          errorType: _errors.ScraperErrorTypes.ChangePassword
+        };
+      }
+      this.emitProgress(_definitions.ScraperProgressTypes.LoginFailed);
+      return {
+        success: false,
+        errorType: _errors.ScraperErrorTypes.InvalidPassword
+      };
+    }
+    if (validateReturnCode === '4') {
+      this.emitProgress(_definitions.ScraperProgressTypes.ChangePassword);
+      return {
+        success: false,
+        errorType: _errors.ScraperErrorTypes.ChangePassword
+      };
+    }
+    this.emitProgress(_definitions.ScraperProgressTypes.LoginFailed);
+    return {
+      success: false,
+      errorType: _errors.ScraperErrorTypes.InvalidPassword
+    };
+  }
+  async fetchData() {
+    const defaultStartMoment = (0, _moment.default)().subtract(1, 'years');
+    const startDate = this.options.startDate || defaultStartMoment.toDate();
+    const startMoment = _moment.default.max(defaultStartMoment, (0, _moment.default)(startDate));
+    return fetchAllTransactions(this.page, this.options, {
+      servicesUrl: this.servicesUrl,
+      companyCode: this.companyCode
+    }, startMoment);
+  }
+}
+var _default = exports.default = IsracardAmexBaseScraper;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_moment","_constants","_definitions","_dates","_debug","_fetch","_transactions","_waiting","_transactions2","_baseScraperWithBrowser","_errors","_browser","e","__esModule","default","RATE_LIMIT","SLEEP_BETWEEN","TRANSACTIONS_BATCH_SIZE","COUNTRY_CODE","ID_TYPE","INSTALLMENTS_KEYWORD","DATE_FORMAT","debug","getDebug","getAccountsUrl","servicesUrl","monthMoment","billingDate","format","url","URL","searchParams","set","toString","fetchAccounts","page","dataUrl","dataResult","fetchGetWithinPage","_","get","DashboardMonthBean","cardsCharges","map","cardCharge","index","parseInt","cardIndex","accountNumber","cardNumber","processedDate","moment","toISOString","getTransactionsUrl","month","year","monthStr","convertCurrency","currencyStr","SHEKEL_CURRENCY_KEYWORD","ALT_SHEKEL_CURRENCY","SHEKEL_CURRENCY","getInstallmentsInfo","txn","moreInfo","includes","undefined","matches","match","length","number","total","getTransactionType","TransactionTypes","Installments","Normal","convertTransactions","txns","filteredTxns","filter","dealSumType","voucherNumberRatz","voucherNumberRatzOutbound","isOutbound","dealSumOutbound","txnDateStr","fullPurchaseDateOutbound","fullPurchaseDate","txnMoment","currentProcessedDate","fullPaymentDate","result","type","identifier","date","originalAmount","dealSum","originalCurrency","currentPaymentCurrency","currencyId","chargedAmount","paymentSumOutbound","paymentSum","chargedCurrency","description","fullSupplierNameOutbound","fullSupplierNameHeb","memo","installments","status","TransactionStatuses","Completed","fetchTransactions","options","companyServiceOptions","startMoment","accounts","sleep","CardsTransactionsListBean","accountTxns","forEach","account","txnGroups","allTxns","txnGroup","txnIsrael","push","txnAbroad","combineInstallments","fixInstallments","outputData","enableTransactionsFilterByDate","filterOldTransactions","getExtraScrapTransaction","accountIndex","transaction","data","rawCategory","category","trim","getExtraScrapAccount","accountMap","Object","values","txnsChunk","chunk","updatedTxns","Promise","all","t","reduce","m","x","getAdditionalTransactionInformation","scraperOptions","accountsWithIndex","allMonths","additionalTransactionInformation","optInFeatures","runSerial","a","i","fetchAllTransactions","futureMonthsToScrape","getAllMonthMoments","results","finalResult","combinedTxns","keys","txnsForAccount","toBeAddedTxns","success","IsracardAmexBaseScraper","BaseScraperWithBrowser","constructor","baseUrl","companyCode","login","credentials","setRequestInterception","on","request","abort","interceptionPriorities","continue","maskHeadlessUserAgent","navigateTo","emitProgress","ScraperProgressTypes","LoggingIn","validateUrl","validateRequest","id","cardSuffix","card6Digits","countryCode","idType","checkLevel","validateResult","fetchPostWithinPage","Header","Status","ValidateIdDataBean","Error","validateReturnCode","returnCode","userName","loginUrl","KodMishtamesh","MisparZihuy","Sisma","password","loginResult","LoginSuccess","ChangePassword","errorType","ScraperErrorTypes","LoginFailed","InvalidPassword","fetchData","defaultStartMoment","subtract","startDate","toDate","max","_default","exports"],"sources":["../../src/scrapers/base-isracard-amex.ts"],"sourcesContent":["import _ from 'lodash';\nimport moment, { type Moment } from 'moment';\nimport { type Page } from 'puppeteer';\nimport { ALT_SHEKEL_CURRENCY, SHEKEL_CURRENCY, SHEKEL_CURRENCY_KEYWORD } from '../constants';\nimport { ScraperProgressTypes } from '../definitions';\nimport getAllMonthMoments from '../helpers/dates';\nimport { getDebug } from '../helpers/debug';\nimport { fetchGetWithinPage, fetchPostWithinPage } from '../helpers/fetch';\nimport { filterOldTransactions, fixInstallments } from '../helpers/transactions';\nimport { runSerial, sleep } from '../helpers/waiting';\nimport {\n  TransactionStatuses,\n  TransactionTypes,\n  type Transaction,\n  type TransactionInstallments,\n  type TransactionsAccount,\n} from '../transactions';\nimport { BaseScraperWithBrowser } from './base-scraper-with-browser';\nimport { ScraperErrorTypes } from './errors';\nimport { type ScraperOptions, type ScraperScrapingResult } from './interface';\nimport { interceptionPriorities, maskHeadlessUserAgent } from '../helpers/browser';\n\nconst RATE_LIMIT = {\n  SLEEP_BETWEEN: 1000,\n  TRANSACTIONS_BATCH_SIZE: 10,\n} as const;\n\nconst COUNTRY_CODE = '212';\nconst ID_TYPE = '1';\nconst INSTALLMENTS_KEYWORD = 'תשלום';\n\nconst DATE_FORMAT = 'DD/MM/YYYY';\n\nconst debug = getDebug('base-isracard-amex');\n\ntype CompanyServiceOptions = {\n  servicesUrl: string;\n  companyCode: string;\n};\n\ntype ScrapedAccountsWithIndex = Record<string, TransactionsAccount & { index: number }>;\n\ninterface ScrapedTransaction {\n  dealSumType: string;\n  voucherNumberRatzOutbound: string;\n  voucherNumberRatz: string;\n  moreInfo?: string;\n  dealSumOutbound: boolean;\n  currencyId: string;\n  currentPaymentCurrency: string;\n  dealSum: number;\n  fullPaymentDate?: string;\n  fullPurchaseDate?: string;\n  fullPurchaseDateOutbound?: string;\n  fullSupplierNameHeb: string;\n  fullSupplierNameOutbound: string;\n  paymentSum: number;\n  paymentSumOutbound: number;\n}\n\ninterface ScrapedAccount {\n  index: number;\n  accountNumber: string;\n  processedDate: string;\n}\n\ninterface ScrapedLoginValidation {\n  Header: {\n    Status: string;\n  };\n  ValidateIdDataBean?: {\n    userName?: string;\n    returnCode: string;\n  };\n}\n\ninterface ScrapedAccountsWithinPageResponse {\n  Header: {\n    Status: string;\n  };\n  DashboardMonthBean?: {\n    cardsCharges: {\n      cardIndex: string;\n      cardNumber: string;\n      billingDate: string;\n    }[];\n  };\n}\n\ninterface ScrapedCurrentCardTransactions {\n  txnIsrael?: ScrapedTransaction[];\n  txnAbroad?: ScrapedTransaction[];\n}\n\ninterface ScrapedTransactionData {\n  Header?: {\n    Status: string;\n  };\n  PirteyIska_204Bean?: {\n    sector: string;\n  };\n\n  CardsTransactionsListBean?: Record<\n    string,\n    {\n      CurrentCardTransactions: ScrapedCurrentCardTransactions[];\n    }\n  >;\n}\n\nfunction getAccountsUrl(servicesUrl: string, monthMoment: Moment) {\n  const billingDate = monthMoment.format('YYYY-MM-DD');\n  const url = new URL(servicesUrl);\n  url.searchParams.set('reqName', 'DashboardMonth');\n  url.searchParams.set('actionCode', '0');\n  url.searchParams.set('billingDate', billingDate);\n  url.searchParams.set('format', 'Json');\n  return url.toString();\n}\n\nasync function fetchAccounts(page: Page, servicesUrl: string, monthMoment: Moment): Promise<ScrapedAccount[]> {\n  const dataUrl = getAccountsUrl(servicesUrl, monthMoment);\n  debug(`fetching accounts from ${dataUrl}`);\n  const dataResult = await fetchGetWithinPage<ScrapedAccountsWithinPageResponse>(page, dataUrl);\n  if (dataResult && _.get(dataResult, 'Header.Status') === '1' && dataResult.DashboardMonthBean) {\n    const { cardsCharges } = dataResult.DashboardMonthBean;\n    if (cardsCharges) {\n      return cardsCharges.map(cardCharge => {\n        return {\n          index: parseInt(cardCharge.cardIndex, 10),\n          accountNumber: cardCharge.cardNumber,\n          processedDate: moment(cardCharge.billingDate, DATE_FORMAT).toISOString(),\n        };\n      });\n    }\n  }\n  return [];\n}\n\nfunction getTransactionsUrl(servicesUrl: string, monthMoment: Moment) {\n  const month = monthMoment.month() + 1;\n  const year = monthMoment.year();\n  const monthStr = month < 10 ? `0${month}` : month.toString();\n  const url = new URL(servicesUrl);\n  url.searchParams.set('reqName', 'CardsTransactionsList');\n  url.searchParams.set('month', monthStr);\n  url.searchParams.set('year', `${year}`);\n  url.searchParams.set('requiredDate', 'N');\n  return url.toString();\n}\n\nfunction convertCurrency(currencyStr: string) {\n  if (currencyStr === SHEKEL_CURRENCY_KEYWORD || currencyStr === ALT_SHEKEL_CURRENCY) {\n    return SHEKEL_CURRENCY;\n  }\n  return currencyStr;\n}\n\nfunction getInstallmentsInfo(txn: ScrapedTransaction): TransactionInstallments | undefined {\n  if (!txn.moreInfo || !txn.moreInfo.includes(INSTALLMENTS_KEYWORD)) {\n    return undefined;\n  }\n  const matches = txn.moreInfo.match(/\\d+/g);\n  if (!matches || matches.length < 2) {\n    return undefined;\n  }\n\n  return {\n    number: parseInt(matches[0], 10),\n    total: parseInt(matches[1], 10),\n  };\n}\n\nfunction getTransactionType(txn: ScrapedTransaction) {\n  return getInstallmentsInfo(txn) ? TransactionTypes.Installments : TransactionTypes.Normal;\n}\n\nfunction convertTransactions(txns: ScrapedTransaction[], processedDate: string): Transaction[] {\n  const filteredTxns = txns.filter(\n    txn =>\n      txn.dealSumType !== '1' && txn.voucherNumberRatz !== '000000000' && txn.voucherNumberRatzOutbound !== '000000000',\n  );\n\n  return filteredTxns.map(txn => {\n    const isOutbound = txn.dealSumOutbound;\n    const txnDateStr = isOutbound ? txn.fullPurchaseDateOutbound : txn.fullPurchaseDate;\n    const txnMoment = moment(txnDateStr, DATE_FORMAT);\n\n    const currentProcessedDate = txn.fullPaymentDate\n      ? moment(txn.fullPaymentDate, DATE_FORMAT).toISOString()\n      : processedDate;\n    const result: Transaction = {\n      type: getTransactionType(txn),\n      identifier: parseInt(isOutbound ? txn.voucherNumberRatzOutbound : txn.voucherNumberRatz, 10),\n      date: txnMoment.toISOString(),\n      processedDate: currentProcessedDate,\n      originalAmount: isOutbound ? -txn.dealSumOutbound : -txn.dealSum,\n      originalCurrency: convertCurrency(txn.currentPaymentCurrency ?? txn.currencyId),\n      chargedAmount: isOutbound ? -txn.paymentSumOutbound : -txn.paymentSum,\n      chargedCurrency: convertCurrency(txn.currencyId),\n      description: isOutbound ? txn.fullSupplierNameOutbound : txn.fullSupplierNameHeb,\n      memo: txn.moreInfo || '',\n      installments: getInstallmentsInfo(txn) || undefined,\n      status: TransactionStatuses.Completed,\n    };\n\n    return result;\n  });\n}\n\nasync function fetchTransactions(\n  page: Page,\n  options: ScraperOptions,\n  companyServiceOptions: CompanyServiceOptions,\n  startMoment: Moment,\n  monthMoment: Moment,\n): Promise<ScrapedAccountsWithIndex> {\n  const accounts = await fetchAccounts(page, companyServiceOptions.servicesUrl, monthMoment);\n  const dataUrl = getTransactionsUrl(companyServiceOptions.servicesUrl, monthMoment);\n  await sleep(RATE_LIMIT.SLEEP_BETWEEN);\n  debug(`fetching transactions from ${dataUrl} for month ${monthMoment.format('YYYY-MM')}`);\n  const dataResult = await fetchGetWithinPage<ScrapedTransactionData>(page, dataUrl);\n  if (dataResult && _.get(dataResult, 'Header.Status') === '1' && dataResult.CardsTransactionsListBean) {\n    const accountTxns: ScrapedAccountsWithIndex = {};\n    accounts.forEach(account => {\n      const txnGroups: ScrapedCurrentCardTransactions[] | undefined = _.get(\n        dataResult,\n        `CardsTransactionsListBean.Index${account.index}.CurrentCardTransactions`,\n      );\n      if (txnGroups) {\n        let allTxns: Transaction[] = [];\n        txnGroups.forEach(txnGroup => {\n          if (txnGroup.txnIsrael) {\n            const txns = convertTransactions(txnGroup.txnIsrael, account.processedDate);\n            allTxns.push(...txns);\n          }\n          if (txnGroup.txnAbroad) {\n            const txns = convertTransactions(txnGroup.txnAbroad, account.processedDate);\n            allTxns.push(...txns);\n          }\n        });\n\n        if (!options.combineInstallments) {\n          allTxns = fixInstallments(allTxns);\n        }\n        if (options.outputData?.enableTransactionsFilterByDate ?? true) {\n          allTxns = filterOldTransactions(allTxns, startMoment, options.combineInstallments || false);\n        }\n        accountTxns[account.accountNumber] = {\n          accountNumber: account.accountNumber,\n          index: account.index,\n          txns: allTxns,\n        };\n      }\n    });\n    return accountTxns;\n  }\n\n  return {};\n}\n\nasync function getExtraScrapTransaction(\n  page: Page,\n  options: CompanyServiceOptions,\n  month: Moment,\n  accountIndex: number,\n  transaction: Transaction,\n): Promise<Transaction> {\n  const url = new URL(options.servicesUrl);\n  url.searchParams.set('reqName', 'PirteyIska_204');\n  url.searchParams.set('CardIndex', accountIndex.toString());\n  url.searchParams.set('shovarRatz', transaction.identifier!.toString());\n  url.searchParams.set('moedChiuv', month.format('MMYYYY'));\n\n  debug(`fetching extra scrap for transaction ${transaction.identifier} for month ${month.format('YYYY-MM')}`);\n  const data = await fetchGetWithinPage<ScrapedTransactionData>(page, url.toString());\n  if (!data) {\n    return transaction;\n  }\n\n  const rawCategory = _.get(data, 'PirteyIska_204Bean.sector') ?? '';\n  return {\n    ...transaction,\n    category: rawCategory.trim(),\n  };\n}\n\nasync function getExtraScrapAccount(\n  page: Page,\n  options: CompanyServiceOptions,\n  accountMap: ScrapedAccountsWithIndex,\n  month: moment.Moment,\n): Promise<ScrapedAccountsWithIndex> {\n  const accounts: ScrapedAccountsWithIndex[string][] = [];\n  for (const account of Object.values(accountMap)) {\n    debug(\n      `get extra scrap for ${account.accountNumber} with ${account.txns.length} transactions`,\n      month.format('YYYY-MM'),\n    );\n    const txns: Transaction[] = [];\n    for (const txnsChunk of _.chunk(account.txns, RATE_LIMIT.TRANSACTIONS_BATCH_SIZE)) {\n      debug(`processing chunk of ${txnsChunk.length} transactions for account ${account.accountNumber}`);\n      const updatedTxns = await Promise.all(\n        txnsChunk.map(t => getExtraScrapTransaction(page, options, month, account.index, t)),\n      );\n      await sleep(RATE_LIMIT.SLEEP_BETWEEN);\n      txns.push(...updatedTxns);\n    }\n    accounts.push({ ...account, txns });\n  }\n\n  return accounts.reduce((m, x) => ({ ...m, [x.accountNumber]: x }), {});\n}\n\nasync function getAdditionalTransactionInformation(\n  scraperOptions: ScraperOptions,\n  accountsWithIndex: ScrapedAccountsWithIndex[],\n  page: Page,\n  options: CompanyServiceOptions,\n  allMonths: moment.Moment[],\n): Promise<ScrapedAccountsWithIndex[]> {\n  if (\n    !scraperOptions.additionalTransactionInformation ||\n    scraperOptions.optInFeatures?.includes('isracard-amex:skipAdditionalTransactionInformation')\n  ) {\n    return accountsWithIndex;\n  }\n  return runSerial(accountsWithIndex.map((a, i) => () => getExtraScrapAccount(page, options, a, allMonths[i])));\n}\n\nasync function fetchAllTransactions(\n  page: Page,\n  options: ScraperOptions,\n  companyServiceOptions: CompanyServiceOptions,\n  startMoment: Moment,\n) {\n  const futureMonthsToScrape = options.futureMonthsToScrape ?? 1;\n  const allMonths = getAllMonthMoments(startMoment, futureMonthsToScrape);\n  const results: ScrapedAccountsWithIndex[] = await runSerial(\n    allMonths.map(monthMoment => () => {\n      return fetchTransactions(page, options, companyServiceOptions, startMoment, monthMoment);\n    }),\n  );\n\n  const finalResult = await getAdditionalTransactionInformation(\n    options,\n    results,\n    page,\n    companyServiceOptions,\n    allMonths,\n  );\n  const combinedTxns: Record<string, Transaction[]> = {};\n\n  finalResult.forEach(result => {\n    Object.keys(result).forEach(accountNumber => {\n      let txnsForAccount = combinedTxns[accountNumber];\n      if (!txnsForAccount) {\n        txnsForAccount = [];\n        combinedTxns[accountNumber] = txnsForAccount;\n      }\n      const toBeAddedTxns = result[accountNumber].txns;\n      combinedTxns[accountNumber].push(...toBeAddedTxns);\n    });\n  });\n\n  const accounts = Object.keys(combinedTxns).map(accountNumber => {\n    return {\n      accountNumber,\n      txns: combinedTxns[accountNumber],\n    };\n  });\n\n  return {\n    success: true,\n    accounts,\n  };\n}\n\ntype ScraperSpecificCredentials = { id: string; password: string; card6Digits: string };\nclass IsracardAmexBaseScraper extends BaseScraperWithBrowser<ScraperSpecificCredentials> {\n  private baseUrl: string;\n\n  private companyCode: string;\n\n  private servicesUrl: string;\n\n  constructor(options: ScraperOptions, baseUrl: string, companyCode: string) {\n    super(options);\n\n    this.baseUrl = baseUrl;\n    this.companyCode = companyCode;\n    this.servicesUrl = `${baseUrl}/services/ProxyRequestHandler.ashx`;\n  }\n\n  async login(credentials: ScraperSpecificCredentials): Promise<ScraperScrapingResult> {\n    await this.page.setRequestInterception(true);\n    this.page.on('request', request => {\n      if (request.url().includes('detector-dom.min.js')) {\n        debug('force abort for request do download detector-dom.min.js resource');\n        void request.abort(undefined, interceptionPriorities.abort);\n      } else {\n        void request.continue(undefined, interceptionPriorities.continue);\n      }\n    });\n\n    await maskHeadlessUserAgent(this.page);\n\n    await this.navigateTo(`${this.baseUrl}/personalarea/Login`);\n\n    this.emitProgress(ScraperProgressTypes.LoggingIn);\n\n    const validateUrl = `${this.servicesUrl}?reqName=ValidateIdData`;\n    const validateRequest = {\n      id: credentials.id,\n      cardSuffix: credentials.card6Digits,\n      countryCode: COUNTRY_CODE,\n      idType: ID_TYPE,\n      checkLevel: '1',\n      companyCode: this.companyCode,\n    };\n    debug('logging in with validate request');\n    const validateResult = await fetchPostWithinPage<ScrapedLoginValidation>(this.page, validateUrl, validateRequest);\n    if (\n      !validateResult ||\n      !validateResult.Header ||\n      validateResult.Header.Status !== '1' ||\n      !validateResult.ValidateIdDataBean\n    ) {\n      throw new Error('unknown error during login');\n    }\n\n    const validateReturnCode = validateResult.ValidateIdDataBean.returnCode;\n    debug(`user validate with return code '${validateReturnCode}'`);\n    if (validateReturnCode === '1') {\n      const { userName } = validateResult.ValidateIdDataBean;\n\n      const loginUrl = `${this.servicesUrl}?reqName=performLogonI`;\n      const request = {\n        KodMishtamesh: userName,\n        MisparZihuy: credentials.id,\n        Sisma: credentials.password,\n        cardSuffix: credentials.card6Digits,\n        countryCode: COUNTRY_CODE,\n        idType: ID_TYPE,\n      };\n      debug('user login started');\n      const loginResult = await fetchPostWithinPage<{ status: string }>(this.page, loginUrl, request);\n      debug(`user login with status '${loginResult?.status}'`, loginResult);\n\n      if (loginResult && loginResult.status === '1') {\n        this.emitProgress(ScraperProgressTypes.LoginSuccess);\n        return { success: true };\n      }\n\n      if (loginResult && loginResult.status === '3') {\n        this.emitProgress(ScraperProgressTypes.ChangePassword);\n        return {\n          success: false,\n          errorType: ScraperErrorTypes.ChangePassword,\n        };\n      }\n\n      this.emitProgress(ScraperProgressTypes.LoginFailed);\n      return {\n        success: false,\n        errorType: ScraperErrorTypes.InvalidPassword,\n      };\n    }\n\n    if (validateReturnCode === '4') {\n      this.emitProgress(ScraperProgressTypes.ChangePassword);\n      return {\n        success: false,\n        errorType: ScraperErrorTypes.ChangePassword,\n      };\n    }\n\n    this.emitProgress(ScraperProgressTypes.LoginFailed);\n    return {\n      success: false,\n      errorType: ScraperErrorTypes.InvalidPassword,\n    };\n  }\n\n  async fetchData() {\n    const defaultStartMoment = moment().subtract(1, 'years');\n    const startDate = this.options.startDate || defaultStartMoment.toDate();\n    const startMoment = moment.max(defaultStartMoment, moment(startDate));\n\n    return fetchAllTransactions(\n      this.page,\n      this.options,\n      {\n        servicesUrl: this.servicesUrl,\n        companyCode: this.companyCode,\n      },\n      startMoment,\n    );\n  }\n}\n\nexport default IsracardAmexBaseScraper;\n"],"mappings":"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","ignoreList":[]}

package/lib/scrapers/base-scraper-with-browser.d.ts

@@ -0,0 +1,57 @@
+import { type Frame, type Page, type PuppeteerLifeCycleEvent } from 'puppeteer';
+import { BaseScraper } from './base-scraper';
+import { ScraperErrorTypes } from './errors';
+import { type ScraperCredentials, type ScraperScrapingResult } from './interface';
+declare enum LoginBaseResults {
+    Success = "SUCCESS",
+    UnknownError = "UNKNOWN_ERROR"
+}
+export declare const LoginResults: {
+    Success: LoginBaseResults.Success;
+    UnknownError: LoginBaseResults.UnknownError;
+    TwoFactorRetrieverMissing: ScraperErrorTypes.TwoFactorRetrieverMissing;
+    InvalidPassword: ScraperErrorTypes.InvalidPassword;
+    ChangePassword: ScraperErrorTypes.ChangePassword;
+    AccountBlocked: ScraperErrorTypes.AccountBlocked;
+};
+export type LoginResults = Exclude<ScraperErrorTypes, ScraperErrorTypes.Timeout | ScraperErrorTypes.Generic | ScraperErrorTypes.General> | LoginBaseResults;
+export type PossibleLoginResults = {
+    [key in LoginResults]?: (string | RegExp | ((options?: {
+        page?: Page;
+    }) => Promise<boolean>))[];
+};
+export interface LoginOptions {
+    loginUrl: string;
+    checkReadiness?: () => Promise<void>;
+    fields: {
+        selector: string;
+        value: string;
+    }[];
+    submitButtonSelector: string | (() => Promise<void>);
+    preAction?: () => Promise<Frame | void>;
+    postAction?: () => Promise<void>;
+    possibleResults: PossibleLoginResults;
+    userAgent?: string;
+    waitUntil?: PuppeteerLifeCycleEvent;
+}
+declare class BaseScraperWithBrowser<TCredentials extends ScraperCredentials> extends BaseScraper<TCredentials> {
+    private cleanups;
+    private defaultViewportSize;
+    protected page: Page;
+    protected getViewPort(): {
+        width: number;
+        height: number;
+    };
+    initialize(): Promise<void>;
+    private initializePage;
+    navigateTo(url: string, waitUntil?: PuppeteerLifeCycleEvent | undefined, retries?: number): Promise<void>;
+    getLoginOptions(_credentials: ScraperCredentials): LoginOptions;
+    fillInputs(pageOrFrame: Page | Frame, fields: {
+        selector: string;
+        value: string;
+    }[]): Promise<void>;
+    login(credentials: ScraperCredentials): Promise<ScraperScrapingResult>;
+    terminate(_success: boolean): Promise<void>;
+    private handleLoginResult;
+}
+export { BaseScraperWithBrowser };