@nlabs/reaktor 0.3.0 → 0.4.0

package/lib/data/payments.js

@@ -0,0 +1,771 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.for-each");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.array.map");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.date.now");
+
+require("core-js/modules/es.date.to-string");
+
+require("core-js/modules/es.object.define-properties");
+
+require("core-js/modules/es.object.define-property");
+
+require("core-js/modules/es.object.freeze");
+
+require("core-js/modules/es.object.get-own-property-descriptor");
+
+require("core-js/modules/es.object.get-own-property-descriptors");
+
+require("core-js/modules/es.object.keys");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/es.string.iterator");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPaymentHold = exports.createPaymentTransfer = exports.deleteBankAccount = exports.deleteCreditCard = exports.getCreditCards = exports.updateCreditCard = exports.addCreditCard = exports.addBankAccount = exports.addCustomerAccount = void 0;
+
+var _utils = require("@nlabs/utils");
+
+var _arangojs = require("arangojs");
+
+var _graphqlErrors = require("graphql-errors");
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _stripe = _interopRequireDefault(require("stripe"));
+
+var _config = require("../config");
+
+var _analytics = require("../utils/analytics");
+
+var _arangodb = require("../utils/arangodb");
+
+var _users = require("./users");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _templateObject10() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN payments RETURN NEW"]);
+
+  _templateObject10 = function _templateObject10() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject9() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN transfers RETURN NEW"]);
+
+  _templateObject9 = function _templateObject9() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject8() {
+  var data = _taggedTemplateLiteral(["UPDATE ", " WITH ", " IN users LIMIT 1 RETURN NEW"]);
+
+  _templateObject8 = function _templateObject8() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject7() {
+  var data = _taggedTemplateLiteral(["REMOVE {_key:", "} IN hasPayment"]);
+
+  _templateObject7 = function _templateObject7() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject6() {
+  var data = _taggedTemplateLiteral(["\n    LET card = FIRST(\n      FOR c IN creditCards\n      FILTER c._key == ", " && c.userId == ", "\n      LIMIT 1\n      REMOVE c IN creditCards\n      RETURN OLD\n    )\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u._key == ", "\n      LIMIT 1\n      RETURN u\n    )\n    RETURN {user: user, card: card}"]);
+
+  _templateObject6 = function _templateObject6() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject5() {
+  var data = _taggedTemplateLiteral(["FOR c IN creditCards\n    FILTER c.userId == ", "\n    RETURN c"]);
+
+  _templateObject5 = function _templateObject5() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject4() {
+  var data = _taggedTemplateLiteral(["\n      LET updatedCard = FIRST(\n        FOR c IN creditCards\n        FILTER c._key == ", " && c.userId == ", "\n        UPDATE c WITH ", " IN creditCards\n        LIMIT 1\n        RETURN NEW\n      )\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == ", "\n        LIMIT 1\n        RETURN u\n      )\n      RETURN {user: user, card: updatedCard}"]);
+
+  _templateObject4 = function _templateObject4() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN creditCards RETURN NEW"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["UPDATE ", " WITH ", " IN users LIMIT 1 RETURN NEW"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["UPDATE ", " WITH ", " IN users LIMIT 1 RETURN NEW"]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+var eventCategory = 'payments';
+var apiVersion = '2020-03-02';
+
+var addCustomerAccount = function addCustomerAccount(context) {
+  var action = 'addCustomerAccount';
+  var database = context.database,
+      sessionId = context.userId,
+      username = context.username; // Stripe
+
+  var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+    apiVersion: apiVersion,
+    typescript: true
+  });
+  return stripeClient.customers.create({
+    metadata: {
+      userId: sessionId,
+      username: username
+    }
+  }).then(function (customer) {
+    // Create session
+    var now = Date.now();
+    var update = {
+      modified: now,
+      stripeCustomerId: customer.id
+    };
+    var aqlQry = (0, _arangojs.aql)(_templateObject(), sessionId, update);
+    return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+      return cursor.next();
+    }).then(function () {
+      var updatedUser = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return !(0, _isEmpty["default"])(updatedUser);
+    })["catch"](function (error) {
+      return (0, _analytics.logError)({
+        action: action,
+        category: eventCategory,
+        label: 'db_error'
+      }, error, context).then(function () {
+        return null;
+      });
+    });
+  });
+};
+
+exports.addCustomerAccount = addCustomerAccount;
+
+var addBankAccount = function addBankAccount(context, bankAccount) {
+  var action = 'addPaymentAccountBank';
+  var database = context.database,
+      sessionId = context.userId; // Params
+
+  var accountNumber = bankAccount.accountNumber,
+      fullName = bankAccount.fullName,
+      routing = bankAccount.routing;
+  var formatAccount = (0, _utils.parseString)(accountNumber, 32);
+
+  if (formatAccount === '') {
+    throw new _graphqlErrors.UserError('required_account_number');
+  }
+
+  var formatFullName = (0, _utils.parseVarChar)(fullName, 128);
+
+  if (formatFullName === '') {
+    throw new _graphqlErrors.UserError('required_full_name');
+  }
+
+  var formatRouting = (0, _utils.parseString)(routing, 32);
+
+  if (formatRouting === '') {
+    throw new _graphqlErrors.UserError('required_routing_number');
+  }
+
+  return (0, _users.getUser)(context, sessionId).then(function (user) {
+    var stripeAccountId = user.stripeAccountId; // Stripe
+
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    var source = {
+      account_holder_name: formatFullName,
+      account_holder_type: 'individual',
+      account_number: formatAccount,
+      country: 'US',
+      currency: 'USD',
+      object: 'bank_account',
+      routing_number: formatRouting
+    };
+    return stripeClient.customers.createSource(stripeAccountId, {
+      source: source
+    }).then(function (account) {
+      var bankId = account.id,
+          bankAccount = account.last4,
+          bankRouting = account.routing_number;
+      var update = {
+        bankAccount: bankAccount,
+        bankFullName: formatFullName,
+        bankId: bankId,
+        bankRouting: bankRouting,
+        modified: Date.now()
+      };
+      var aqlQry = (0, _arangojs.aql)(_templateObject2(), sessionId, update);
+      return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+        return cursor.next();
+      }).then(function () {
+        var updatedUser = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        return updatedUser;
+      });
+    })["catch"](function (error) {
+      var msg = error.message;
+
+      if (msg === 'A bank account with that routing number and account number ' + 'already exists for this customer.') {
+        return (0, _analytics.logError)({
+          action: action,
+          category: eventCategory,
+          label: 'bank_account_exists'
+        }, error, context).then(function () {
+          return null;
+        });
+      }
+
+      return (0, _analytics.logError)({
+        action: action,
+        category: eventCategory,
+        label: 'payment_error'
+      }, error, context).then(function () {
+        return null;
+      });
+    });
+  });
+};
+
+exports.addBankAccount = addBankAccount;
+
+var addCreditCard = function addCreditCard(context, card) {
+  var action = 'addCreditCard';
+  var database = context.database,
+      sessionId = context.userId;
+  return (0, _users.getUser)(context, sessionId).then(function (user) {
+    // User
+    var stripeAccountId = user.stripeAccountId; // Card
+
+    var accountNumber = card.accountNumber,
+        city = card.city,
+        country = card.country,
+        cvc = card.cvc,
+        expMonth = card.expMonth,
+        expYear = card.expYear,
+        fullName = card.fullName,
+        street1 = card.street1,
+        street2 = card.street2,
+        state = card.state,
+        zip = card.zip;
+    var formatNumber = (0, _utils.parseNum)(accountNumber, 16);
+
+    if (!formatNumber) {
+      throw new _graphqlErrors.UserError('required_credit_card_number');
+    }
+
+    var formatExpMonth = (0, _utils.parseNum)(expMonth, 2);
+
+    if (!formatExpMonth) {
+      throw new _graphqlErrors.UserError('required_credit_card_exp_month');
+    }
+
+    var formatExpYear = (0, _utils.parseNum)(expYear, 2);
+
+    if (!formatExpYear) {
+      throw new _graphqlErrors.UserError('required_credit_card_exp_year');
+    }
+
+    var formatCvc = (0, _utils.parseNum)(cvc, 3); // Address
+
+    var paymentCard = {};
+    var formatCity = (0, _utils.parseVarChar)(city, 32);
+
+    if (formatCity) {
+      paymentCard.city = formatCity;
+    }
+
+    var formatCountry = (0, _utils.parseChar)(country, 2);
+
+    if (formatCountry) {
+      paymentCard.country = formatCountry;
+    }
+
+    var formatFullName = (0, _utils.parseVarChar)(fullName, 32);
+
+    if (formatFullName) {
+      paymentCard.fullName = formatFullName;
+    }
+
+    var formatStreet1 = (0, _utils.parseVarChar)(street1, 32);
+
+    if (formatStreet1) {
+      paymentCard.street1 = formatStreet1;
+    }
+
+    var formatStreet2 = (0, _utils.parseVarChar)(street2, 32);
+
+    if (formatStreet2) {
+      paymentCard.street2 = formatStreet2;
+    }
+
+    var formatState = (0, _utils.parseChar)(state, 2);
+
+    if (formatState) {
+      paymentCard.state = formatState;
+    }
+
+    var formatZip = (0, _utils.parseVarChar)(zip, 10);
+
+    if (formatZip) {
+      paymentCard.zip = formatZip;
+    } // Stripe
+
+
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    var source = {
+      address_city: formatCity,
+      address_country: formatCountry,
+      address_line1: formatStreet1,
+      address_line2: formatStreet2,
+      address_state: formatState,
+      address_zip: formatZip,
+      cvc: formatCvc,
+      exp_month: formatExpMonth,
+      exp_year: formatExpYear,
+      name: fullName,
+      number: formatNumber,
+      object: 'card'
+    };
+    return stripeClient.customers.createSource(stripeAccountId, {
+      source: source
+    }).then(function (newSource) {
+      var brand = newSource.brand,
+          cvcCheck = newSource.cvc_check,
+          last4 = newSource.last4; // Create session
+
+      var now = Date.now();
+
+      var insert = _objectSpread(_objectSpread({}, paymentCard), {}, {
+        _key: (0, _utils.createHash)("user-payment-".concat(sessionId)),
+        accountNumber: last4,
+        added: now,
+        brand: brand,
+        cvcCheck: cvcCheck,
+        expMonth: expMonth,
+        expYear: expYear,
+        modified: now,
+        userId: sessionId
+      });
+
+      var insertAqlQry = (0, _arangojs.aql)(_templateObject3(), insert);
+      return (0, _arangodb.useDb)(database).query(insertAqlQry).then(function (cursor) {
+        return cursor.next();
+      }).then(function () {
+        var newCard = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        if (!(0, _isEmpty["default"])(newCard)) {
+          // Add linked edge
+          var cardId = card._id,
+              cardKey = card._key;
+          var edgeCollection = (0, _arangodb.useDb)(database).collection('hasPayment');
+          var edgeId = (0, _utils.createHash)("payment-".concat(cardKey));
+          var edge = {
+            _from: "users/".concat(sessionId),
+            _key: edgeId,
+            _to: cardId
+          };
+          return edgeCollection.save(edge, {
+            returnNew: true
+          }).then(function () {
+            return card;
+          });
+        }
+
+        return newCard;
+      })["catch"](function (error) {
+        return (0, _analytics.logError)({
+          action: action,
+          category: eventCategory,
+          label: 'payment_error'
+        }, error, context).then(function () {
+          return null;
+        });
+      });
+    });
+  });
+};
+
+exports.addCreditCard = addCreditCard;
+
+var updateCreditCard = function updateCreditCard(context, card) {
+  var database = context.database,
+      sessionId = context.userId;
+  var city = card.city,
+      country = card.country,
+      expMonth = card.expMonth,
+      expYear = card.expYear,
+      fullName = card.fullName,
+      id = card.id,
+      street1 = card.street1,
+      state = card.state,
+      zip = card.zip;
+  var formatId = (0, _utils.parseId)(id);
+
+  if (formatId) {
+    throw new _graphqlErrors.UserError('required_credit_card_id');
+  }
+
+  var paymentCard = {};
+  var formatExpMonth = (0, _utils.parseNum)(expMonth, 2);
+  var formatExpYear = (0, _utils.parseNum)(expYear, 2);
+  var formatCity = (0, _utils.parseVarChar)(city, 32);
+  var formatCountry = (0, _utils.parseChar)(country, 2);
+  var formatFullName = (0, _utils.parseVarChar)(fullName, 32);
+  var formatStreet1 = (0, _utils.parseString)(street1, 32);
+  var formatState = (0, _utils.parseChar)(state, 2);
+  var formatZip = (0, _utils.parseVarChar)(zip, 10);
+
+  if (formatExpMonth) {
+    paymentCard.expMonth = formatExpMonth;
+  }
+
+  if (formatExpYear) {
+    paymentCard.expYear = formatExpYear;
+  }
+
+  if (formatCity) {
+    paymentCard.city = formatCity;
+  }
+
+  if (formatCountry) {
+    paymentCard.country = formatCountry;
+  }
+
+  if (formatFullName) {
+    paymentCard.fullName = formatFullName;
+  }
+
+  if (formatStreet1) {
+    paymentCard.street1 = formatStreet1;
+  }
+
+  if (formatState) {
+    paymentCard.state = formatState;
+  }
+
+  if (formatZip) {
+    paymentCard.zip = formatZip;
+  }
+
+  var update = paymentCard;
+  var aqlQry = (0, _arangojs.aql)(_templateObject4(), formatId, sessionId, update, sessionId);
+  return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var results = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      card: {},
+      user: {}
+    };
+    var updatedCard = results.card;
+    var user = results.user;
+
+    if ((0, _isEmpty["default"])(updatedCard)) {
+      throw new _graphqlErrors.UserError('not_found');
+    }
+
+    var stripeCustomerId = user.stripeCustomerId;
+    var stripeId = card.stripeId; // Stripe
+
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    var update = {
+      address_city: formatCity,
+      address_country: formatCountry,
+      address_line1: formatStreet1,
+      address_state: formatState,
+      address_zip: formatZip,
+      exp_month: formatExpMonth,
+      exp_year: formatExpYear,
+      name: formatFullName
+    };
+    return stripeClient.customers.updateSource(stripeCustomerId, stripeId, update).then(function () {
+      return card;
+    })["catch"](function (error) {
+      console.log('payments::updateCard::error', error);
+      throw new _graphqlErrors.UserError('payment_error');
+    });
+  });
+};
+
+exports.updateCreditCard = updateCreditCard;
+
+var getCreditCards = function getCreditCards(context) {
+  var action = 'getCreditCards';
+  var database = context.database,
+      sessionId = context.userId;
+  var aqlQry = (0, _arangojs.aql)(_templateObject5(), sessionId);
+  return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).then(function () {
+    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return list;
+  })["catch"](function (error) {
+    return (0, _analytics.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+
+exports.getCreditCards = getCreditCards;
+
+var deleteCreditCard = function deleteCreditCard(context, cardId) {
+  var database = context.database,
+      sessionId = context.userId;
+  var formatCardId = (0, _utils.parseId)(cardId);
+  var aqlQry = (0, _arangojs.aql)(_templateObject6(), formatCardId, sessionId, sessionId);
+  return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      card: {},
+      user: {}
+    };
+
+    if ((0, _isEmpty["default"])(result)) {
+      return false;
+    }
+
+    var card = result.card,
+        user = result.user;
+    var cardKey = card._key; // Remove linked edges
+
+    var edgeCollection = (0, _arangodb.useDb)(database).collection('hasPayment');
+    return edgeCollection.outEdges(cardKey).then(function (edges) {
+      if (edges.length) {
+        return Promise.all(edges.map(function (edge) {
+          var edgeKey = edge._key;
+          var removeAqlQry = (0, _arangojs.aql)(_templateObject7(), edgeKey);
+          return (0, _arangodb.useDb)(database).query(removeAqlQry);
+        })).then(function () {
+          // Stripe
+          var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+            apiVersion: apiVersion,
+            typescript: true
+          });
+          return stripeClient.customers.deleteSource(user.stripeCustomerId, card.stripeId).then(function () {
+            return true;
+          })["catch"](function (error) {
+            console.log('payments::deleteCard::error', error);
+            throw new _graphqlErrors.UserError('payment_error');
+          });
+        });
+      }
+
+      return false;
+    });
+  });
+};
+
+exports.deleteCreditCard = deleteCreditCard;
+
+var deleteBankAccount = function deleteBankAccount(context, bankId) {
+  var database = context.database,
+      sessionId = context.userId; // Clean db
+
+  var update = {
+    bankAccount: '',
+    bankFullName: '',
+    bankId: '',
+    bankRouting: '',
+    modified: Date.now()
+  };
+  var aqlQry = (0, _arangojs.aql)(_templateObject8(), sessionId, update);
+  return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var user = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var stripeAccountId = user.stripeAccountId; // Stripe
+
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    return stripeClient.customers.deleteSource(stripeAccountId, bankId).then(function () {
+      var response = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        deleted: false
+      };
+      return response.deleted;
+    })["catch"](function () {
+      return Promise.resolve(false);
+    });
+  });
+};
+
+exports.deleteBankAccount = deleteBankAccount;
+
+var createPaymentTransfer = function createPaymentTransfer(context, transfer) {
+  var database = context.database,
+      sessionId = context.userId;
+  var amount = transfer.amount,
+      currency = transfer.currency;
+  var formatAmount = (0, _utils.parseNum)(amount);
+  var formatCurrency = (0, _utils.parseChar)(currency, 3, 'USD').toUpperCase();
+  return (0, _users.getUser)(context, sessionId).then(function (user) {
+    var stripeAccountId = user.stripeAccountId; // Stripe
+
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    return stripeClient.transfers.create({
+      amount: formatAmount,
+      currency: formatCurrency,
+      destination: stripeAccountId
+    }).then(function (stripeTransfer) {
+      console.log(stripeTransfer);
+      var now = Date.now();
+      var insert = {
+        added: now,
+        amount: formatAmount,
+        currency: formatCurrency,
+        modified: now,
+        userId: sessionId
+      };
+      var aqlQry = (0, _arangojs.aql)(_templateObject9(), insert);
+      return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+        return cursor.next();
+      }).then(function (newTransfer) {
+        return newTransfer;
+      });
+    });
+  });
+};
+
+exports.createPaymentTransfer = createPaymentTransfer;
+
+var createPaymentHold = function createPaymentHold(context, payment) {
+  var database = context.database,
+      sessionId = context.userId;
+  var amount = payment.amount,
+      capture = payment.capture,
+      cardId = payment.cardId,
+      currency = payment.currency,
+      description = payment.description;
+  var formatCurrency = (0, _utils.parseChar)(currency, 3, 'USD').toUpperCase();
+  var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+    apiVersion: apiVersion,
+    typescript: true
+  });
+  return stripeClient.charges.create({
+    amount: amount,
+    capture: capture,
+    currency: formatCurrency,
+    description: description,
+    source: cardId
+  }).then(function (stripeCharge) {
+    var now = Date.now();
+    var insert = {
+      added: now,
+      amount: amount,
+      capture: capture,
+      cardId: cardId,
+      chargeFailCode: stripeCharge.failure_code,
+      chargeFailMsg: stripeCharge.failure_message,
+      chargeId: stripeCharge.id,
+      chargeStatus: stripeCharge.status,
+      currency: formatCurrency,
+      description: description,
+      modified: now,
+      userId: sessionId
+    };
+    var aqlQry = (0, _arangojs.aql)(_templateObject10(), insert);
+    return (0, _arangodb.useDb)(database).query(aqlQry).then(function (cursor) {
+      return cursor.next();
+    }).then(function (newPayment) {
+      return newPayment;
+    });
+  })["catch"](function (error) {
+    console.log('payments::createHold::error', error);
+    throw new _graphqlErrors.UserError('payment_error');
+  });
+};
+
+exports.createPaymentHold = createPaymentHold;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/payments.ts"],"names":["eventCategory","apiVersion","addCustomerAccount","context","action","database","sessionId","userId","username","stripeClient","Stripe","Config","get","typescript","customers","create","metadata","then","customer","now","Date","update","modified","stripeCustomerId","id","aqlQry","aql","query","cursor","next","updatedUser","error","category","label","addBankAccount","bankAccount","accountNumber","fullName","routing","formatAccount","UserError","formatFullName","formatRouting","user","stripeAccountId","source","account_holder_name","account_holder_type","account_number","country","currency","object","routing_number","createSource","account","bankId","last4","bankRouting","bankFullName","msg","message","addCreditCard","card","city","cvc","expMonth","expYear","street1","street2","state","zip","formatNumber","formatExpMonth","formatExpYear","formatCvc","paymentCard","formatCity","formatCountry","formatStreet1","formatStreet2","formatState","formatZip","address_city","address_country","address_line1","address_line2","address_state","address_zip","exp_month","exp_year","name","number","newSource","brand","cvcCheck","cvc_check","insert","_key","added","insertAqlQry","newCard","cardId","_id","cardKey","edgeCollection","collection","edgeId","edge","_from","_to","save","returnNew","updateCreditCard","formatId","results","updatedCard","stripeId","updateSource","console","log","getCreditCards","all","list","deleteCreditCard","formatCardId","result","outEdges","edges","length","Promise","map","edgeKey","removeAqlQry","deleteSource","deleteBankAccount","response","deleted","resolve","createPaymentTransfer","transfer","amount","formatAmount","formatCurrency","toUpperCase","transfers","destination","stripeTransfer","newTransfer","createPaymentHold","payment","capture","description","charges","stripeCharge","chargeFailCode","failure_code","chargeFailMsg","failure_message","chargeId","chargeStatus","status","newPayment"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;AACA;;AAIA;;AACA;;AACA;;AAEA;;AAEA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAMA,aAAqB,GAAG,UAA9B;AACA,IAAMC,UAAe,GAAG,YAAxB;;AAEO,IAAMC,kBAAkB,GAAG,SAArBA,kBAAqB,CAACC,OAAD,EAA2C;AAC3E,MAAMC,MAAc,GAAG,oBAAvB;AAD2E,MAEpEC,QAFoE,GAE3BF,OAF2B,CAEpEE,QAFoE;AAAA,MAElDC,SAFkD,GAE3BH,OAF2B,CAE1DI,MAF0D;AAAA,MAEvCC,QAFuC,GAE3BL,OAF2B,CAEvCK,QAFuC,EAI3E;;AACA,MAAMC,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,IAAAA,UAAU,EAAVA,UAAD;AAAaY,IAAAA,UAAU,EAAE;AAAzB,GAAvC,CAArB;AAEA,SAAOJ,YAAY,CAACK,SAAb,CACJC,MADI,CACG;AACNC,IAAAA,QAAQ,EAAE;AACRT,MAAAA,MAAM,EAAED,SADA;AAERE,MAAAA,QAAQ,EAARA;AAFQ;AADJ,GADH,EAOJS,IAPI,CAOC,UAACC,QAAD,EAAc;AAClB;AACA,QAAMC,GAAW,GAAGC,IAAI,CAACD,GAAL,EAApB;AACA,QAAME,MAAgB,GAAG;AACvBC,MAAAA,QAAQ,EAAEH,GADa;AAEvBI,MAAAA,gBAAgB,EAAEL,QAAQ,CAACM;AAFJ,KAAzB;AAKA,QAAMC,MAAgB,OAAGC,aAAH,qBAAgBpB,SAAhB,EAAkCe,MAAlC,CAAtB;AAEA,WAAO,qBAAMhB,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,aAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,KADD,EAEJZ,IAFI,CAEC;AAAA,UAACa,WAAD,uEAAyB,EAAzB;AAAA,aAAgC,CAAC,yBAAQA,WAAR,CAAjC;AAAA,KAFD,WAGE,UAACC,KAAD;AAAA,aAAkB,yBAAS;AAChC3B,QAAAA,MAAM,EAANA,MADgC;AAEhC4B,QAAAA,QAAQ,EAAEhC,aAFsB;AAGhCiC,QAAAA,KAAK,EAAE;AAHyB,OAAT,EAItBF,KAJsB,EAIf5B,OAJe,EAINc,IAJM,CAID;AAAA,eAAM,IAAN;AAAA,OAJC,CAAlB;AAAA,KAHF,CAAP;AAQD,GAzBI,CAAP;AA0BD,CAjCM;;;;AAmCA,IAAMiB,cAAc,GAAG,SAAjBA,cAAiB,CAAC/B,OAAD,EAAsBgC,WAAtB,EAA4E;AACxG,MAAM/B,MAAc,GAAG,uBAAvB;AADwG,MAEjGC,QAFiG,GAElEF,OAFkE,CAEjGE,QAFiG;AAAA,MAE/EC,SAF+E,GAElEH,OAFkE,CAEvFI,MAFuF,EAIxG;;AAJwG,MAMtG6B,aANsG,GASpGD,WAToG,CAMtGC,aANsG;AAAA,MAOtGC,QAPsG,GASpGF,WAToG,CAOtGE,QAPsG;AAAA,MAQtGC,OARsG,GASpGH,WAToG,CAQtGG,OARsG;AAWxG,MAAMC,aAAqB,GAAG,wBAAYH,aAAZ,EAA2B,EAA3B,CAA9B;;AAEA,MAAGG,aAAa,KAAK,EAArB,EAAyB;AACvB,UAAM,IAAIC,wBAAJ,CAAc,yBAAd,CAAN;AACD;;AAED,MAAMC,cAAsB,GAAG,yBAAaJ,QAAb,EAAuB,GAAvB,CAA/B;;AAEA,MAAGI,cAAc,KAAK,EAAtB,EAA0B;AACxB,UAAM,IAAID,wBAAJ,CAAc,oBAAd,CAAN;AACD;;AAED,MAAME,aAAqB,GAAG,wBAAYJ,OAAZ,EAAqB,EAArB,CAA9B;;AAEA,MAAGI,aAAa,KAAK,EAArB,EAAyB;AACvB,UAAM,IAAIF,wBAAJ,CAAc,yBAAd,CAAN;AACD;;AAED,SAAO,oBAAQrC,OAAR,EAAiBG,SAAjB,EACJW,IADI,CACC,UAAC0B,IAAD,EAAoB;AAAA,QACjBC,eADiB,GACYD,IADZ,CACjBC,eADiB,EAGxB;;AACA,QAAMnC,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,MAAAA,UAAU,EAAVA,UAAD;AAAaY,MAAAA,UAAU,EAAE;AAAzB,KAAvC,CAArB;AACA,QAAMgC,MAAW,GAAG;AAClBC,MAAAA,mBAAmB,EAAEL,cADH;AAElBM,MAAAA,mBAAmB,EAAE,YAFH;AAGlBC,MAAAA,cAAc,EAAET,aAHE;AAIlBU,MAAAA,OAAO,EAAE,IAJS;AAKlBC,MAAAA,QAAQ,EAAE,KALQ;AAMlBC,MAAAA,MAAM,EAAE,cANU;AAOlBC,MAAAA,cAAc,EAAEV;AAPE,KAApB;AAUA,WAAOjC,YAAY,CAACK,SAAb,CACJuC,YADI,CACST,eADT,EAC0B;AAACC,MAAAA,MAAM,EAANA;AAAD,KAD1B,EAEJ5B,IAFI,CAEC,UAACqC,OAAD,EAAkB;AAAA,UACXC,MADW,GACgDD,OADhD,CACf9B,EADe;AAAA,UACIW,WADJ,GACgDmB,OADhD,CACHE,KADG;AAAA,UACiCC,WADjC,GACgDH,OADhD,CACiBF,cADjB;AAEtB,UAAM/B,MAAW,GAAG;AAClBc,QAAAA,WAAW,EAAXA,WADkB;AAElBuB,QAAAA,YAAY,EAAEjB,cAFI;AAGlBc,QAAAA,MAAM,EAANA,MAHkB;AAIlBE,QAAAA,WAAW,EAAXA,WAJkB;AAKlBnC,QAAAA,QAAQ,EAAEF,IAAI,CAACD,GAAL;AALQ,OAApB;AAQA,UAAMM,MAAgB,OAAGC,aAAH,sBAAgBpB,SAAhB,EAAkCe,MAAlC,CAAtB;AAEA,aAAO,qBAAMhB,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,eAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,OADD,EAEJZ,IAFI,CAEC;AAAA,YAACa,WAAD,uEAAyB,EAAzB;AAAA,eAAgCA,WAAhC;AAAA,OAFD,CAAP;AAGD,KAjBI,WAkBE,UAACC,KAAD,EAAkB;AACvB,UAAM4B,GAAG,GAAG5B,KAAK,CAAC6B,OAAlB;;AAEA,UAAGD,GAAG,KAAK,gEACT,mCADF,EACuC;AACrC,eAAO,yBAAS;AACdvD,UAAAA,MAAM,EAANA,MADc;AAEd4B,UAAAA,QAAQ,EAAEhC,aAFI;AAGdiC,UAAAA,KAAK,EAAE;AAHO,SAAT,EAIJF,KAJI,EAIG5B,OAJH,EAIYc,IAJZ,CAIiB;AAAA,iBAAM,IAAN;AAAA,SAJjB,CAAP;AAKD;;AACD,aAAO,yBAAS;AACdb,QAAAA,MAAM,EAANA,MADc;AAEd4B,QAAAA,QAAQ,EAAEhC,aAFI;AAGdiC,QAAAA,KAAK,EAAE;AAHO,OAAT,EAIJF,KAJI,EAIG5B,OAJH,EAIYc,IAJZ,CAIiB;AAAA,eAAM,IAAN;AAAA,OAJjB,CAAP;AAKD,KAlCI,CAAP;AAmCD,GAnDI,CAAP;AAoDD,CAjFM;;;;AAmFA,IAAM4C,aAAa,GAAG,SAAhBA,aAAgB,CAAC1D,OAAD,EAAsB2D,IAAtB,EAAmE;AAC9F,MAAM1D,MAAc,GAAG,eAAvB;AAD8F,MAEvFC,QAFuF,GAExDF,OAFwD,CAEvFE,QAFuF;AAAA,MAErEC,SAFqE,GAExDH,OAFwD,CAE7EI,MAF6E;AAI9F,SAAO,oBAAQJ,OAAR,EAAiBG,SAAjB,EACJW,IADI,CACC,UAAC0B,IAAD,EAAoB;AACxB;AADwB,QAEjBC,eAFiB,GAEYD,IAFZ,CAEjBC,eAFiB,EAIxB;;AAJwB,QAMtBR,aANsB,GAiBH0B,IAjBG,CAMtB1B,aANsB;AAAA,QAOtB2B,IAPsB,GAiBHD,IAjBG,CAOtBC,IAPsB;AAAA,QAQtBd,OARsB,GAiBHa,IAjBG,CAQtBb,OARsB;AAAA,QAStBe,GATsB,GAiBHF,IAjBG,CAStBE,GATsB;AAAA,QAUtBC,QAVsB,GAiBHH,IAjBG,CAUtBG,QAVsB;AAAA,QAWtBC,OAXsB,GAiBHJ,IAjBG,CAWtBI,OAXsB;AAAA,QAYtB7B,QAZsB,GAiBHyB,IAjBG,CAYtBzB,QAZsB;AAAA,QAatB8B,OAbsB,GAiBHL,IAjBG,CAatBK,OAbsB;AAAA,QActBC,OAdsB,GAiBHN,IAjBG,CActBM,OAdsB;AAAA,QAetBC,KAfsB,GAiBHP,IAjBG,CAetBO,KAfsB;AAAA,QAgBtBC,GAhBsB,GAiBHR,IAjBG,CAgBtBQ,GAhBsB;AAmBxB,QAAMC,YAAoB,GAAG,qBAASnC,aAAT,EAAwB,EAAxB,CAA7B;;AAEA,QAAG,CAACmC,YAAJ,EAAkB;AAChB,YAAM,IAAI/B,wBAAJ,CAAc,6BAAd,CAAN;AACD;;AAED,QAAMgC,cAAsB,GAAG,qBAASP,QAAT,EAAmB,CAAnB,CAA/B;;AAEA,QAAG,CAACO,cAAJ,EAAoB;AAClB,YAAM,IAAIhC,wBAAJ,CAAc,gCAAd,CAAN;AACD;;AAED,QAAMiC,aAAqB,GAAG,qBAASP,OAAT,EAAkB,CAAlB,CAA9B;;AAEA,QAAG,CAACO,aAAJ,EAAmB;AACjB,YAAM,IAAIjC,wBAAJ,CAAc,+BAAd,CAAN;AACD;;AAED,QAAMkC,SAAiB,GAAG,qBAASV,GAAT,EAAc,CAAd,CAA1B,CArCwB,CAuCxB;;AACA,QAAMW,WAA4B,GAAG,EAArC;AACA,QAAMC,UAAkB,GAAG,yBAAab,IAAb,EAAmB,EAAnB,CAA3B;;AAEA,QAAGa,UAAH,EAAe;AACbD,MAAAA,WAAW,CAACZ,IAAZ,GAAmBa,UAAnB;AACD;;AAED,QAAMC,aAAqB,GAAG,sBAAU5B,OAAV,EAAmB,CAAnB,CAA9B;;AAEA,QAAG4B,aAAH,EAAkB;AAChBF,MAAAA,WAAW,CAAC1B,OAAZ,GAAsB4B,aAAtB;AACD;;AAED,QAAMpC,cAAsB,GAAG,yBAAaJ,QAAb,EAAuB,EAAvB,CAA/B;;AAEA,QAAGI,cAAH,EAAmB;AACjBkC,MAAAA,WAAW,CAACtC,QAAZ,GAAuBI,cAAvB;AACD;;AAED,QAAMqC,aAAqB,GAAG,yBAAaX,OAAb,EAAsB,EAAtB,CAA9B;;AAEA,QAAGW,aAAH,EAAkB;AAChBH,MAAAA,WAAW,CAACR,OAAZ,GAAsBW,aAAtB;AACD;;AAED,QAAMC,aAAqB,GAAG,yBAAaX,OAAb,EAAsB,EAAtB,CAA9B;;AAEA,QAAGW,aAAH,EAAkB;AAChBJ,MAAAA,WAAW,CAACP,OAAZ,GAAsBW,aAAtB;AACD;;AAED,QAAMC,WAAmB,GAAG,sBAAUX,KAAV,EAAiB,CAAjB,CAA5B;;AAEA,QAAGW,WAAH,EAAgB;AACdL,MAAAA,WAAW,CAACN,KAAZ,GAAoBW,WAApB;AACD;;AAED,QAAMC,SAAiB,GAAG,yBAAaX,GAAb,EAAkB,EAAlB,CAA1B;;AAEA,QAAGW,SAAH,EAAc;AACZN,MAAAA,WAAW,CAACL,GAAZ,GAAkBW,SAAlB;AACD,KAjFuB,CAmFxB;;;AACA,QAAMxE,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,MAAAA,UAAU,EAAVA,UAAD;AAAaY,MAAAA,UAAU,EAAE;AAAzB,KAAvC,CAArB;AACA,QAAMgC,MAAW,GAAG;AAClBqC,MAAAA,YAAY,EAAEN,UADI;AAElBO,MAAAA,eAAe,EAAEN,aAFC;AAGlBO,MAAAA,aAAa,EAAEN,aAHG;AAIlBO,MAAAA,aAAa,EAAEN,aAJG;AAKlBO,MAAAA,aAAa,EAAEN,WALG;AAMlBO,MAAAA,WAAW,EAAEN,SANK;AAOlBjB,MAAAA,GAAG,EAAEU,SAPa;AAQlBc,MAAAA,SAAS,EAAEhB,cARO;AASlBiB,MAAAA,QAAQ,EAAEhB,aATQ;AAUlBiB,MAAAA,IAAI,EAAErD,QAVY;AAWlBsD,MAAAA,MAAM,EAAEpB,YAXU;AAYlBpB,MAAAA,MAAM,EAAE;AAZU,KAApB;AAeA,WAAO1C,YAAY,CAACK,SAAb,CACJuC,YADI,CACST,eADT,EAC0B;AAACC,MAAAA,MAAM,EAANA;AAAD,KAD1B,EAEJ5B,IAFI,CAEC,UAAC2E,SAAD,EAAoB;AAAA,UACjBC,KADiB,GACoBD,SADpB,CACjBC,KADiB;AAAA,UACCC,QADD,GACoBF,SADpB,CACVG,SADU;AAAA,UACWvC,KADX,GACoBoC,SADpB,CACWpC,KADX,EAGxB;;AACA,UAAMrC,GAAW,GAAGC,IAAI,CAACD,GAAL,EAApB;;AACA,UAAM6E,MAAM,mCACPrB,WADO;AAEVsB,QAAAA,IAAI,EAAE,8CAA2B3F,SAA3B,EAFI;AAGV8B,QAAAA,aAAa,EAAEoB,KAHL;AAIV0C,QAAAA,KAAK,EAAE/E,GAJG;AAKV0E,QAAAA,KAAK,EAALA,KALU;AAMVC,QAAAA,QAAQ,EAARA,QANU;AAOV7B,QAAAA,QAAQ,EAARA,QAPU;AAQVC,QAAAA,OAAO,EAAPA,OARU;AASV5C,QAAAA,QAAQ,EAAEH,GATA;AAUVZ,QAAAA,MAAM,EAAED;AAVE,QAAZ;;AAYA,UAAM6F,YAAsB,OAAGzE,aAAH,sBAAgBsE,MAAhB,CAA5B;AAEA,aAAO,qBAAM3F,QAAN,EAAgBsB,KAAhB,CAAsBwE,YAAtB,EACJlF,IADI,CACC,UAACW,MAAD;AAAA,eAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,OADD,EAEJZ,IAFI,CAEC,YAAmC;AAAA,YAAlCmF,OAAkC,uEAAP,EAAO;;AACvC,YAAG,CAAC,yBAAQA,OAAR,CAAJ,EAAsB;AACpB;AADoB,cAERC,MAFQ,GAEiBvC,IAFjB,CAEbwC,GAFa;AAAA,cAEMC,OAFN,GAEiBzC,IAFjB,CAEAmC,IAFA;AAGpB,cAAMO,cAA8B,GAAG,qBAAMnG,QAAN,EAAgBoG,UAAhB,CAA2B,YAA3B,CAAvC;AACA,cAAMC,MAAM,GAAG,yCAAsBH,OAAtB,EAAf;AACA,cAAMI,IAAS,GAAG;AAChBC,YAAAA,KAAK,kBAAWtG,SAAX,CADW;AAEhB2F,YAAAA,IAAI,EAAES,MAFU;AAGhBG,YAAAA,GAAG,EAAER;AAHW,WAAlB;AAMA,iBAAOG,cAAc,CAACM,IAAf,CAAoBH,IAApB,EAA0B;AAACI,YAAAA,SAAS,EAAE;AAAZ,WAA1B,EAA6C9F,IAA7C,CAAkD;AAAA,mBAAM6C,IAAN;AAAA,WAAlD,CAAP;AACD;;AAED,eAAOsC,OAAP;AACD,OAlBI,WAmBE,UAACrE,KAAD;AAAA,eAAkB,yBAAS;AAChC3B,UAAAA,MAAM,EAANA,MADgC;AAEhC4B,UAAAA,QAAQ,EAAEhC,aAFsB;AAGhCiC,UAAAA,KAAK,EAAE;AAHyB,SAAT,EAItBF,KAJsB,EAIf5B,OAJe,EAINc,IAJM,CAID;AAAA,iBAAM,IAAN;AAAA,SAJC,CAAlB;AAAA,OAnBF,CAAP;AAwBD,KA7CI,CAAP;AA8CD,GAnJI,CAAP;AAoJD,CAxJM;;;;AA0JA,IAAM+F,gBAAgB,GAAG,SAAnBA,gBAAmB,CAAC7G,OAAD,EAAsB2D,IAAtB,EAA0E;AAAA,MACjGzD,QADiG,GAClEF,OADkE,CACjGE,QADiG;AAAA,MAC/EC,SAD+E,GAClEH,OADkE,CACvFI,MADuF;AAAA,MAItGwD,IAJsG,GAanFD,IAbmF,CAItGC,IAJsG;AAAA,MAKtGd,OALsG,GAanFa,IAbmF,CAKtGb,OALsG;AAAA,MAMtGgB,QANsG,GAanFH,IAbmF,CAMtGG,QANsG;AAAA,MAOtGC,OAPsG,GAanFJ,IAbmF,CAOtGI,OAPsG;AAAA,MAQtG7B,QARsG,GAanFyB,IAbmF,CAQtGzB,QARsG;AAAA,MAStGb,EATsG,GAanFsC,IAbmF,CAStGtC,EATsG;AAAA,MAUtG2C,OAVsG,GAanFL,IAbmF,CAUtGK,OAVsG;AAAA,MAWtGE,KAXsG,GAanFP,IAbmF,CAWtGO,KAXsG;AAAA,MAYtGC,GAZsG,GAanFR,IAbmF,CAYtGQ,GAZsG;AAexG,MAAM2C,QAAgB,GAAG,oBAAQzF,EAAR,CAAzB;;AAEA,MAAGyF,QAAH,EAAa;AACX,UAAM,IAAIzE,wBAAJ,CAAc,yBAAd,CAAN;AACD;;AAED,MAAMmC,WAA4B,GAAG,EAArC;AACA,MAAMH,cAAsB,GAAG,qBAASP,QAAT,EAAmB,CAAnB,CAA/B;AACA,MAAMQ,aAAqB,GAAG,qBAASP,OAAT,EAAkB,CAAlB,CAA9B;AACA,MAAMU,UAAkB,GAAG,yBAAab,IAAb,EAAmB,EAAnB,CAA3B;AACA,MAAMc,aAAqB,GAAG,sBAAU5B,OAAV,EAAmB,CAAnB,CAA9B;AACA,MAAMR,cAAsB,GAAG,yBAAaJ,QAAb,EAAuB,EAAvB,CAA/B;AACA,MAAMyC,aAAqB,GAAG,wBAAYX,OAAZ,EAAqB,EAArB,CAA9B;AACA,MAAMa,WAAmB,GAAG,sBAAUX,KAAV,EAAiB,CAAjB,CAA5B;AACA,MAAMY,SAAiB,GAAG,yBAAaX,GAAb,EAAkB,EAAlB,CAA1B;;AAEA,MAAGE,cAAH,EAAmB;AACjBG,IAAAA,WAAW,CAACV,QAAZ,GAAuBO,cAAvB;AACD;;AAED,MAAGC,aAAH,EAAkB;AAChBE,IAAAA,WAAW,CAACT,OAAZ,GAAsBO,aAAtB;AACD;;AAED,MAAGG,UAAH,EAAe;AACbD,IAAAA,WAAW,CAACZ,IAAZ,GAAmBa,UAAnB;AACD;;AAED,MAAGC,aAAH,EAAkB;AAChBF,IAAAA,WAAW,CAAC1B,OAAZ,GAAsB4B,aAAtB;AACD;;AAED,MAAGpC,cAAH,EAAmB;AACjBkC,IAAAA,WAAW,CAACtC,QAAZ,GAAuBI,cAAvB;AACD;;AAED,MAAGqC,aAAH,EAAkB;AAChBH,IAAAA,WAAW,CAACR,OAAZ,GAAsBW,aAAtB;AACD;;AAED,MAAGE,WAAH,EAAgB;AACdL,IAAAA,WAAW,CAACN,KAAZ,GAAoBW,WAApB;AACD;;AAED,MAAGC,SAAH,EAAc;AACZN,IAAAA,WAAW,CAACL,GAAZ,GAAkBW,SAAlB;AACD;;AAED,MAAM5D,MAAW,GAAGsD,WAApB;AACA,MAAMlD,MAAgB,OAAGC,aAAH,sBAGGuF,QAHH,EAG8B3G,SAH9B,EAIAe,MAJA,EAUGf,SAVH,CAAtB;AAgBA,SAAO,qBAAMD,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,WAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,GADD,EAEJZ,IAFI,CAEC,YAAoC;AAAA,QAAnCiG,OAAmC,uEAAzB;AAACpD,MAAAA,IAAI,EAAE,EAAP;AAAWnB,MAAAA,IAAI,EAAE;AAAjB,KAAyB;AACxC,QAAMwE,WAA4B,GAAGD,OAAO,CAACpD,IAA7C;AADwC,QAEjCnB,IAFiC,GAEzBuE,OAFyB,CAEjCvE,IAFiC;;AAIxC,QAAG,yBAAQwE,WAAR,CAAH,EAAyB;AACvB,YAAM,IAAI3E,wBAAJ,CAAc,WAAd,CAAN;AACD;;AANuC,QAQjCjB,gBARiC,GAQboB,IARa,CAQjCpB,gBARiC;AAAA,QASjC6F,QATiC,GASrBtD,IATqB,CASjCsD,QATiC,EAWxC;;AACA,QAAM3G,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,MAAAA,UAAU,EAAVA,UAAD;AAAaY,MAAAA,UAAU,EAAE;AAAzB,KAAvC,CAArB;AACA,QAAMQ,MAAW,GAAG;AAClB6D,MAAAA,YAAY,EAAEN,UADI;AAElBO,MAAAA,eAAe,EAAEN,aAFC;AAGlBO,MAAAA,aAAa,EAAEN,aAHG;AAIlBQ,MAAAA,aAAa,EAAEN,WAJG;AAKlBO,MAAAA,WAAW,EAAEN,SALK;AAMlBO,MAAAA,SAAS,EAAEhB,cANO;AAOlBiB,MAAAA,QAAQ,EAAEhB,aAPQ;AAQlBiB,MAAAA,IAAI,EAAEjD;AARY,KAApB;AAWA,WAAOhC,YAAY,CAACK,SAAb,CACJuG,YADI,CACS9F,gBADT,EAC2B6F,QAD3B,EACqC/F,MADrC,EAEJJ,IAFI,CAEC;AAAA,aAAM6C,IAAN;AAAA,KAFD,WAGE,UAAC/B,KAAD,EAAkB;AACvBuF,MAAAA,OAAO,CAACC,GAAR,CAAY,6BAAZ,EAA2CxF,KAA3C;AACA,YAAM,IAAIS,wBAAJ,CAAc,eAAd,CAAN;AACD,KANI,CAAP;AAOD,GAjCI,CAAP;AAkCD,CAlHM;;;;AAoHA,IAAMgF,cAAc,GAAG,SAAjBA,cAAiB,CAACrH,OAAD,EAAqD;AACjF,MAAMC,MAAc,GAAG,gBAAvB;AADiF,MAE1EC,QAF0E,GAE3CF,OAF2C,CAE1EE,QAF0E;AAAA,MAExDC,SAFwD,GAE3CH,OAF2C,CAEhEI,MAFgE;AAGjF,MAAMkB,MAAgB,OAAGC,aAAH,sBACCpB,SADD,CAAtB;AAIA,SAAO,qBAAMD,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,WAAyBA,MAAM,CAAC6F,GAAP,EAAzB;AAAA,GADD,EAEJxG,IAFI,CAEC;AAAA,QAACyG,IAAD,uEAA2B,EAA3B;AAAA,WAAkCA,IAAlC;AAAA,GAFD,WAGE,UAAC3F,KAAD;AAAA,WAAkB,yBAAS;AAChC3B,MAAAA,MAAM,EAANA,MADgC;AAEhC4B,MAAAA,QAAQ,EAAEhC,aAFsB;AAGhCiC,MAAAA,KAAK,EAAE;AAHyB,KAAT,EAItBF,KAJsB,EAIf5B,OAJe,EAINc,IAJM,CAID;AAAA,aAAM,IAAN;AAAA,KAJC,CAAlB;AAAA,GAHF,CAAP;AAQD,CAfM;;;;AAiBA,IAAM0G,gBAAgB,GAAG,SAAnBA,gBAAmB,CAACxH,OAAD,EAAsBkG,MAAtB,EAA2D;AAAA,MAClFhG,QADkF,GACnDF,OADmD,CAClFE,QADkF;AAAA,MAChEC,SADgE,GACnDH,OADmD,CACxEI,MADwE;AAEzF,MAAMqH,YAAoB,GAAG,oBAAQvB,MAAR,CAA7B;AACA,MAAM5E,MAAgB,OAAGC,aAAH,sBAGCkG,YAHD,EAGgCtH,SAHhC,EAUCA,SAVD,CAAtB;AAgBA,SAAO,qBAAMD,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,WAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,GADD,EAEJZ,IAFI,CAEC,YAAmC;AAAA,QAAlC4G,MAAkC,uEAAzB;AAAC/D,MAAAA,IAAI,EAAE,EAAP;AAAWnB,MAAAA,IAAI,EAAE;AAAjB,KAAyB;;AACvC,QAAG,yBAAQkF,MAAR,CAAH,EAAoB;AAClB,aAAO,KAAP;AACD;;AAHsC,QAKhC/D,IALgC,GAKlB+D,MALkB,CAKhC/D,IALgC;AAAA,QAK1BnB,IAL0B,GAKlBkF,MALkB,CAK1BlF,IAL0B;AAAA,QAM1B4D,OAN0B,GAMfzC,IANe,CAMhCmC,IANgC,EAQvC;;AACA,QAAMO,cAAc,GAAG,qBAAMnG,QAAN,EAAgBoG,UAAhB,CAA2B,YAA3B,CAAvB;AAEA,WAAOD,cAAc,CAACsB,QAAf,CAAwBvB,OAAxB,EACJtF,IADI,CACC,UAAC8G,KAAD,EAAgB;AACpB,UAAGA,KAAK,CAACC,MAAT,EAAiB;AACf,eAAOC,OAAO,CAACR,GAAR,CACLM,KAAK,CAACG,GAAN,CAAU,UAACvB,IAAD,EAAU;AAAA,cACLwB,OADK,GACMxB,IADN,CACXV,IADW;AAElB,cAAMmC,YAAsB,OAAG1G,aAAH,sBAAsByG,OAAtB,CAA5B;AACA,iBAAO,qBAAM9H,QAAN,EAAgBsB,KAAhB,CAAsByG,YAAtB,CAAP;AACD,SAJD,CADK,EAMJnH,IANI,CAMC,YAAM;AACV;AACA,cAAMR,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,YAAAA,UAAU,EAAVA,UAAD;AAAaY,YAAAA,UAAU,EAAE;AAAzB,WAAvC,CAArB;AAEA,iBAAOJ,YAAY,CAACK,SAAb,CACJuH,YADI,CACS1F,IAAI,CAACpB,gBADd,EACgCuC,IAAI,CAACsD,QADrC,EAEJnG,IAFI,CAEC;AAAA,mBAAM,IAAN;AAAA,WAFD,WAGE,UAACc,KAAD,EAAkB;AACvBuF,YAAAA,OAAO,CAACC,GAAR,CAAY,6BAAZ,EAA2CxF,KAA3C;AACA,kBAAM,IAAIS,wBAAJ,CAAc,eAAd,CAAN;AACD,WANI,CAAP;AAOD,SAjBI,CAAP;AAkBD;;AAED,aAAO,KAAP;AACD,KAxBI,CAAP;AAyBD,GAtCI,CAAP;AAuCD,CA1DM;;;;AA4DA,IAAM8F,iBAAiB,GAAG,SAApBA,iBAAoB,CAACnI,OAAD,EAAsBoD,MAAtB,EAA2D;AAAA,MACnFlD,QADmF,GACpDF,OADoD,CACnFE,QADmF;AAAA,MACjEC,SADiE,GACpDH,OADoD,CACzEI,MADyE,EAG1F;;AACA,MAAMc,MAAgB,GAAG;AACvBc,IAAAA,WAAW,EAAE,EADU;AAEvBuB,IAAAA,YAAY,EAAE,EAFS;AAGvBH,IAAAA,MAAM,EAAE,EAHe;AAIvBE,IAAAA,WAAW,EAAE,EAJU;AAKvBnC,IAAAA,QAAQ,EAAEF,IAAI,CAACD,GAAL;AALa,GAAzB;AAOA,MAAMM,MAAgB,OAAGC,aAAH,sBAAgBpB,SAAhB,EAAkCe,MAAlC,CAAtB;AAEA,SAAO,qBAAMhB,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,WAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,GADD,EAEJZ,IAFI,CAEC,YAAyB;AAAA,QAAxB0B,IAAwB,uEAAP,EAAO;AAAA,QACtBC,eADsB,GACHD,IADG,CACtBC,eADsB,EAG7B;;AACA,QAAMnC,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,MAAAA,UAAU,EAAVA,UAAD;AAAaY,MAAAA,UAAU,EAAE;AAAzB,KAAvC,CAArB;AAEA,WAAOJ,YAAY,CAACK,SAAb,CACJuH,YADI,CACSzF,eADT,EAC0BW,MAD1B,EAEJtC,IAFI,CAEC;AAAA,UAACsH,QAAD,uEAAiB;AAACC,QAAAA,OAAO,EAAE;AAAV,OAAjB;AAAA,aAAsCD,QAAQ,CAACC,OAA/C;AAAA,KAFD,WAGE;AAAA,aAAMP,OAAO,CAACQ,OAAR,CAAgB,KAAhB,CAAN;AAAA,KAHF,CAAP;AAID,GAZI,CAAP;AAaD,CA1BM;;;;AA4BA,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAwB,CAACvI,OAAD,EAAsBwI,QAAtB,EAA8E;AAAA,MAC1GtI,QAD0G,GAC3EF,OAD2E,CAC1GE,QAD0G;AAAA,MACxFC,SADwF,GAC3EH,OAD2E,CAChGI,MADgG;AAAA,MAE1GqI,MAF0G,GAEtFD,QAFsF,CAE1GC,MAF0G;AAAA,MAElG1F,QAFkG,GAEtFyF,QAFsF,CAElGzF,QAFkG;AAGjH,MAAM2F,YAAoB,GAAG,qBAASD,MAAT,CAA7B;AACA,MAAME,cAAsB,GAAG,sBAAU5F,QAAV,EAAoB,CAApB,EAAuB,KAAvB,EAA8B6F,WAA9B,EAA/B;AAEA,SAAO,oBAAQ5I,OAAR,EAAiBG,SAAjB,EACJW,IADI,CACC,UAAC0B,IAAD,EAAoB;AAAA,QACjBC,eADiB,GACED,IADF,CACjBC,eADiB,EAGxB;;AACA,QAAMnC,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,MAAAA,UAAU,EAAVA,UAAD;AAAaY,MAAAA,UAAU,EAAE;AAAzB,KAAvC,CAArB;AAEA,WAAOJ,YAAY,CAACuI,SAAb,CACJjI,MADI,CACG;AACN6H,MAAAA,MAAM,EAAEC,YADF;AAEN3F,MAAAA,QAAQ,EAAE4F,cAFJ;AAGNG,MAAAA,WAAW,EAAErG;AAHP,KADH,EAMJ3B,IANI,CAMC,UAACiI,cAAD,EAAoB;AACxB5B,MAAAA,OAAO,CAACC,GAAR,CAAY2B,cAAZ;AACA,UAAM/H,GAAW,GAAGC,IAAI,CAACD,GAAL,EAApB;AACA,UAAM6E,MAAuB,GAAG;AAC9BE,QAAAA,KAAK,EAAE/E,GADuB;AAE9ByH,QAAAA,MAAM,EAAEC,YAFsB;AAG9B3F,QAAAA,QAAQ,EAAE4F,cAHoB;AAI9BxH,QAAAA,QAAQ,EAAEH,GAJoB;AAK9BZ,QAAAA,MAAM,EAAED;AALsB,OAAhC;AAOA,UAAMmB,MAAgB,OAAGC,aAAH,sBAAgBsE,MAAhB,CAAtB;AAEA,aAAO,qBAAM3F,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,eAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,OADD,EAEJZ,IAFI,CAEC,UAACkI,WAAD;AAAA,eAAkCA,WAAlC;AAAA,OAFD,CAAP;AAGD,KArBI,CAAP;AAsBD,GA7BI,CAAP;AA8BD,CApCM;;;;AAsCA,IAAMC,iBAAiB,GAAG,SAApBA,iBAAoB,CAACjJ,OAAD,EAAsBkJ,OAAtB,EAAyE;AAAA,MACjGhJ,QADiG,GAClEF,OADkE,CACjGE,QADiG;AAAA,MAC/EC,SAD+E,GAClEH,OADkE,CACvFI,MADuF;AAAA,MAEjGqI,MAFiG,GAE/CS,OAF+C,CAEjGT,MAFiG;AAAA,MAEzFU,OAFyF,GAE/CD,OAF+C,CAEzFC,OAFyF;AAAA,MAEhFjD,MAFgF,GAE/CgD,OAF+C,CAEhFhD,MAFgF;AAAA,MAExEnD,QAFwE,GAE/CmG,OAF+C,CAExEnG,QAFwE;AAAA,MAE9DqG,WAF8D,GAE/CF,OAF+C,CAE9DE,WAF8D;AAGxG,MAAMT,cAAc,GAAG,sBAAU5F,QAAV,EAAoB,CAApB,EAAuB,KAAvB,EAA8B6F,WAA9B,EAAvB;AAEA,MAAMtI,YAAY,GAAG,IAAIC,kBAAJ,CAAWC,eAAOC,GAAP,CAAW,cAAX,CAAX,EAAuC;AAACX,IAAAA,UAAU,EAAVA,UAAD;AAAaY,IAAAA,UAAU,EAAE;AAAzB,GAAvC,CAArB;AAEA,SAAOJ,YAAY,CAAC+I,OAAb,CACJzI,MADI,CACG;AACN6H,IAAAA,MAAM,EAANA,MADM;AAENU,IAAAA,OAAO,EAAPA,OAFM;AAGNpG,IAAAA,QAAQ,EAAE4F,cAHJ;AAINS,IAAAA,WAAW,EAAXA,WAJM;AAKN1G,IAAAA,MAAM,EAAEwD;AALF,GADH,EAQJpF,IARI,CAQC,UAACwI,YAAD,EAAkB;AACtB,QAAMtI,GAAW,GAAGC,IAAI,CAACD,GAAL,EAApB;AACA,QAAM6E,MAAqB,GAAG;AAC5BE,MAAAA,KAAK,EAAE/E,GADqB;AAE5ByH,MAAAA,MAAM,EAANA,MAF4B;AAG5BU,MAAAA,OAAO,EAAPA,OAH4B;AAI5BjD,MAAAA,MAAM,EAANA,MAJ4B;AAK5BqD,MAAAA,cAAc,EAAED,YAAY,CAACE,YALD;AAM5BC,MAAAA,aAAa,EAAEH,YAAY,CAACI,eANA;AAO5BC,MAAAA,QAAQ,EAAEL,YAAY,CAACjI,EAPK;AAQ5BuI,MAAAA,YAAY,EAAEN,YAAY,CAACO,MARC;AAS5B9G,MAAAA,QAAQ,EAAE4F,cATkB;AAU5BS,MAAAA,WAAW,EAAXA,WAV4B;AAW5BjI,MAAAA,QAAQ,EAAEH,GAXkB;AAY5BZ,MAAAA,MAAM,EAAED;AAZoB,KAA9B;AAcA,QAAMmB,MAAgB,OAAGC,aAAH,uBAAgBsE,MAAhB,CAAtB;AAEA,WAAO,qBAAM3F,QAAN,EAAgBsB,KAAhB,CAAsBF,MAAtB,EACJR,IADI,CACC,UAACW,MAAD;AAAA,aAAyBA,MAAM,CAACC,IAAP,EAAzB;AAAA,KADD,EAEJZ,IAFI,CAEC,UAACgJ,UAAD;AAAA,aAA+BA,UAA/B;AAAA,KAFD,CAAP;AAGD,GA7BI,WA8BE,UAAClI,KAAD,EAAkB;AACvBuF,IAAAA,OAAO,CAACC,GAAR,CAAY,6BAAZ,EAA2CxF,KAA3C;AACA,UAAM,IAAIS,wBAAJ,CAAc,eAAd,CAAN;AACD,GAjCI,CAAP;AAkCD,CAzCM","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseChar, parseId, parseNum, parseString, parseVarChar} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {UserError} from 'graphql-errors';\nimport isEmpty from 'lodash/isEmpty';\nimport Stripe from 'stripe';\n\nimport {Config} from '../config';\nimport {ApiContext, PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer, UserType} from '../types';\nimport {logError} from '../utils/analytics';\nimport {useDb} from '../utils/arangodb';\nimport {getUser} from './users';\n\nconst eventCategory: string = 'payments';\nconst apiVersion: any = '2020-03-02';\n\nexport const addCustomerAccount = (context: ApiContext): Promise<boolean> => {\n  const action: string = 'addCustomerAccount';\n  const {database, userId: sessionId, username} = context;\n\n  // Stripe\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n  return stripeClient.customers\n    .create({\n      metadata: {\n        userId: sessionId,\n        username\n      }\n    })\n    .then((customer) => {\n      // Create session\n      const now: number = Date.now();\n      const update: UserType = {\n        modified: now,\n        stripeCustomerId: customer.id\n      };\n\n      const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n      return useDb(database).query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then((updatedUser: UserType = {}) => !isEmpty(updatedUser))\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          label: 'db_error'\n        }, error, context).then(() => null));\n    });\n};\n\nexport const addBankAccount = (context: ApiContext, bankAccount: PaymentBankAccount): Promise<boolean> => {\n  const action: string = 'addPaymentAccountBank';\n  const {database, userId: sessionId} = context;\n\n  // Params\n  const {\n    accountNumber,\n    fullName,\n    routing\n  } = bankAccount;\n\n  const formatAccount: string = parseString(accountNumber, 32);\n\n  if(formatAccount === '') {\n    throw new UserError('required_account_number');\n  }\n\n  const formatFullName: string = parseVarChar(fullName, 128);\n\n  if(formatFullName === '') {\n    throw new UserError('required_full_name');\n  }\n\n  const formatRouting: string = parseString(routing, 32);\n\n  if(formatRouting === '') {\n    throw new UserError('required_routing_number');\n  }\n\n  return getUser(context, sessionId)\n    .then((user: UserType) => {\n      const {stripeAccountId}: UserType = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const source: any = {\n        account_holder_name: formatFullName,\n        account_holder_type: 'individual',\n        account_number: formatAccount,\n        country: 'US',\n        currency: 'USD',\n        object: 'bank_account',\n        routing_number: formatRouting\n      };\n\n      return stripeClient.customers\n        .createSource(stripeAccountId, {source})\n        .then((account: any) => {\n          const {id: bankId, last4: bankAccount, routing_number: bankRouting} = account;\n          const update: any = {\n            bankAccount,\n            bankFullName: formatFullName,\n            bankId,\n            bankRouting,\n            modified: Date.now()\n          };\n\n          const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n          return useDb(database).query(aqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((updatedUser: UserType = {}) => updatedUser);\n        })\n        .catch((error: Error) => {\n          const msg = error.message;\n\n          if(msg === 'A bank account with that routing number and account number ' +\n            'already exists for this customer.') {\n            return logError({\n              action,\n              category: eventCategory,\n              label: 'bank_account_exists'\n            }, error, context).then(() => null);\n          }\n          return logError({\n            action,\n            category: eventCategory,\n            label: 'payment_error'\n          }, error, context).then(() => null);\n        });\n    });\n};\n\nexport const addCreditCard = (context: ApiContext, card: PaymentCardType): Promise<UserType> => {\n  const action: string = 'addCreditCard';\n  const {database, userId: sessionId} = context;\n\n  return getUser(context, sessionId)\n    .then((user: UserType) => {\n      // User\n      const {stripeAccountId}: UserType = user;\n\n      // Card\n      const {\n        accountNumber,\n        city,\n        country,\n        cvc,\n        expMonth,\n        expYear,\n        fullName,\n        street1,\n        street2,\n        state,\n        zip\n      }: PaymentCardType = card;\n\n      const formatNumber: number = parseNum(accountNumber, 16);\n\n      if(!formatNumber) {\n        throw new UserError('required_credit_card_number');\n      }\n\n      const formatExpMonth: number = parseNum(expMonth, 2);\n\n      if(!formatExpMonth) {\n        throw new UserError('required_credit_card_exp_month');\n      }\n\n      const formatExpYear: number = parseNum(expYear, 2);\n\n      if(!formatExpYear) {\n        throw new UserError('required_credit_card_exp_year');\n      }\n\n      const formatCvc: number = parseNum(cvc, 3);\n\n      // Address\n      const paymentCard: PaymentCardType = {};\n      const formatCity: string = parseVarChar(city, 32);\n\n      if(formatCity) {\n        paymentCard.city = formatCity;\n      }\n\n      const formatCountry: string = parseChar(country, 2);\n\n      if(formatCountry) {\n        paymentCard.country = formatCountry;\n      }\n\n      const formatFullName: string = parseVarChar(fullName, 32);\n\n      if(formatFullName) {\n        paymentCard.fullName = formatFullName;\n      }\n\n      const formatStreet1: string = parseVarChar(street1, 32);\n\n      if(formatStreet1) {\n        paymentCard.street1 = formatStreet1;\n      }\n\n      const formatStreet2: string = parseVarChar(street2, 32);\n\n      if(formatStreet2) {\n        paymentCard.street2 = formatStreet2;\n      }\n\n      const formatState: string = parseChar(state, 2);\n\n      if(formatState) {\n        paymentCard.state = formatState;\n      }\n\n      const formatZip: string = parseVarChar(zip, 10);\n\n      if(formatZip) {\n        paymentCard.zip = formatZip;\n      }\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const source: any = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_line2: formatStreet2,\n        address_state: formatState,\n        address_zip: formatZip,\n        cvc: formatCvc,\n        exp_month: formatExpMonth,\n        exp_year: formatExpYear,\n        name: fullName,\n        number: formatNumber,\n        object: 'card'\n      };\n\n      return stripeClient.customers\n        .createSource(stripeAccountId, {source})\n        .then((newSource: any) => {\n          const {brand, cvc_check: cvcCheck, last4} = newSource;\n\n          // Create session\n          const now: number = Date.now();\n          const insert = {\n            ...paymentCard,\n            _key: createHash(`user-payment-${sessionId}`),\n            accountNumber: last4,\n            added: now,\n            brand,\n            cvcCheck,\n            expMonth,\n            expYear,\n            modified: now,\n            userId: sessionId\n          };\n          const insertAqlQry: AqlQuery = aql`INSERT ${insert} IN creditCards RETURN NEW`;\n\n          return useDb(database).query(insertAqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((newCard: PaymentCardType = {}) => {\n              if(!isEmpty(newCard)) {\n                // Add linked edge\n                const {_id: cardId, _key: cardKey} = card;\n                const edgeCollection: EdgeCollection = useDb(database).collection('hasPayment');\n                const edgeId = createHash(`payment-${cardKey}`);\n                const edge: any = {\n                  _from: `users/${sessionId}`,\n                  _key: edgeId,\n                  _to: cardId\n                };\n\n                return edgeCollection.save(edge, {returnNew: true}).then(() => card);\n              }\n\n              return newCard;\n            })\n            .catch((error: Error) => logError({\n              action,\n              category: eventCategory,\n              label: 'payment_error'\n            }, error, context).then(() => null));\n        });\n    });\n};\n\nexport const updateCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {\n  const {database, userId: sessionId} = context;\n\n  const {\n    city,\n    country,\n    expMonth,\n    expYear,\n    fullName,\n    id,\n    street1,\n    state,\n    zip\n  }: PaymentCardType = card;\n\n  const formatId: string = parseId(id);\n\n  if(formatId) {\n    throw new UserError('required_credit_card_id');\n  }\n\n  const paymentCard: PaymentCardType = {};\n  const formatExpMonth: number = parseNum(expMonth, 2);\n  const formatExpYear: number = parseNum(expYear, 2);\n  const formatCity: string = parseVarChar(city, 32);\n  const formatCountry: string = parseChar(country, 2);\n  const formatFullName: string = parseVarChar(fullName, 32);\n  const formatStreet1: string = parseString(street1, 32);\n  const formatState: string = parseChar(state, 2);\n  const formatZip: string = parseVarChar(zip, 10);\n\n  if(formatExpMonth) {\n    paymentCard.expMonth = formatExpMonth;\n  }\n\n  if(formatExpYear) {\n    paymentCard.expYear = formatExpYear;\n  }\n\n  if(formatCity) {\n    paymentCard.city = formatCity;\n  }\n\n  if(formatCountry) {\n    paymentCard.country = formatCountry;\n  }\n\n  if(formatFullName) {\n    paymentCard.fullName = formatFullName;\n  }\n\n  if(formatStreet1) {\n    paymentCard.street1 = formatStreet1;\n  }\n\n  if(formatState) {\n    paymentCard.state = formatState;\n  }\n\n  if(formatZip) {\n    paymentCard.zip = formatZip;\n  }\n\n  const update: any = paymentCard;\n  const aqlQry: AqlQuery = aql`\n      LET updatedCard = FIRST(\n        FOR c IN creditCards\n        FILTER c._key == ${formatId} && c.userId == ${sessionId}\n        UPDATE c WITH ${update} IN creditCards\n        LIMIT 1\n        RETURN NEW\n      )\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == ${sessionId}\n        LIMIT 1\n        RETURN u\n      )\n      RETURN {user: user, card: updatedCard}`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((results = {card: {}, user: {}}) => {\n      const updatedCard: PaymentCardType = results.card;\n      const {user} = results;\n\n      if(isEmpty(updatedCard)) {\n        throw new UserError('not_found');\n      }\n\n      const {stripeCustomerId} = user;\n      const {stripeId} = card;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const update: any = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_state: formatState,\n        address_zip: formatZip,\n        exp_month: formatExpMonth,\n        exp_year: formatExpYear,\n        name: formatFullName\n      };\n\n      return stripeClient.customers\n        .updateSource(stripeCustomerId, stripeId, update)\n        .then(() => card)\n        .catch((error: Error) => {\n          console.log('payments::updateCard::error', error);\n          throw new UserError('payment_error');\n        });\n    });\n};\n\nexport const getCreditCards = (context: ApiContext): Promise<PaymentCardType[]> => {\n  const action: string = 'getCreditCards';\n  const {database, userId: sessionId} = context;\n  const aqlQry: AqlQuery = aql`FOR c IN creditCards\n    FILTER c.userId == ${sessionId}\n    RETURN c`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((list: PaymentCardType[] = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const deleteCreditCard = (context: ApiContext, cardId: string): Promise<boolean> => {\n  const {database, userId: sessionId} = context;\n  const formatCardId: string = parseId(cardId);\n  const aqlQry: AqlQuery = aql`\n    LET card = FIRST(\n      FOR c IN creditCards\n      FILTER c._key == ${formatCardId} && c.userId == ${sessionId}\n      LIMIT 1\n      REMOVE c IN creditCards\n      RETURN OLD\n    )\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u._key == ${sessionId}\n      LIMIT 1\n      RETURN u\n    )\n    RETURN {user: user, card: card}`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((result = {card: {}, user: {}}) => {\n      if(isEmpty(result)) {\n        return false;\n      }\n\n      const {card, user} = result;\n      const {_key: cardKey} = card;\n\n      // Remove linked edges\n      const edgeCollection = useDb(database).collection('hasPayment');\n\n      return edgeCollection.outEdges(cardKey)\n        .then((edges: any) => {\n          if(edges.length) {\n            return Promise.all(\n              edges.map((edge) => {\n                const {_key: edgeKey} = edge;\n                const removeAqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;\n                return useDb(database).query(removeAqlQry);\n              }))\n              .then(() => {\n                // Stripe\n                const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n                return stripeClient.customers\n                  .deleteSource(user.stripeCustomerId, card.stripeId)\n                  .then(() => true)\n                  .catch((error: Error) => {\n                    console.log('payments::deleteCard::error', error);\n                    throw new UserError('payment_error');\n                  });\n              });\n          }\n\n          return false;\n        });\n    });\n};\n\nexport const deleteBankAccount = (context: ApiContext, bankId: string): Promise<boolean> => {\n  const {database, userId: sessionId} = context;\n\n  // Clean db\n  const update: UserType = {\n    bankAccount: '',\n    bankFullName: '',\n    bankId: '',\n    bankRouting: '',\n    modified: Date.now()\n  };\n  const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((user: UserType = {}) => {\n      const {stripeAccountId} = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n      return stripeClient.customers\n        .deleteSource(stripeAccountId, bankId)\n        .then((response: any = {deleted: false}) => response.deleted)\n        .catch(() => Promise.resolve(false));\n    });\n};\n\nexport const createPaymentTransfer = (context: ApiContext, transfer: PaymentTransfer): Promise<PaymentTransfer> => {\n  const {database, userId: sessionId} = context;\n  const {amount, currency} = transfer;\n  const formatAmount: number = parseNum(amount);\n  const formatCurrency: string = parseChar(currency, 3, 'USD').toUpperCase();\n\n  return getUser(context, sessionId)\n    .then((user: UserType) => {\n      const {stripeAccountId} = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n      return stripeClient.transfers\n        .create({\n          amount: formatAmount,\n          currency: formatCurrency,\n          destination: stripeAccountId\n        })\n        .then((stripeTransfer) => {\n          console.log(stripeTransfer);\n          const now: number = Date.now();\n          const insert: PaymentTransfer = {\n            added: now,\n            amount: formatAmount,\n            currency: formatCurrency,\n            modified: now,\n            userId: sessionId\n          };\n          const aqlQry: AqlQuery = aql`INSERT ${insert} IN transfers RETURN NEW`;\n\n          return useDb(database).query(aqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((newTransfer: PaymentTransfer) => newTransfer);\n        });\n    });\n};\n\nexport const createPaymentHold = (context: ApiContext, payment: PaymentCharge): Promise<PaymentCharge> => {\n  const {database, userId: sessionId} = context;\n  const {amount, capture, cardId, currency, description} = payment;\n  const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();\n\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n  return stripeClient.charges\n    .create({\n      amount,\n      capture,\n      currency: formatCurrency,\n      description,\n      source: cardId\n    })\n    .then((stripeCharge) => {\n      const now: number = Date.now();\n      const insert: PaymentCharge = {\n        added: now,\n        amount,\n        capture,\n        cardId,\n        chargeFailCode: stripeCharge.failure_code,\n        chargeFailMsg: stripeCharge.failure_message,\n        chargeId: stripeCharge.id,\n        chargeStatus: stripeCharge.status,\n        currency: formatCurrency,\n        description,\n        modified: now,\n        userId: sessionId\n      };\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN payments RETURN NEW`;\n\n      return useDb(database).query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then((newPayment: PaymentCharge) => newPayment);\n    })\n    .catch((error: Error) => {\n      console.log('payments::createHold::error', error);\n      throw new UserError('payment_error');\n    });\n};\n"]}