@xuda.io/xuda-plugin-stripe-core/server/node.js

Xuda Stripe Connect Library

exports.stripe_charge = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);
    if (customer) {
      var opt = {
        amount: Number(params.stripe_amount * 100),
        currency: "usd",
        description: params.stripe_description,

        capture: params.stripe_capture === "N" ? false : true,
      };

      if (params.stripe_customer_id) {
        opt.customer = params.stripe_customer_id;
      }

      if (params.stripe_token) {
        opt.source = params.stripe_token;
      }

      if (params.stripe_send_invoice !== "N" && params.stripe_email) {
        opt["receipt_email"] = params.stripe_email;
      }
      const charge = await stripe.charges.create(opt).then(
        function (result) {
          resolve(result);
        },
        function (err) {
          var error_msg = "";
          switch (err.type) {
            case "StripeCardError":
              // A declined card error

              error_msg = err.message; // => e.g. "Your card's expiration year is invalid."
              break;
            case "StripeRateLimitError":
              error_msg = "Too many requests made to the API too quickly";
              break;
            case "StripeInvalidRequestError":
              error_msg == "Invalid parameters were supplied to Stripe's API";
              break;
            case "StripeAPIError":
              error_msg = "An error occurred internally with Stripe's API";
              break;
            case "StripeConnectionError":
              error_msg ==
                "Some kind of error occurred during the HTTPS communication";
              break;
            case "StripeAuthenticationError":
              error_msg = "You probably used an incorrect API key";
              break;
            default:
              error_msg = "Handle any other types of unexpected errors";
              break;
          }

          reject(err.message);
        }
      );
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_refund = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  debugger;
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    var opt = {
      reverse_transfer: params.stripe_reverse_transfer,

      ...(params.stripe_payment_intent && {
        payment_intent: params.stripe_payment_intent,
      }),
      ...(params.stripe_charge_id && { charge: params.stripe_charge_id }),
      ...(params.stripe_reason && { reason: params.stripe_reason }),
    };
    if (params.stripe_amount) {
      opt.amount = Number(params.stripe_amount * 100);
    }

    const refund = await stripe.refunds.create(opt);
    resolve(refund);
  } catch (error) {
    reject(error);
  }
};

exports.stripe_capture_charge = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  debugger;
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const charge = await stripe.charges.capture(params.stripe_charge_id);
    resolve(charge);
  } catch (error) {
    reject(error);
  }
};

exports.stripe_get_charges = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);
    if (customer) {
      const charges = await stripe.charges.list({
        limit: params.stripe_limit,
        customer: params.stripe_customer_id,
      });

      resolve(charges);
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_get_cards = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);
    if (customer) {
      let opt = { object: "card" };
      if (params.limit) {
        opt.limit = params.limit;
      }
      const customer_cards = await stripe.customers.listSources(
        params.stripe_customer_id,
        opt
      );

      cards = customer_cards.data;

      resolve(cards);
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_remove_card = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);

    if (customer) {
      await stripe.customers.deleteSource(
        params.stripe_customer_id,
        params.stripe_card_id
      );
      resolve(params.stripe_card_id);
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_set_default_card = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);

    if (customer) {
      await stripe.customers.update(params.stripe_customer_id, {
        default_source: params.stripe_card_id,
      });
      resolve(params.stripe_card_id);
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_create_customer = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const xu_each = require("@xuda.io/xu_each");
    const dot = require("dot-object");
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    var obj = {};
    var stripe_map = {
      stripe_address_line_1: "address.line1",
      stripe_address_line_2: "address.line2",
      stripe_city: "address.city",
      stripe_country: "address.country",
      stripe_postal_code: "address.postal_code",

      stripe_first_name: "name",
      stripe_last_name: "name",
      stripe_phone: "phone",
      stripe_description: "description",
      stripe_email: "email",
      stripe_balance: "balance",

      stripe_shipping_name: "shipping.name",
      stripe_shipping_address_line_1: "shipping.address.line1",
      stripe_shipping_address_line_2: "shipping.address.line2",
      stripe_shipping_city: "shipping.address.city",
      stripe_shipping_country: "shipping.address.country",
      stripe_shipping_postal_code: "shipping.address.postal_code",
    };

    xu_each(stripe_map, function (key, val) {
      var value = params[key];

      if (!value || typeof value === "undefiled") return true;

      if (key !== "stripe_first_name" && key !== "stripe_last_name") {
        dot.str(val, value, obj);
      } else {
        obj.name = params.stripe_first_name + " " + params.stripe_last_name;
      }
    });
    res = await stripe.customers.create(obj);
    resolve(res);
  } catch (error) {
    reject(error);
  }
};

exports.stripe_update_customer = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const xu_each = require("@xuda.io/xu_each");
    const dot = require("dot-object");
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    var obj = {};
    var stripe_map = {
      stripe_address_line_1: "address.line1",
      stripe_address_line_2: "address.line2",
      stripe_city: "address.city",
      stripe_country: "address.country",
      stripe_postal_code: "address.postal_code",

      stripe_first_name: "name",
      stripe_last_name: "name",
      stripe_phone: "phone",
      stripe_description: "description",
      stripe_email: "email",
      stripe_balance: "balance",

      stripe_shipping_name: "shipping.name",
      stripe_shipping_address_line_1: "shipping.address.line1",
      stripe_shipping_address_line_2: "shipping.address.line2",
      stripe_shipping_city: "shipping.address.city",
      stripe_shipping_country: "shipping.address.country",
      stripe_shipping_postal_code: "shipping.address.postal_code",
    };

    xu_each(stripe_map, function (key, val) {
      var value = params[key];

      if (!value || typeof value === "undefiled") return true;

      if (key !== "stripe_first_name" && key !== "stripe_last_name") {
        dot.str(val, value, obj);
      } else {
        obj.name = params.stripe_first_name + " " + params.stripe_last_name;
      }
    });
    res = await stripe.customers.update(params.stripe_customer_id, obj);
    resolve(res);
  } catch (error) {
    reject(error);
  }
};

exports.stripe_create_portal = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  try {
    const stripe = require("stripe")(
      setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
    );
    const customer = await stripe.customers.retrieve(params.stripe_customer_id);

    if (customer) {
      const session = await stripe.billingPortal.sessions.create({
        customer: params.stripe_customer_id,

        ...(params.stripe_portal_return_url && {
          return_url: params.stripe_portal_return_url,
        }),
      });

      resolve(session);
    } else {
      reject("stripe customer not found");
    }
  } catch (error) {
    reject(error);
  }
};

exports.stripe_add_card = async function (
  req,
  params,
  setup_doc,
  resolve,
  reject
) {
  debugger;
  var card;
  const stripe = require("stripe")(
    setup_doc.accounts[params.stripe_api_account_id].data.stripe_secret_key
  );
  async function update_source_to_stripe_customer(stripe_customer_id, source) {
    return await stripe.customers.update(stripe_customer_id, {
      source: source,
    });
  }

  try {
    await stripe.customers.retrieve(params.stripe_customer_id);
    try {
      card = await stripe.customers.createSource(params.stripe_customer_id, {
        source: params.stripe_token,
      });
    } catch (error) {
      return reject(error);
    }
  } catch (error) {
    try {
      await update_source_to_stripe_customer(
        params.stripe_customer_id,
        params.stripe_token
      );

      customer = await stripe.customers.retrieve(params.stripe_customer_id);

      card = customer.sources.data[0];
    } catch (error) {
      reject(error);
    }
  }
  resolve(card);
  return;
  try {
    // const customer = await stripe.customers.retrieve(params.stripe_customer_id);
    await stripe.customers.retrieve(params.stripe_customer_id);

    // if (customer) {
    card = await stripe.customers.createSource(params.stripe_customer_id, {
      source: params.stripe_card_id,
    });
    // } else {
    // await update_source_to_stripe_customer(
    //   params.stripe_customer_id,
    //   params.stripe_card_id
    // );

    // customer = await stripe.customers.retrieve(params.stripe_customer_id);

    // card = customer.sources.data[0];
    // }
    // resolve(card);
  } catch (error) {
    try {
      await update_source_to_stripe_customer(
        params.stripe_customer_id,
        params.stripe_card_id
      );

      customer = await stripe.customers.retrieve(params.stripe_customer_id);

      card = customer.sources.data[0];
    } catch (error) {
      reject(error);
    }
  }
  resolve(card);
};