@winible/winible-typed 1.0.0

package/src/pk-sub.ts

@@ -0,0 +1,455 @@
+import PhoneUser from "../typed-model/phone-user";
+import PhoneOwner from "../typed-model/phone-owner";
+import Subscription from "../typed-model/subscription";
+import SubscriptionPlan from "../typed-model/subscription-plan";
+import SubscriptionBundle from "../typed-model/subscription-bundle";
+import { TransactionData } from "./types";
+
+import sequelize from "../typed-model/pb-sequelize";
+import CreditPayments from "../typed-model/credit-payment";
+import { ProcessorId } from "../typed-model/customer-profile";
+
+export class SubscriptionInitException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SubscriptionInitException";
+  }
+}
+
+export class SubscriptionChargeException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SubscriptionChargeException";
+  }
+}
+
+export class SubscriptionChargeCreditCardException extends SubscriptionChargeException {
+  constructor(message: string) {
+    super(message);
+    this.name = "SubscriptionChargeCreditCardException";
+  }
+}
+
+export class SubscriptionChargeProfileException extends SubscriptionChargeException {
+  constructor(message: string) {
+    super(message);
+    this.name = "SubscriptionChargeProfileException";
+  }
+}
+
+export class CreatePaymentProfileException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CreatePaymentProfileException";
+  }
+}
+
+export class InvalidSubscriptionRequestException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidSubscriptionRequestException";
+  }
+}
+
+export class CliqSubscriptionCreationException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CliqSubscriptionCreationException";
+  }
+}
+
+export class CliqPaymentCreationException extends Error {
+  constructor() {
+    super("Failed to create Cliq credit payment");
+    this.name = "CliqSubscriptionCreationException";
+  }
+}
+
+export class CreatePKSubscriptionException extends Error {
+  constructor(name: string, message: string) {
+    super(message);
+    this.name = name;
+  }
+}
+
+import {
+  chargeCustomerByPaymentProfile,
+  chargeCreditCardAndCreateProfile,
+  updateUserPaymentProfile,
+  createSubscription,
+  voidTransaction,
+  createSubscriptionWithCreditCard,
+} from "./pk-client";
+import { rejects } from "assert";
+
+export class PKSub {
+  user: PhoneUser;
+  creator: PhoneOwner;
+  subscriptionPlan: SubscriptionPlan;
+  trialAmount: number;
+  trialLength: number;
+  amountInCents: number;
+  intervalCount: number;
+  intervalUnit: "months" | "days";
+  transactionData?: TransactionData;
+  useCoachingMid: boolean;
+  paymentProfile?: {
+    customerProfileId: string;
+    customerPaymentProfileId: string;
+  };
+
+  constructor(
+    user: PhoneUser,
+    creator: PhoneOwner,
+    subscriptionPlan: SubscriptionPlan,
+    subscriptionBundle?: SubscriptionBundle,
+    isPreviouslySubscribed?: boolean,
+    useCoachingMid?: boolean
+  ) {
+    this.user = user;
+    this.creator = creator;
+    this.subscriptionPlan = subscriptionPlan;
+    this.useCoachingMid = !!useCoachingMid;
+
+    if (!user) {
+      throw new SubscriptionInitException("User cannot be null");
+    }
+
+    if (!creator || !creator.id) {
+      console.log(creator);
+      throw new SubscriptionInitException("Creator cannot be null");
+    }
+
+    var promotion =
+      subscriptionPlan.SubscriptionPromotions &&
+      subscriptionPlan.SubscriptionPromotions[0];
+
+    this.trialAmount = 0;
+    this.trialLength = 0;
+    this.amountInCents = subscriptionPlan.amountInCents!;
+    this.intervalCount = subscriptionPlan.intervalCount || 1;
+    this.intervalUnit = subscriptionPlan.intervalUnit || "months";
+
+    if (subscriptionBundle) {
+      promotion = null;
+    }
+
+    if (!isPreviouslySubscribed && promotion) {
+      this.trialAmount = Math.round(
+        (1 - promotion.trialDiscountPercentage) *
+          subscriptionPlan.amountInCents!
+      );
+      this.trialLength = promotion.trialLength;
+    }
+
+    if (subscriptionBundle) {
+      this.amountInCents = Math.round(
+        (1 - subscriptionBundle.bundleDiscountPercentage!) *
+          this.amountInCents *
+          subscriptionBundle.bundleIntervalCount!
+      );
+      this.intervalCount = subscriptionBundle.bundleIntervalCount!;
+      this.trialAmount = 0;
+      this.trialLength = 0;
+    }
+  }
+
+  async _charge(
+    amount: number,
+    description: string
+  ): Promise<
+    | {
+        amountInCents: number;
+        transactionId: string;
+        pkCustomerProfileId?: string;
+        pkCustomerPaymentProfileId?: string;
+        processorId: ProcessorId;
+      }
+    | undefined
+  > {
+    console.log("Start Charge...");
+    if (this.paymentProfile) {
+      console.log("Charge by payment profile...");
+      let response = await chargeCustomerByPaymentProfile(
+        this.paymentProfile.customerProfileId,
+        this.paymentProfile.customerPaymentProfileId,
+        amount,
+        description
+      ).catch((err) => {
+        throw new SubscriptionChargeProfileException(err);
+      });
+      return {
+        ...response,
+        pkCustomerProfileId: this.paymentProfile.customerProfileId,
+        pkCustomerPaymentProfileId:
+          this.paymentProfile.customerPaymentProfileId,
+      };
+    } else if (this.transactionData) {
+      console.log("Charge by credit card...");
+      let chargeResponse = await chargeCreditCardAndCreateProfile(
+        this.user,
+        this.transactionData,
+        amount,
+        description,
+        true,
+        this.useCoachingMid
+      ).catch((err) => {
+        throw new SubscriptionChargeCreditCardException(err);
+      });
+      try {
+        // if (chargeResponse.pkCustomerProfileId) {
+        // await updateUserPaymentProfile(
+        //   this.user.id,
+        //   chargeResponse.pkCustomerProfileId,
+        //   chargeResponse.pkCustomerPaymentProfileId!
+        // );
+        // this.paymentProfile = {
+        //   customerProfileId: chargeResponse.pkCustomerProfileId,
+        //   customerPaymentProfileId:
+        //     chargeResponse.pkCustomerPaymentProfileId!,
+        // };
+        // }
+        return {
+          amountInCents: chargeResponse.amountInCents,
+          transactionId: chargeResponse.transactionId,
+          processorId: chargeResponse.processorId,
+          // pkCustomerProfileId: chargeResponse.pkCustomerProfileId,
+          // pkCustomerPaymentProfileId: chargeResponse.pkCustomerPaymentProfileId,
+        };
+      } catch (err) {
+        console.log(err);
+        if (chargeResponse.transactionId) {
+          // Void transaction
+          await voidTransaction(
+            chargeResponse.transactionId,
+            chargeResponse.processorId
+          );
+          console.log("Failed to create customer id");
+        }
+        throw new CreatePaymentProfileException(
+          "Failed to create customer profile"
+        );
+      }
+    }
+    throw new InvalidSubscriptionRequestException(
+      "Must include transaction data or customer profile"
+    );
+  }
+
+  async _chargeFirstPayment(): Promise<{
+    amountInCents: number;
+    transactionId: string;
+    pkCustomerProfileId?: string;
+    pkCustomerPaymentProfileId?: string;
+    processorId: ProcessorId;
+  }> {
+    console.log("Charge first payment");
+    if (this.trialLength > 0 && this.trialAmount > 0) {
+      const charge = await this._charge(
+        this.trialAmount,
+        `${this.creator.name} ${
+          this.intervalUnit == "days" ? "weekly" : "monthly"
+        } subscriptions`
+      );
+      this.trialLength = this.trialLength - 1;
+      if (this.trialLength == 0) {
+        this.trialAmount = 0;
+      }
+      return charge!;
+    } else {
+      const charge = await this._charge(
+        this.amountInCents,
+        `${this.creator.name} ${
+          this.intervalUnit == "days" ? "weekly" : "monthly"
+        } subscriptions`
+      );
+      return charge!;
+    }
+  }
+
+  async _initializePkSubscription(
+    processorId: ProcessorId
+  ): Promise<{ pkSubId: string }> {
+    if (this.paymentProfile) {
+      console.log("Creating sub with payment profile");
+      return await createSubscription({
+        intervalCount: this.intervalCount,
+        intervalUnit: this.intervalUnit,
+        trialLength: this.trialLength,
+        trialAmountInCents: this.trialAmount,
+        customerProfileId: this.paymentProfile!.customerProfileId,
+        customerPaymentProfileId: this.paymentProfile!.customerPaymentProfileId,
+        creatorName: this.creator.name!,
+        amountInCents: this.amountInCents,
+        processorId: processorId,
+      }).catch((err) => {
+        throw new CreatePKSubscriptionException(
+          "CreatePKSubscriptionWithProfileException",
+          "Failed to create authorize subscription with payment profile"
+        );
+      });
+    } else if (this.transactionData) {
+      console.log("Creating sub credit card");
+      let subscriptionResponse = await createSubscriptionWithCreditCard({
+        intervalCount: this.intervalCount,
+        intervalUnit: this.intervalUnit,
+        trialLength: this.trialLength,
+        trialAmountInCents: this.trialAmount,
+        data: this.transactionData,
+        creatorName: this.creator.name!,
+        amountInCents: this.amountInCents,
+        processorId: processorId,
+      }).catch((err) => {
+        throw new CreatePKSubscriptionException(
+          "CreatePKSubscriptionWithCardException",
+          "Failed to create authorize subscription with credit card"
+        );
+      });
+      if (subscriptionResponse.paymentProfile.pkCustomerProfileId) {
+        console.log("Updating customer profile from sub response");
+        await updateUserPaymentProfile(
+          this.user.id,
+          subscriptionResponse.paymentProfile.pkCustomerProfileId,
+          processorId,
+          subscriptionResponse.paymentProfile.pkCustomerPaymentProfileId
+        );
+      }
+      return subscriptionResponse;
+    }
+    throw new InvalidSubscriptionRequestException(
+      "No payment method for subscription"
+    );
+  }
+
+  setTransactionData(transactionData: TransactionData) {
+    this.transactionData = transactionData;
+  }
+
+  setPaymentProfile(paymentProfile: {
+    customerProfileId: string;
+    customerPaymentProfileId: string;
+  }) {
+    this.paymentProfile = paymentProfile;
+  }
+
+  /*
+    1) Start SQL transaction
+    2) Create sequelize updates
+      - Create first payment
+      - Create subscription
+    3) Create first charge
+      - If charge fails, rollback transaction
+    4) Create subscription
+      - If subscription fails
+        - Refund transaction
+        - Rollback transaction
+    5) Commit transaction
+  */
+
+  async buildSubscription(): Promise<{
+    subscription: any;
+    creditPayment: any;
+    pkSubId: string;
+  }> {
+    let firstPayment;
+    try {
+      if (this.trialLength == 0 || this.trialAmount > 0) {
+        firstPayment = await this._chargeFirstPayment();
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
+      } else {
+        throw new Error("Failed to charge: " + err);
+      }
+    }
+
+    if (!firstPayment) {
+      throw new Error("Failed to charge credit card");
+    }
+
+    let transaction = await sequelize.transaction();
+    let subscription;
+    try {
+      subscription = await Subscription.create(
+        {
+          userId: this.user.id,
+          subscriptionPlanId: this.subscriptionPlan.id,
+          lastPaymentDate: new Date(),
+          cancelDate: this.subscriptionPlan.accessEndDate || undefined,
+          processorId: firstPayment.processorId,
+        },
+        { transaction }
+      );
+    } catch (err) {
+      console.log(err);
+      await transaction.rollback();
+      // Void first transaction
+      await voidTransaction(
+        firstPayment.transactionId,
+        firstPayment.processorId
+      );
+      throw new CliqSubscriptionCreationException(
+        "Failed to create subscription in CLIQ"
+      );
+    }
+
+    let creditPayment;
+    try {
+      if (subscription) {
+        creditPayment = await CreditPayments.logSubscriptionPayment(
+          this.user.id,
+          this.creator,
+          firstPayment.amountInCents,
+          subscription,
+          transaction,
+          firstPayment.transactionId
+        );
+      }
+    } catch (err) {
+      console.log(err);
+      await transaction.rollback();
+      // Void first transaction
+      if (firstPayment) {
+        await voidTransaction(
+          firstPayment.transactionId,
+          firstPayment.processorId
+        );
+      }
+      throw new CliqPaymentCreationException();
+    }
+
+    let pkSub;
+    let setRecurring =
+      !this.subscriptionPlan.accessEndDate &&
+      !this.subscriptionPlan.oneTimePurchase;
+    try {
+      if (setRecurring) {
+        pkSub = await this._initializePkSubscription(firstPayment.processorId);
+      }
+    } catch (err) {
+      console.log(err);
+      await transaction.rollback();
+      // Void first transaction
+      await voidTransaction(
+        firstPayment.transactionId,
+        firstPayment.processorId
+      );
+      throw new CreatePKSubscriptionException(
+        "CreatePKSubscriptionException",
+        "Failed to create subscription: " + err
+      );
+    }
+
+    await transaction.commit();
+    if (subscription && setRecurring) {
+      subscription.pkSubscriptionId = pkSub.pkSubId;
+      await subscription.save();
+    }
+    return {
+      subscription,
+      creditPayment,
+      pkSubId: pkSub && pkSub.pkSubId,
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+export type CreditCard = {
+  cardNumber: string;
+  expirationDate: string;
+  cardCode: string;
+};
+
+export type Payment = {
+  creditCard: CreditCard;
+};
+
+export type Address = {
+  firstName: string;
+  lastName: string;
+  address: string;
+  city: string;
+  zip: string;
+  country: string;
+  state: string;
+};
+
+export type TransactionData = {
+  payment: Payment;
+  billTo: Address;
+  defaultPaymentProfile: string;
+};
+
+export type PkSubStatus =
+  | "active"
+  | "expired"
+  | "suspended"
+  | "canceled"
+  | "terminated";
+
+export type ArbTransaction = {
+  getTransId: () => string;
+  getResponse: () => string;
+  getSubmitTimeUTC: () => string;
+  getPayNum: () => number;
+  getAttemptNum: () => string;
+};

package/support/index.ts

@@ -0,0 +1,2 @@
+export * from "./slack-client";
+export * from "./utils";

package/support/slack-client.ts

@@ -0,0 +1,43 @@
+import axios from "axios";
+const WEBHOOK_URL =
+  "https://hooks.slack.com/services/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";
+
+export const postSlackNotification = async (body: any) => {
+  try {
+    await axios.post(WEBHOOK_URL, body);
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+export const postSlackText = async (text: string) => {
+  await postSlackNotification({ text });
+};
+
+export const postSubscriptionAlarm = async (pkIds: string[]) => {
+  try {
+    await postSlackNotification({
+      text: `Unreferenced subscriptions created`,
+      blocks: [
+        {
+          type: "header",
+          text: {
+            type: "plain_text",
+            text: `Unreferenced subscriptions created`,
+          },
+        },
+        {
+          type: "section",
+          fields: [
+            {
+              type: "mrkdwn",
+              text: `*pk_subscription_ids:*\n${pkIds.join(", ")}`,
+            },
+          ],
+        },
+      ],
+    });
+  } catch (err) {
+    console.log(err);
+  }
+};