@shaxpir/duiduidui-models 1.0.0

package/lib/models/content/Billing.ts

@@ -0,0 +1,558 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { Struct } from '../../util/Struct';
+import { CachingHasher } from '../../util/CachingHasher';
+import { NumberFormat } from "../../util/NumberFormat";
+import { BatchOperation } from '../markup/Operation';
+import { ArrayView } from './ArrayView';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { ContentKind } from './ContentKind';
+import { CompactDateTime, MultiClock, MultiTime, Time } from './Time';
+
+export interface CreditCardHarvest {
+  name:string;
+  number:string;
+  cvc:string;
+  exp_month:string;
+  exp_year:string;
+}
+
+export interface CreditCard {
+  name:string;
+  brand:string;
+  last4:string;
+  exp_month:string;
+  exp_year:string;
+  country:string;
+  funding:string;
+  wallet?:string;
+}
+
+export interface TransactionPayload {
+  at_utc_time?:CompactDateTime;
+  topic:TransactionTopic;
+  details?:any;
+}
+
+export enum TransactionTopic {
+
+  START_7_DAY_TRIAL = "START_7_DAY_TRIAL",
+
+  APPLY_COUPON = "APPLY_COUPON",
+
+  PAYMENT_SUCCESS = "PAYMENT_SUCCESS",
+  PAYMENT_FAIL = "PAYMENT_FAIL",
+
+  CANCEL_SUBSCRIPTION = "CANCEL_SUBSCRIPTION",
+  RESTART_SUBSCRIPTION = "RESTART_SUBSCRIPTION"
+}
+
+export enum Interval {
+  MONTHLY = "MONTHLY",
+  ANNUAL =  "ANNUAL",
+};
+
+export enum ProductLevel {
+  FREE = "FREE",
+  BASIC = "BASIC",
+  PRO = "PRO",
+};
+
+export interface BillingProduct {
+  id:string;
+  name:string;
+  level:ProductLevel;
+};
+
+export interface BillingPrice {
+  id:string;
+  name:string;
+  amount:number;
+  interval:Interval;
+  product_id:string;
+  trial_days:number;
+}
+
+export interface BillingPlan {
+  id:string;
+  name:string;
+  amount:number;
+  level:ProductLevel;
+  interval:Interval;
+  trial_days:number;
+}
+
+export interface ProductCatalogConfig {
+  products:BillingProduct[];
+  prices:BillingPrice[];
+  plans:BillingPlan[];
+}
+
+export class ProductCatalog {
+
+  private productsById:Map<string,BillingProduct>;
+  private pricesById:Map<string,BillingPrice>;
+  private plansById:Map<string,BillingPlan>;
+
+  constructor(config:ProductCatalogConfig) {
+    this.productsById = new Map<string,BillingProduct>();
+    this.pricesById = new Map<string,BillingPrice>();
+    this.plansById = new Map<string,BillingPlan>();
+    for (const product of config.products) {
+      this.productsById.set(product.id, product);
+    }
+    for (const price of config.prices) {
+      this.pricesById.set(price.id, price);
+    }
+    for (const plan of config.plans) {
+      this.plansById.set(plan.id, plan);
+    }
+  }
+
+  public getProductById(id:string):BillingProduct {
+    return this.productsById.get(id);
+  }
+
+  public getPriceById(id:string):BillingPrice {
+    return this.pricesById.get(id);
+  }
+
+  public getPlanById(id:string):BillingPlan {
+    return this.plansById.get(id);
+  }
+
+  public getProductsByPredicate(
+    predicate:(product:BillingProduct) => boolean
+  ):BillingProduct[] {
+    const products:BillingProduct[] = [];
+    for (const product of this.productsById.values()) {
+      if (predicate(product)) {
+        products.push(product);
+      }
+    }
+    return products;
+  }
+
+  public getPricesByPredicate(
+    predicate:(price:BillingPrice) => boolean
+  ):BillingPrice[] {
+    const prices:BillingPrice[] = [];
+    for (const price of this.pricesById.values()) {
+      if (predicate(price)) {
+        prices.push(price);
+      }
+    }
+    return prices;
+  }
+
+  public getPlansByPredicate(
+    predicate:(plan:BillingPlan) => boolean
+  ):BillingPlan[] {
+    const plans:BillingPlan[] = [];
+    for (const plan of this.plansById.values()) {
+      if (predicate(plan)) {
+        plans.push(plan);
+      }
+    }
+    return plans;
+  }
+}
+
+// TODO: cleanup "PRE_TRIAL" status, and update all users who have this status
+export enum PaymentStatus {
+  PRE_TRIAL = "PRE_TRIAL",
+  IN_TRIAL = "IN_TRIAL",
+  PAID = "PAID",
+  UNPAID = "UNPAID",
+  CANCELLED = "CANCELLED",
+}
+
+export interface BillingBody extends ContentBody {
+  meta:ContentMeta;
+  payload:BillingPayload;
+}
+
+export interface BillingPayload {
+  payment_status:PaymentStatus;
+  paid_until:CompactDateTime;
+  stripe_customer_id:string;
+  stripe_payment_method_id?:string;
+  stripe_payment_method_type?:string;
+  transactions:TransactionPayload[];
+  credit_card?:CreditCard;
+  product_id?:string;
+  price_id?:string;
+}
+
+export class Billing extends Content {
+
+  private _transactionsView:ArrayView<TransactionPayload>;
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+    this._transactionsView = new ArrayView<TransactionPayload>(this, [ 'payload', 'transactions' ]);
+  }
+
+  public get payload():BillingPayload {
+    this.checkDisposed("Billing.payload");
+    return this.doc.data.payload as BillingPayload;
+  }
+
+  public static makeBillingId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5ContentId(userId + "-" + ContentKind.BILLING);
+  }
+
+  public static create(
+    userId:ContentId,
+    payload:BillingPayload,
+    createdAt?:MultiTime
+  ):Billing {
+    // Billing creation always happens in UTC time
+    const now = MultiClock.utcNow();
+    // If the createdAt time is not provided, use the current time
+    createdAt ??= now;
+    const billingId = Billing.makeBillingId(userId);
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : billingId,
+          is_head : true,
+          kind : ContentKind.BILLING,
+          id : billingId,
+          owner : userId,
+          created_at : createdAt,
+          updated_at : now,
+        },
+        payload : payload
+      }
+    ) as Billing;
+  }
+
+  public isSubscribedToPricedProduct():boolean {
+    this.checkDisposed("Billing.isSubscribedToPricedProduct");
+    return this.priceId != null && this.productId != null;
+  }
+
+  public get priceId():string {
+    this.checkDisposed("Billing.priceId");
+    return this.payload.price_id || null;
+  }
+  public setPriceId(value:string) {
+    this.checkDisposed("Billing.setPriceId");
+    if (this.payload.price_id !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'price_id' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get productId():string {
+    this.checkDisposed("Billing.productId");
+    return this.payload.product_id || null;
+  }
+  public setProductId(value:string) {
+    this.checkDisposed("Billing.setProductId");
+    if (this.payload.product_id !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'product_id' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get paidUntil():CompactDateTime {
+    this.checkDisposed("Billing.paidUntil");
+    return this.payload.paid_until;
+  }
+  public setPaidUntil(value:CompactDateTime) {
+    this.checkDisposed("Billing.setPaidUntil");
+    if (this.paidUntil !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'paid_until' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get paymentStatus():PaymentStatus {
+    this.checkDisposed("Billing.paymentStatus");
+    return this.payload.payment_status;
+  }
+  public setPaymentStatus(value:PaymentStatus) {
+    this.checkDisposed("Billing.setPaymentStatus");
+    if (this.paymentStatus !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'payment_status' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get stripeCustomerId():string {
+    this.checkDisposed("Billing.stripeCustomerId");
+    return this.payload.stripe_customer_id;
+  }
+  public setStripeCustomerId(value:string) {
+    this.checkDisposed("Billing.setStripeCustomerId");
+    if (this.stripeCustomerId !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'stripe_customer_id' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get stripePaymentMethodId():string {
+    this.checkDisposed("Billing.stripePaymentMethodId");
+    return this.payload.stripe_payment_method_id;
+  }
+  public setStripePaymentMethodId(value:string) {
+    this.checkDisposed("Billing.setStripePaymentMethodId");
+    if (this.stripeCustomerId !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'stripe_payment_method_id' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get stripePaymentMethodType():string {
+    this.checkDisposed("Billing.stripePaymentMethodType");
+    return this.payload.stripe_payment_method_id;
+  }
+  public setStripePaymentMethodType(value:string) {
+    this.checkDisposed("Billing.setStripePaymentMethodType");
+    if (this.stripeCustomerId !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'stripe_payment_method_type' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get creditCard():CreditCard {
+    this.checkDisposed("Billing.creditCard");
+    return this.payload.credit_card;
+  }
+  public setCreditCard(value:CreditCard) {
+    this.checkDisposed("Billing.setCreditCard");
+    if (this.creditCard != value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'credit_card' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get transactions():ArrayView<TransactionPayload> {
+    this.checkDisposed("Billing.transactions");
+    return this._transactionsView;
+  }
+
+  // Somehow, the transactions array on many users is not in the correct order. Some users have
+  // transactions in reverse order, and some have transactions in random order. Eventually, we
+  // will correct the stored data, but for now, we will clone the transactions array and sort it
+  // by the transaction time, so that we can correctly iterate through the transactions.
+  public get sortedTransactions():TransactionPayload[] {
+    this.checkDisposed("Billing.sortedTransactions");
+    return Struct.clone(this._transactionsView.values).sort(
+      (a:TransactionPayload, b:TransactionPayload) => {
+        return Time.compareDateTime(a.at_utc_time, b.at_utc_time);
+      }
+    );
+  }
+
+  public getLastTransaction():TransactionPayload {
+    this.checkDisposed("Billing.getLastTransaction");
+    if (this._transactionsView.length > 0) {
+      const transactions = this.sortedTransactions;
+      return transactions[transactions.length - 1];
+    } else {
+      return null;
+    }
+  }
+
+  public getLastPaymentTransaction():TransactionPayload {
+    this.checkDisposed("Billing.getLastPaymentTransaction");
+    // Starts iterating from the most-recent transaction, so this function will
+    // return only the most-recent matching transaction.
+    const transactions = this.sortedTransactions;
+    for (let i = transactions.length - 1; i >= 0; i--) {
+      const transaction:TransactionPayload = transactions[i];
+      const topic:TransactionTopic = transaction.topic;
+      if (topic === TransactionTopic.PAYMENT_FAIL || topic === TransactionTopic.PAYMENT_SUCCESS) {
+        return transaction;
+      }
+    }
+    return null;
+  }
+
+  public getActiveUserCoupon():any {
+    this.checkDisposed("Billing.getActiveUserCoupon");
+    const nowInSeconds:number = (new Date()).getTime() / 1000;
+    // Coupons with a duration of "once" or "forever" have a null "end" value. We treat "once" coupons
+    // as being still-in-effect until a payment on the next invoice is attempted (either a pass or fail
+    // tells us that the billing period has completed).
+    const transactions = this.sortedTransactions;
+    for (let i = transactions.length - 1; i >= 0; i--) {
+      const transaction = transactions[i];
+      const topic:TransactionTopic = transaction.topic;
+      if (topic === TransactionTopic.CANCEL_SUBSCRIPTION) {
+        return null;
+      }
+     if (topic === TransactionTopic.APPLY_COUPON) {
+        const discount:any = transaction.details;
+        const coupon:any = discount.coupon;
+        if (coupon.duration === "forever" || (nowInSeconds >= discount.start && nowInSeconds <= discount.end)) {
+          return coupon;
+        } else {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+
+  public daysPastDue():number {
+    this.checkDisposed("Billing.daysPastDue");
+    const daysSincePaidUntil:number = Time.timeSince(this.paidUntil, 'days');
+    return daysSincePaidUntil < 0 ? 0 : daysSincePaidUntil;
+  }
+
+  public didLastPaymentFail():boolean {
+    this.checkDisposed("Billing.didLastPaymentFail");
+    const t:TransactionPayload = this.getLastPaymentTransaction();
+    return t != null && t.topic === TransactionTopic.PAYMENT_FAIL;
+  }
+
+  public didLastPaymentSucceed():boolean {
+    this.checkDisposed("Billing.didLastPaymentSucceed");
+    const t:TransactionPayload = this.getLastPaymentTransaction();
+    return t != null && t.topic === TransactionTopic.PAYMENT_SUCCESS;
+  }
+
+  public findTransactionByTopic(topic:TransactionTopic):TransactionPayload {
+    this.checkDisposed("Billing.findTransactionByTopic");
+    const transactions = this.sortedTransactions;
+    // Starts iterating from the most-recent transaction, so this function will
+    // return only the most-recent matching transaction.
+    for (let i = transactions.length - 1; i >= 0; i--) {
+      const transaction:TransactionPayload = transactions[i];
+      if (transaction.topic === topic) {
+        return transaction;
+      }
+    }
+    return null;
+  }
+
+  public cancel():void {
+    this.checkDisposed("Billing.cancel");
+
+    const now:MultiTime = MultiClock.utcNow();
+    const transaction:TransactionPayload = {
+      at_utc_time: now.utc_time,
+      topic: TransactionTopic.CANCEL_SUBSCRIPTION
+    };
+
+    const batch = new BatchOperation(this, now);
+
+    // Add a transaction to the billing model for this cancellation
+    batch.pushIntoArray([ 'payload', 'transactions' ], transaction);
+    batch.setPathValue([ 'payload', 'plan' ], null);
+    batch.setPathValue([ 'payload', 'price_id' ], null);
+    batch.setPathValue([ 'payload', 'product_id' ], null);
+    batch.setPathValue([ 'payload', 'paid_until' ], null);
+    batch.setPathValue([ 'payload', 'payment_status' ], PaymentStatus.CANCELLED);
+
+    batch.commit();
+  }
+
+  public restartPlan(
+    plan:string,
+    paidUntilEpochSeconds:number
+  ):void {
+    this.checkDisposed("Billing.restartPlan");
+
+    const now:MultiTime = MultiClock.utcNow();
+    const transaction:TransactionPayload = {
+      at_utc_time: now.utc_time,
+      topic: TransactionTopic.RESTART_SUBSCRIPTION
+    };
+
+    const batch = new BatchOperation(this, now);
+
+    // Add a transaction to the billing model for this cancellation
+    batch.pushIntoArray([ 'payload', 'transactions' ], transaction);
+    batch.setPathValue([ 'payload', 'plan' ], plan);
+    batch.setPathValue([ 'payload', 'product_id' ], null);
+    batch.setPathValue([ 'payload', 'price_id' ], null);
+    batch.setPathValue([ 'payload', 'paid_until' ], Time.utcFromEpochSeconds(paidUntilEpochSeconds));
+    batch.setPathValue([ 'payload', 'payment_status' ], PaymentStatus.PAID);
+
+    batch.commit();
+  }
+
+  public restartPricedProduct(
+    productId:string,
+    priceId:string,
+    paidUntilEpochSeconds:number
+  ):void {
+    this.checkDisposed("Billing.restartPricedProduct");
+
+    const now:MultiTime = MultiClock.utcNow();
+    const transaction:TransactionPayload = {
+      at_utc_time: now.utc_time,
+      topic: TransactionTopic.RESTART_SUBSCRIPTION
+    };
+
+    const batch = new BatchOperation(this, now);
+
+    // Add a transaction to the billing model for this cancellation
+    batch.pushIntoArray([ 'payload', 'transactions' ], transaction);
+    batch.setPathValue([ 'payload', 'plan' ], null);
+    batch.setPathValue([ 'payload', 'product_id' ], productId);
+    batch.setPathValue([ 'payload', 'price_id' ], priceId);
+    batch.setPathValue([ 'payload', 'paid_until' ], Time.utcFromEpochSeconds(paidUntilEpochSeconds));
+    batch.setPathValue([ 'payload', 'payment_status' ], PaymentStatus.PAID);
+
+    batch.commit();
+  }
+
+  public static async findByStripeCustomerId(stripeCustomerId:string):Promise<Billing[]> {
+    const shareSync = ShareSyncFactory.get();
+    return shareSync.findAndAcquire(
+      ContentKind.BILLING, { "payload.stripe_customer_id" : stripeCustomerId }
+    ) as Promise<Billing[]>;
+  }
+
+  public static describeCoupon(coupon:any):string {
+
+    let description:string = "";
+    if (coupon.hasOwnProperty("percent_off") && coupon.percent_off !== null) {
+      description = coupon.percent_off + "% OFF";
+    } else if (coupon.hasOwnProperty("amount_off") && coupon.amount_off !== null) {
+      description = NumberFormat.dollarsFromCents(coupon.amount_off) + " OFF";
+    }
+
+    if (coupon.duration === "forever") {
+      description += ", FOREVER";
+    } else if (coupon.duration === "once") {
+      description += " YOUR NEXT INVOICE";
+    } else if (coupon.duration === "repeating") {
+      description += " FOR " + coupon.duration_in_months +  " MONTHS";
+    }
+
+    return description;
+  }
+
+  public static normalizeCreditCardBrand(brand:string):string {
+    const lowerCaseNoSpaces:string = brand.toLowerCase().replace(/\s/g, '');
+    if (lowerCaseNoSpaces.startsWith("visa")) {
+      return "VISA";
+    } else if (lowerCaseNoSpaces.startsWith("mastercard")) {
+      return "MC";
+    } else if (lowerCaseNoSpaces.startsWith("americanexpress")) {
+      return "AMEX";
+    } else if (lowerCaseNoSpaces.startsWith("diners")) {
+      return "DINERS";
+    } else if (lowerCaseNoSpaces.startsWith("jcb")) {
+      return "JCB";
+    } else if (lowerCaseNoSpaces.startsWith("discover")) {
+      return "DISC";
+    }
+    return brand;
+  }
+}

package/lib/models/content/Content.ts

@@ -0,0 +1,110 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Struct } from '../../util/Struct';
+import { BillingPayload } from "./Billing";
+import { ContentKind } from './ContentKind';
+import { DevicePayload } from './Device';
+import { HanziPayload } from './Hanzi';
+import { Model } from './Model';
+import { PhrasePayload } from './Phrase';
+import { ProfilePayload } from "./Profile";
+import { CompactDateTime, MultiTime } from './Time';
+import { UserPayload } from './User';
+import { MediaPayload } from './Media';
+
+enum ContentIdBrand {}
+enum ContentRefBrand {}
+
+export type ContentId = string & ContentIdBrand;
+export type ContentRef = (string & ContentRefBrand) | ContentId;
+
+export interface ParsedContentRef {
+  id:ContentId;
+  kind?:ContentKind;
+  timestamp?:CompactDateTime;
+}
+
+export interface ContentBody {
+  meta:ContentMeta;
+  payload:ContentPayload;
+}
+
+export interface ContentMeta {
+  ref:ContentRef;
+  kind:ContentKind;
+  is_head:boolean;
+  id:ContentId;
+  owner:ContentId;
+  created_at:MultiTime;
+  updated_at:MultiTime;
+}
+
+export type ContentPayload =
+  BillingPayload
+| HanziPayload
+| PhrasePayload
+| DevicePayload
+| MediaPayload
+| ProfilePayload
+| UserPayload;
+
+export abstract class Content extends Model {
+
+  public static ID_LENGTH:number = 16;
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get isHead():boolean {
+    this.checkDisposed("Content.isHead");
+    return this.meta.is_head;
+  }
+
+  public get meta():ContentMeta {
+    this.checkDisposed("Content.meta");
+    return this.doc.data.meta as ContentMeta;
+  }
+
+  public get payload():ContentPayload {
+    this.checkDisposed("Content.payload");
+    return this.doc.data.payload as ContentPayload;
+  }
+
+  public cloneContentBody():ContentBody {
+    this.checkDisposed("Content.cloneContentBody");
+    if (this.exists()) {
+      return Struct.clone(this.doc.data);
+    } else {
+      return null;
+    }
+  }
+
+  public get id():ContentId {
+    this.checkDisposed("Content.id");
+    return this.meta.id as ContentId;
+  }
+
+  public get updatedAt():MultiTime {
+    this.checkDisposed("Content.updatedAt");
+    return this.meta.updated_at as MultiTime;
+  }
+
+  public get createdAt():MultiTime {
+    this.checkDisposed("Content.createdAt");
+    return this.meta.created_at as MultiTime;
+  }
+
+  public get owner():ContentId {
+    this.checkDisposed("Content.owner");
+    return this.meta.owner as ContentId;
+  }
+
+  public async modelUpdated():Promise<void> {
+    this.checkDisposed("Content.modelUpdated");
+    this.acquire();
+    await this.shareSync.updateManifestForContent(this);
+    this.release();
+  }
+
+}

package/lib/models/content/ContentKind.ts

@@ -0,0 +1,14 @@
+export enum ContentKind {
+
+  // These are all the current Content subclasses
+  BILLING = "billing",
+  DEVICE = "device",
+  METRIC = "metric",
+  PROFILE = "profile",
+  SESSION = "session",
+  USER = "user",
+  MEDIA = "media",
+
+  // These are used in the ShareDB system, but for internal bookkeeping, not for Content subclasses.
+  MANIFEST = "manifest",
+}

package/lib/models/content/DevEnv.ts

@@ -0,0 +1,5 @@
+export enum DevEnv {
+  LOCAL = "LOCAL",
+  STAGING = "STAGING",
+  PRODUCTION = "PRODUCTION",
+}