node-clippercard/lib/statement.js

Unofficial Node.js library to retrieve and parse profile and activity data from the Bay Area's Clipper Card system

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _pdf2json = require('pdf2json');

var _pdf2json2 = _interopRequireDefault(_pdf2json);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ClipperStatement = function () {
  function ClipperStatement(buffer) {
    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    _classCallCheck(this, ClipperStatement);

    if (false === Buffer.isBuffer(buffer)) {
      throw new Error('ClipperStatement must be instantiated with a valid buffer');
    }

    this._rawBuffer = buffer;
    this.activity = undefined;
  }

  _createClass(ClipperStatement, [{
    key: 'getActivity',
    value: function getActivity(callback) {
      var _this = this;

      if (undefined !== this.activity) {
        return callback(null, this.activity);
      }

      var pdf = new _pdf2json2.default();
      pdf.parseBuffer(this._rawBuffer);

      pdf.on('pdfParser_dataError', function (error) {
        return callback(error);
      });
      pdf.on('pdfParser_dataReady', function (result) {
        return _this._parse(callback, result);
      });
    }
  }, {
    key: '_parse',
    value: function _parse(callback, result) {
      var pages = result.formImage.Pages;
      var texts = [];

      var pageNumber = 0;
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = result.formImage.Pages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var page = _step.value;

          pageNumber++;
          var _iteratorNormalCompletion5 = true;
          var _didIteratorError5 = false;
          var _iteratorError5 = undefined;

          try {
            for (var _iterator5 = page.Texts[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
              var t = _step5.value;

              texts.push({
                p: pageNumber,
                x: t.x,
                y: t.y,
                t: decodeURIComponent(t.R[0].T)
              });
            }
          } catch (err) {
            _didIteratorError5 = true;
            _iteratorError5 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion5 && _iterator5.return) {
                _iterator5.return();
              }
            } finally {
              if (_didIteratorError5) {
                throw _iteratorError5;
              }
            }
          }

          ;
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      ;

      var yHeader = texts.filter(function (v) {
        return 'TRANSACTION TYPE' === v.t;
      })[0].y;
      var th = texts.filter(function (v) {
        return yHeader === v.y;
      }).map(function (v) {
        var map = {
          'TRANSACTION TYPE': 'transactionType',
          'LOCATION': 'location',
          'ROUTE': 'route',
          'PRODUCT': 'product',
          'DEBIT': 'debit',
          'CREDIT': 'credit',
          'BALANCE*': 'balance'
        };

        if (undefined !== map[v.t]) {
          return { x: v.x, key: map[v.t] };
        } else {
          return null;
        }
      }).filter(function (v) {
        return null !== v;
      });
      th.unshift({ x: 0, key: 'dateTime' });
      th.sort(function (a, b) {
        return a.x < b.x;
      });

      var findColumnName = function findColumnName(x) {
        var _iteratorNormalCompletion2 = true;
        var _didIteratorError2 = false;
        var _iteratorError2 = undefined;

        try {
          for (var _iterator2 = th[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
            var i = _step2.value;

            if (i.x <= x) {
              return i.key;
            }
          }
        } catch (err) {
          _didIteratorError2 = true;
          _iteratorError2 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion2 && _iterator2.return) {
              _iterator2.return();
            }
          } finally {
            if (_didIteratorError2) {
              throw _iteratorError2;
            }
          }
        }
      };

      // split the texts into rows
      var rows = {};
      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

      try {
        for (var _iterator3 = texts.filter(function (v) {
          return v.p > 1 || v.y > yHeader;
        })[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var t = _step3.value;

          if (undefined === rows[t.p + '/' + t.y]) {
            rows[t.p + '/' + t.y] = [];
          }
          rows[t.p + '/' + t.y].push({ x: t.x, t: t.t });
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3.return) {
            _iterator3.return();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }

      var column, r, activity;
      this.activity = [];
      for (var i in rows) {
        r = rows[i];
        activity = {};
        var _iteratorNormalCompletion4 = true;
        var _didIteratorError4 = false;
        var _iteratorError4 = undefined;

        try {
          for (var _iterator4 = r[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
            var c = _step4.value;

            activity[findColumnName(c.x)] = c.t;
          }
        } catch (err) {
          _didIteratorError4 = true;
          _iteratorError4 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion4 && _iterator4.return) {
              _iterator4.return();
            }
          } finally {
            if (_didIteratorError4) {
              throw _iteratorError4;
            }
          }
        }

        if ('undefined' !== typeof activity.dateTime && activity.dateTime.search(/[0-9]{2}\/[0-9]{2}\/[0-9]{4} [0-9]{2}:[0-9]{2} (AM|PM)/) > -1) {
          this.activity.push(activity);
        }
      }
      return callback(null, this.activity);
    }
  }], [{
    key: 'fromFile',
    value: function fromFile(path, callback) {
      var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

      if ('function' !== typeof callback) {
        callback = function callback() {};
      }

      if ('string' !== typeof path) {
        return callback(new Error('Path is required to create statement from file'));
      }

      _fs2.default.readFile(path, function (error, buffer) {
        if (error) {
          return callback(error);
        }

        try {
          var statement = new ClipperStatement(buffer, options);
        } catch (e) {
          return callback(e);
        }

        callback(null, statement);
      });
    }
  }]);

  return ClipperStatement;
}();

exports.default = ClipperStatement;