@winible/winible-typed 1.0.0

package/typed-model/subscription.ts

@@ -0,0 +1,170 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+} from "sequelize";
+import { ProcessorId } from "./customer-profile";
+
+import sequelize from "./pb-sequelize";
+import PhoneOwner from "./phone-owner";
+import PhoneUser from "./phone-user";
+import SubscriptionPromotion from "./subscription-promotion";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class Subscription extends Model<
+  InferAttributes<Subscription>,
+  InferCreationAttributes<Subscription>
+> {
+  // '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 subscriptionPlanId: string;
+  declare processorId: ProcessorId;
+  declare paypalSubscriptionId?: string;
+  declare paypalOrderId?: string;
+  declare paypalBillingToken?: string;
+  declare lastPaymentDate?: Date;
+  declare cancelDate?: Date;
+  declare pkSubscriptionId?: string;
+  declare numberOfPayments?: number;
+  declare subscriptionPromotionId?: string;
+  declare stale: CreationOptional<boolean>;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+
+  static getById: (id: string) => Promise<Subscription | null>;
+  static getByUserId: (userId: string) => Promise<Subscription | null>;
+  static getBySubscriptionPlanId: (
+    subscriptionPlanId: string
+  ) => Promise<Subscription | null>;
+  static getByPaypalSubscriptionId: (
+    paypalSubscriptionId: string
+  ) => Promise<Subscription | null>;
+}
+
+Subscription.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    userId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "user_id",
+    },
+    subscriptionPlanId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "subscription_plan_id",
+    },
+    paypalSubscriptionId: {
+      type: DataTypes.STRING,
+      field: "paypal_subscription_id",
+    },
+    paypalOrderId: {
+      type: DataTypes.STRING,
+      field: "paypal_order_id",
+    },
+    paypalBillingToken: {
+      type: DataTypes.STRING,
+      field: "paypal_billing_token",
+    },
+    lastPaymentDate: {
+      type: DataTypes.DATE,
+      field: "last_payment_date",
+    },
+    cancelDate: {
+      type: DataTypes.DATE,
+      field: "cancel_date",
+    },
+    pkSubscriptionId: {
+      type: DataTypes.STRING,
+      field: "pk_subscription_id",
+    },
+    numberOfPayments: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
+      field: "number_of_payments",
+    },
+    subscriptionPromotionId: {
+      type: DataTypes.BIGINT,
+      field: "subscription_promotion_id",
+    },
+    processorId: {
+      type: DataTypes.STRING,
+      field: "processor_id",
+      defaultValue: ProcessorId.HUMBOLDT,
+    },
+    stale: {
+      type: DataTypes.BOOLEAN,
+      field: "stale",
+      defaultValue: false,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "subscriptions",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+Subscription.getById = async (id: string) => {
+  return await Subscription.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+Subscription.getByUserId = async (userId: string) => {
+  return await Subscription.findOne({
+    where: {
+      userId,
+    },
+  });
+};
+
+Subscription.getBySubscriptionPlanId = async (subscriptionPlanId: string) => {
+  return await Subscription.findOne({
+    where: {
+      subscriptionPlanId,
+    },
+  });
+};
+
+Subscription.getByPaypalSubscriptionId = async (
+  paypalSubscriptionId: string
+) => {
+  return await Subscription.findOne({
+    where: {
+      paypalSubscriptionId,
+    },
+  });
+};
+
+Subscription.hasOne(SubscriptionPromotion, {
+  foreignKey: "id",
+  sourceKey: "subscriptionPromotionId",
+});
+SubscriptionPromotion.hasMany(Subscription, {
+  foreignKey: "subscription_plan_id",
+});
+Subscription.hasOne(PhoneUser, { foreignKey: "id", sourceKey: "userId" });
+PhoneUser.hasMany(Subscription, { foreignKey: "user_id", sourceKey: "id" });
+
+export default Subscription;

package/typed-model/twilio-phone.ts

@@ -0,0 +1,149 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import client = require("twilio");
+const accountSid = process.env.TWILIO_ACCOUNT_SID;
+const authToken = process.env.TWILIO_AUTH_TOKEN;
+let twilioClient = client(accountSid, authToken);
+
+// order of InferAttributes & InferCreationAttributes is important.
+class TwilioPhone extends Model<
+  InferAttributes<TwilioPhone>,
+  InferCreationAttributes<TwilioPhone>
+> {
+  // '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 phone: string;
+  declare type: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static getByPhone: (phone: string) => Promise<TwilioPhone | null>;
+  static getById: (id: string) => Promise<TwilioPhone | null>;
+  static getOrCreateByPhone: (phone: string) => Promise<any>;
+  static getAvailableChatPhone: (
+    userId: string,
+    ownerId: string
+  ) => Promise<TwilioPhone | null>;
+  static sendMessageFromNumberToPhone: (
+    fromNumber: string,
+    phone: string,
+    message: string,
+    media?: string
+  ) => Promise<any>;
+  static sendMessageToPhone: (
+    twilioPhone: { phone: string },
+    phone: string,
+    message: string,
+    media?: string
+  ) => Promise<any>;
+}
+
+TwilioPhone.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    phone: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      field: "phone",
+      unique: true,
+    },
+    type: {
+      type: DataTypes.STRING,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "twilio_phones",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+TwilioPhone.getByPhone = async (phone: string) => {
+  return await TwilioPhone.findOne({
+    where: {
+      phone,
+    },
+  });
+};
+
+TwilioPhone.getById = async (id: string) => {
+  return await TwilioPhone.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+TwilioPhone.getOrCreateByPhone = async (phone: string) => {
+  let phoneObject = await TwilioPhone.getByPhone(phone);
+
+  if (phoneObject) {
+    return phoneObject;
+  }
+
+  throw new Error("This phone does not exist");
+};
+
+TwilioPhone.getAvailableChatPhone = async (userId: string, ownerId: string) => {
+  let phone = await TwilioPhone.findOne({
+    where: sequelize.literal(`
+			type='chat' AND id NOT IN 
+				(SELECT tp.id FROM twilio_phones tp
+					JOIN chats ch on ch.twilio_phone_id = tp.id
+					JOIN chat_participants cps on cps.chat_id = ch.id
+					WHERE type = 'chat' AND (ch.owner_id = ${ownerId} OR cps.user_id = ${userId}))
+			`),
+  });
+
+  return phone;
+};
+
+TwilioPhone.sendMessageFromNumberToPhone = async (
+  fromNumber: string,
+  phone: string,
+  message: string,
+  media?: string
+) => {
+  return await twilioClient.messages.create({
+    body: message || "",
+    from: fromNumber,
+    to: phone,
+    mediaUrl: media,
+  });
+};
+
+TwilioPhone.sendMessageToPhone = async (
+  twilioPhone: { phone: string },
+  phone: string,
+  message: string,
+  media?: string
+) => {
+  return await twilioClient.messages.create({
+    body: message || "",
+    from: twilioPhone.phone,
+    to: phone,
+    mediaUrl: media,
+  });
+};
+
+export default TwilioPhone;

package/typed-model/user-follow.ts

@@ -0,0 +1,141 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import Notification from "./notification";
+import PhoneUser from "./phone-user";
+import PhoneOwner from "./phone-owner";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class UserFollow extends Model<
+  InferAttributes<UserFollow>,
+  InferCreationAttributes<UserFollow>
+> {
+  // '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 active?: boolean;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static getAllByUserId: (
+    userId: string,
+    ownerId: string
+  ) => Promise<UserFollow[]>;
+  static getByUserIdAndOwnerId: (
+    userId: string,
+    ownerId: string
+  ) => Promise<UserFollow | null>;
+  static createByUserIdAndOwnerId: (
+    userId: string,
+    ownerId: string
+  ) => Promise<any>;
+}
+
+UserFollow.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,
+      field: "owner_id",
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      field: "active",
+      defaultValue: true,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "user_follows",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+UserFollow.getAllByUserId = async (userId: string, ownerId: string) => {
+  return await UserFollow.findAll({
+    where: {
+      userId,
+      active: true,
+    },
+  });
+};
+
+UserFollow.getByUserIdAndOwnerId = async (userId: string, ownerId: string) => {
+  return await UserFollow.findOne({
+    where: {
+      userId,
+      ownerId,
+    },
+  });
+};
+
+UserFollow.createByUserIdAndOwnerId = async (
+  userId: string,
+  ownerId: string
+) => {
+  let follow = await UserFollow.getByUserIdAndOwnerId(userId, ownerId);
+  if (!follow) {
+    follow = await UserFollow.create({ userId, ownerId });
+    try {
+      await Notification.create({
+        ownerId,
+        userId,
+        userFollowId: follow.id,
+        type: "follow",
+      });
+    } catch (err) {
+      console.log(err);
+    }
+  }
+  follow.active = true;
+  await follow.save();
+  return follow;
+};
+
+PhoneUser.hasMany(UserFollow, {
+  foreignKey: "user_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+PhoneOwner.hasMany(UserFollow, {
+  foreignKey: "owner_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+UserFollow.hasOne(PhoneUser, {
+  sourceKey: "user_id",
+  foreignKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+Notification.hasOne(UserFollow, {
+  foreignKey: "id",
+  sourceKey: "userFollowId",
+  constraints: false,
+});
+
+export default UserFollow;

package/typed-model/verification-code.ts

@@ -0,0 +1,74 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class VerificationCode extends Model<
+  InferAttributes<VerificationCode>,
+  InferCreationAttributes<VerificationCode>
+> {
+  // '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 code: string;
+  declare verified?: boolean;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static createCode: (userId: string) => Promise<VerificationCode>;
+}
+
+VerificationCode.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    userId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "user_id",
+    },
+    code: {
+      type: DataTypes.STRING,
+      field: "code",
+    },
+    verified: {
+      type: DataTypes.BOOLEAN,
+      field: "verified",
+      defaultValue: false,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "verification_codes",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+VerificationCode.createCode = async (userId: string) => {
+  let code = Math.floor(100000 + Math.random() * 900000) + "";
+  return await VerificationCode.create({
+    userId,
+    code,
+  });
+};
+
+export default VerificationCode;