@winible/winible-typed 1.0.0

package/typed-model/credit-payment.ts

@@ -0,0 +1,678 @@
+import { Transaction } from "sequelize";
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import PhoneOwner from "./phone-owner";
+import PhoneUser from "./phone-user";
+import PremiumContent from "./premium-content";
+import Message from "./message";
+import Subscription from "./subscription";
+import PurchasedContent from "./purchased-content";
+import Notification from "./notification";
+
+type InteractionType =
+  | "subscription"
+  | "tip"
+  | "text"
+  | "unlock_message"
+  | "content"
+  | "unlock"
+  | "audio"
+  | "referral"
+  | "video";
+
+const INTERACTION_TYPES: { [key: string]: InteractionType } = {
+  CONTENT: "content",
+  AUDIO: "audio",
+  TEXT: "text",
+  VIDEO: "video",
+  TIP: "tip",
+  UNLOCK: "unlock",
+  UNLOCK_MESSAGE: "unlock_message",
+  REFERRAL: "referral",
+  SUBSCRIPTION: "subscription",
+};
+
+// order of InferAttributes & InferCreationAttributes is important.
+class CreditPayments extends Model<
+  InferAttributes<CreditPayments>,
+  InferCreationAttributes<CreditPayments>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare userId?: string;
+  declare ownerId: string;
+  declare creditAmountInCents: number;
+  declare interactionType: InteractionType;
+  declare payoutDate?: Date;
+  declare metadata?: string;
+  declare earningAmountInCents: number;
+  declare payoutId?: string;
+  declare referredCreditPaymentId?: string;
+  declare transId?: number;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static getById: (id: string) => Promise<CreditPayments | null>;
+  static logContentPurchase: (
+    user: PhoneUser,
+    contentId: string,
+    owner: PhoneOwner,
+    alreadyPaid?: boolean,
+    transaction?: Transaction,
+    transId?: number
+  ) => Promise<CreditPayments>;
+  static logMessage: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    chatRateInCents: number
+  ) => Promise<CreditPayments>;
+  static logTip: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    tipAmountInCents: number
+  ) => Promise<CreditPayments>;
+  static logAudioCall: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    callAmountInCents: number
+  ) => Promise<CreditPayments>;
+  static logVideoCall: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    callAmountInCents: number
+  ) => Promise<CreditPayments>;
+  static logUnlockMessage: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    message: Message,
+    alreadyPaid?: boolean,
+    transaction?: Transaction,
+    transId?: number
+  ) => Promise<CreditPayments>;
+  static logSubscriptionPayment: (
+    userId: string,
+    owner: PhoneOwner,
+    subscriptionAmountInCents: number,
+    subscription: Subscription,
+    transaction: Transaction | undefined,
+    transId: number
+  ) => Promise<CreditPayments>;
+  static logUnlockedContent: (
+    user: PhoneUser,
+    owner: PhoneOwner,
+    lockedContent: PremiumContent
+  ) => Promise<CreditPayments>;
+}
+
+CreditPayments.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    userId: {
+      type: DataTypes.BIGINT,
+      field: "user_id",
+    },
+    ownerId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "owner_id",
+    },
+    creditAmountInCents: {
+      type: DataTypes.INTEGER,
+      field: "credit_amount_in_cents",
+    },
+    interactionType: {
+      type: DataTypes.STRING,
+      field: "interaction_type",
+    },
+    payoutDate: {
+      type: DataTypes.DATE,
+      field: "payout_date",
+    },
+    metadata: {
+      type: DataTypes.STRING,
+      field: "metadata",
+    },
+    earningAmountInCents: {
+      type: DataTypes.INTEGER,
+      field: "earning_amount_in_cents",
+    },
+    payoutId: {
+      type: DataTypes.BIGINT,
+      field: "payout_id",
+    },
+    referredCreditPaymentId: {
+      type: DataTypes.BIGINT,
+      field: "referred_credit_payment_id",
+    },
+    transId: {
+      type: DataTypes.BIGINT,
+      field: "trans_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "credit_payments",
+    sequelize,
+  }
+);
+
+const REFERRAL_PERCENTAGE = 0.03;
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+CreditPayments.getById = async (id: string) => {
+  return await CreditPayments.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+CreditPayments.logContentPurchase = async (
+  user: PhoneUser,
+  contentId: string,
+  owner: PhoneOwner,
+  alreadyPaid?: boolean,
+  transaction?: Transaction,
+  transId?: number
+) => {
+  const content = await PremiumContent.getById(contentId);
+
+  if (!content) {
+    throw new Error("No such content for id: " + contentId);
+  }
+
+  if (user.creditsInCents! < content.amountInCents! && !alreadyPaid) {
+    throw new Error("Not enough credits");
+  }
+
+  if (content.amountInCents! < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  let purchasedContent = await PurchasedContent.create(
+    {
+      userId: user.id!,
+      contentId: content.id!,
+    },
+    { transaction }
+  );
+
+  if (!alreadyPaid) {
+    user.creditsInCents = user.creditsInCents! - content.amountInCents!;
+    await user.save({ transaction });
+  }
+
+  let creditPayment = await CreditPayments.create(
+    {
+      userId: user.id,
+      ownerId: content.ownerId,
+      creditAmountInCents: content.amountInCents!,
+      earningAmountInCents: earningsAmount(
+        content.amountInCents!,
+        owner && owner.serviceFeePercentage
+      ),
+      interactionType: INTERACTION_TYPES.CONTENT,
+      metadata: JSON.stringify({ contentId }),
+      transId,
+    },
+    { transaction }
+  );
+
+  try {
+    await Notification.create(
+      {
+        ownerId: content.ownerId,
+        userId: user.id,
+        creditPaymentId: creditPayment.id,
+        type: "content",
+        purchasedContentId: purchasedContent.id,
+      },
+      { transaction }
+    );
+  } catch (err) {
+    console.log(err);
+  }
+
+  if (owner && owner.referringOwnerId) {
+    await createReferralPayment(
+      owner,
+      creditPayment,
+      content.amountInCents!,
+      transaction
+    );
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(
+      user,
+      creditPayment,
+      content.amountInCents!,
+      transaction
+    );
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logTip = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  tipAmountInCents: number
+) => {
+  if (tipAmountInCents > user.creditsInCents!) {
+    let url = await getPaymentUrl(user, owner);
+    throw new Error(
+      `Sorry, it looks like you've run out of credits. To send a tip, add more credits here: ${url}`
+    );
+  }
+
+  if (tipAmountInCents < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  user.creditsInCents = user.creditsInCents! - tipAmountInCents;
+  await user.save();
+
+  let creditPayment = await CreditPayments.create({
+    userId: user.id,
+    ownerId: owner.id,
+    creditAmountInCents: tipAmountInCents,
+    earningAmountInCents: earningsAmount(
+      tipAmountInCents,
+      owner.serviceFeePercentage
+    ),
+    interactionType: INTERACTION_TYPES.TIP,
+  });
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(owner, creditPayment, tipAmountInCents);
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(user, creditPayment, tipAmountInCents);
+  }
+
+  try {
+    await Notification.create({
+      ownerId: owner.id,
+      userId: user.id,
+      creditPaymentId: creditPayment.id,
+      type: "tip",
+    });
+  } catch (err) {
+    console.log(err);
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logMessage = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  chatRateInCents: number
+) => {
+  if (chatRateInCents > user.creditsInCents!) {
+    let url = await getPaymentUrl(user, owner);
+    throw new Error(
+      `Sorry, it looks like you've run out of credits. To keep texting, add more credits here: ${url}`
+    );
+  }
+
+  if (chatRateInCents < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  user.creditsInCents = user.creditsInCents! - chatRateInCents;
+  await user.save();
+
+  let creditPayment = await CreditPayments.create({
+    userId: user.id,
+    ownerId: owner.id,
+    creditAmountInCents: chatRateInCents,
+    earningAmountInCents: earningsAmount(chatRateInCents),
+    interactionType: INTERACTION_TYPES.TEXT,
+  });
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(owner, creditPayment, chatRateInCents);
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(user, creditPayment, chatRateInCents);
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logAudioCall = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  callAmountInCents: number
+) => {
+  if (callAmountInCents < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  user.creditsInCents = user.creditsInCents! - callAmountInCents;
+  await user.save();
+
+  let creditPayment = await CreditPayments.create({
+    userId: user.id,
+    ownerId: owner.id,
+    creditAmountInCents: callAmountInCents,
+    earningAmountInCents: earningsAmount(
+      callAmountInCents,
+      owner.serviceFeePercentage
+    ),
+    interactionType: INTERACTION_TYPES.AUDIO,
+  });
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(owner, creditPayment, callAmountInCents);
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(user, creditPayment, callAmountInCents);
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logVideoCall = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  callAmountInCents: number
+) => {
+  if (callAmountInCents < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  user.creditsInCents = user.creditsInCents! - callAmountInCents;
+  await user.save();
+
+  let creditPayment = await CreditPayments.create({
+    userId: user.id,
+    ownerId: owner.id,
+    creditAmountInCents: callAmountInCents,
+    earningAmountInCents: earningsAmount(
+      callAmountInCents,
+      owner.serviceFeePercentage
+    ),
+    interactionType: INTERACTION_TYPES.VIDEO,
+  });
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(owner, creditPayment, callAmountInCents);
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(user, creditPayment, callAmountInCents);
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logUnlockMessage = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  message: Message,
+  alreadyPaid?: boolean,
+  transaction?: Transaction,
+  transId?: number
+) => {
+  if (message.amountInCents! > user.creditsInCents! && !alreadyPaid) {
+    throw new Error(`Sorry, it looks like you've run out of credits`);
+  }
+
+  if (!message.amountInCents) {
+    throw new Error("Must contain message amount");
+  }
+
+  if (message.amountInCents! < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  if (!alreadyPaid) {
+    user.creditsInCents = user.creditsInCents! - message.amountInCents!;
+    await user.save({ transaction });
+  }
+
+  let creditPayment = await CreditPayments.create(
+    {
+      userId: user.id,
+      ownerId: owner.id,
+      creditAmountInCents: message.amountInCents!,
+      earningAmountInCents: earningsAmount(
+        message.amountInCents!,
+        owner.serviceFeePercentage
+      ),
+      transId,
+      interactionType: INTERACTION_TYPES.UNLOCK_MESSAGE,
+    },
+    { transaction }
+  );
+
+  try {
+    await Notification.create(
+      {
+        ownerId: owner.id,
+        userId: user.id,
+        creditPaymentId: creditPayment.id,
+        type: "unlock_message",
+        messageId: message.id,
+      },
+      { transaction }
+    );
+  } catch (err) {
+    console.log(err);
+  }
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(
+      owner,
+      creditPayment,
+      message.amountInCents!,
+      transaction
+    );
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logUnlockedContent = async (
+  user: PhoneUser,
+  owner: PhoneOwner,
+  lockedContent: PremiumContent
+) => {
+  if (lockedContent.amountInCents! < 0) {
+    throw new Error("Cannot be less than 0");
+  }
+
+  if (lockedContent.amountInCents! > user.creditsInCents!) {
+    let url = await getPaymentUrl(user, owner);
+    throw new Error(
+      `Sorry, it looks like you've run out of credits. To unlock this content, add more credits here: ${url}`
+    );
+  }
+
+  user.creditsInCents = user.creditsInCents! - lockedContent.amountInCents!;
+  await user.save();
+
+  let creditPayment = await CreditPayments.create({
+    userId: user.id,
+    ownerId: owner.id,
+    creditAmountInCents: lockedContent.amountInCents!,
+    earningAmountInCents: earningsAmount(
+      lockedContent.amountInCents!,
+      owner.serviceFeePercentage
+    ),
+    interactionType: INTERACTION_TYPES.UNLOCK,
+  });
+
+  if (owner.referringOwnerId) {
+    await createReferralPayment(
+      owner,
+      creditPayment,
+      lockedContent.amountInCents!
+    );
+  }
+
+  if (user.referringOwnerId) {
+    await createUserReferralPayment(
+      user,
+      creditPayment,
+      lockedContent.amountInCents!
+    );
+  }
+
+  return creditPayment;
+};
+
+CreditPayments.logSubscriptionPayment = async (
+  userId: string,
+  owner: PhoneOwner,
+  subscriptionAmountInCents: number,
+  subscription: Subscription,
+  transaction: Transaction | undefined,
+  transId: number
+) => {
+  let creditPayment = await CreditPayments.create(
+    {
+      userId: userId,
+      ownerId: owner.id,
+      creditAmountInCents: subscriptionAmountInCents,
+      earningAmountInCents: earningsAmount(
+        subscriptionAmountInCents,
+        owner.serviceFeePercentage
+      ),
+      interactionType: INTERACTION_TYPES.SUBSCRIPTION,
+      metadata: JSON.stringify({ subscription_id: subscription.id }),
+      transId,
+    },
+    { transaction }
+  );
+
+  try {
+    if (owner.referringOwnerId) {
+      await createReferralPayment(
+        owner,
+        creditPayment,
+        subscriptionAmountInCents,
+        transaction
+      );
+    }
+    const user = await PhoneUser.getById(userId);
+    if (user && user.referringOwnerId) {
+      await createUserReferralPayment(
+        user,
+        creditPayment,
+        subscriptionAmountInCents,
+        transaction
+      );
+    }
+  } catch (err) {
+    console.log(err);
+    console.log("Issue creating referral payment");
+  }
+
+  return creditPayment;
+};
+
+const earningsAmount = (amount: number, serviceFeePercentage?: number) => {
+  return Math.floor(amount * (1 - (serviceFeePercentage || 0.2)));
+};
+
+const createReferralPayment = async (
+  owner: PhoneOwner,
+  creditPayment: CreditPayments,
+  creditAmount: number,
+  transaction?: Transaction
+) => {
+  return await CreditPayments.create(
+    {
+      ownerId: owner.referringOwnerId!,
+      creditAmountInCents: creditAmount,
+      earningAmountInCents: Math.floor(
+        creditAmount * (owner.referralPercentage || REFERRAL_PERCENTAGE)
+      ),
+      interactionType: INTERACTION_TYPES.REFERRAL,
+      referredCreditPaymentId: creditPayment.id,
+    },
+    { transaction }
+  );
+};
+
+const createUserReferralPayment = async (
+  user: PhoneUser,
+  creditPayment: CreditPayments,
+  creditAmount: number,
+  transaction?: Transaction
+) => {
+  return await CreditPayments.create(
+    {
+      ownerId: user.referringOwnerId!,
+      creditAmountInCents: creditAmount,
+      earningAmountInCents: Math.floor(creditAmount * 0.04),
+      interactionType: INTERACTION_TYPES.REFERRAL,
+      referredCreditPaymentId: creditPayment.id!,
+    },
+    { transaction }
+  );
+};
+
+const getPaymentUrl = async (user: PhoneUser, owner: PhoneOwner) => {
+  let name = owner.name && owner.name.toLowerCase().replace(/\s+/g, "-");
+  return `https://${process.env.SITE_DOMAIN}/${name}`;
+};
+
+PhoneOwner.hasMany(CreditPayments, {
+  foreignKey: "owner_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+PhoneUser.hasMany(CreditPayments, {
+  foreignKey: "user_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+CreditPayments.hasOne(PhoneOwner, {
+  foreignKey: "id",
+  sourceKey: "owner_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+CreditPayments.hasOne(PhoneUser, {
+  foreignKey: "id",
+  sourceKey: "user_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+Notification.hasOne(CreditPayments, {
+  foreignKey: "id",
+  sourceKey: "creditPaymentId",
+  constraints: false,
+  onDelete: "NO ACTION",
+});
+
+export default CreditPayments;