@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Billing.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Billing = exports.PaymentStatus = exports.ProductCatalog = exports.ProductLevel = exports.Interval = exports.TransactionTopic = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const Struct_1 = require("../../util/Struct");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const NumberFormat_1 = require("../../util/NumberFormat");
+const Operation_1 = require("../markup/Operation");
+const ArrayView_1 = require("./ArrayView");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Time_1 = require("./Time");
+var TransactionTopic;
+(function (TransactionTopic) {
+    TransactionTopic["START_7_DAY_TRIAL"] = "START_7_DAY_TRIAL";
+    TransactionTopic["APPLY_COUPON"] = "APPLY_COUPON";
+    TransactionTopic["PAYMENT_SUCCESS"] = "PAYMENT_SUCCESS";
+    TransactionTopic["PAYMENT_FAIL"] = "PAYMENT_FAIL";
+    TransactionTopic["CANCEL_SUBSCRIPTION"] = "CANCEL_SUBSCRIPTION";
+    TransactionTopic["RESTART_SUBSCRIPTION"] = "RESTART_SUBSCRIPTION";
+})(TransactionTopic || (exports.TransactionTopic = TransactionTopic = {}));
+var Interval;
+(function (Interval) {
+    Interval["MONTHLY"] = "MONTHLY";
+    Interval["ANNUAL"] = "ANNUAL";
+})(Interval || (exports.Interval = Interval = {}));
+;
+var ProductLevel;
+(function (ProductLevel) {
+    ProductLevel["FREE"] = "FREE";
+    ProductLevel["BASIC"] = "BASIC";
+    ProductLevel["PRO"] = "PRO";
+})(ProductLevel || (exports.ProductLevel = ProductLevel = {}));
+;
+;
+class ProductCatalog {
+    constructor(config) {
+        this.productsById = new Map();
+        this.pricesById = new Map();
+        this.plansById = new Map();
+        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);
+        }
+    }
+    getProductById(id) {
+        return this.productsById.get(id);
+    }
+    getPriceById(id) {
+        return this.pricesById.get(id);
+    }
+    getPlanById(id) {
+        return this.plansById.get(id);
+    }
+    getProductsByPredicate(predicate) {
+        const products = [];
+        for (const product of this.productsById.values()) {
+            if (predicate(product)) {
+                products.push(product);
+            }
+        }
+        return products;
+    }
+    getPricesByPredicate(predicate) {
+        const prices = [];
+        for (const price of this.pricesById.values()) {
+            if (predicate(price)) {
+                prices.push(price);
+            }
+        }
+        return prices;
+    }
+    getPlansByPredicate(predicate) {
+        const plans = [];
+        for (const plan of this.plansById.values()) {
+            if (predicate(plan)) {
+                plans.push(plan);
+            }
+        }
+        return plans;
+    }
+}
+exports.ProductCatalog = ProductCatalog;
+// TODO: cleanup "PRE_TRIAL" status, and update all users who have this status
+var PaymentStatus;
+(function (PaymentStatus) {
+    PaymentStatus["PRE_TRIAL"] = "PRE_TRIAL";
+    PaymentStatus["IN_TRIAL"] = "IN_TRIAL";
+    PaymentStatus["PAID"] = "PAID";
+    PaymentStatus["UNPAID"] = "UNPAID";
+    PaymentStatus["CANCELLED"] = "CANCELLED";
+})(PaymentStatus || (exports.PaymentStatus = PaymentStatus = {}));
+class Billing extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+        this._transactionsView = new ArrayView_1.ArrayView(this, ['payload', 'transactions']);
+    }
+    get payload() {
+        this.checkDisposed("Billing.payload");
+        return this.doc.data.payload;
+    }
+    static makeBillingId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.BILLING);
+    }
+    static create(userId, payload, createdAt) {
+        // Billing creation always happens in UTC time
+        const now = Time_1.MultiClock.utcNow();
+        // If the createdAt time is not provided, use the current time
+        createdAt ??= now;
+        const billingId = Billing.makeBillingId(userId);
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: billingId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.BILLING,
+                id: billingId,
+                owner: userId,
+                created_at: createdAt,
+                updated_at: now,
+            },
+            payload: payload
+        });
+    }
+    isSubscribedToPricedProduct() {
+        this.checkDisposed("Billing.isSubscribedToPricedProduct");
+        return this.priceId != null && this.productId != null;
+    }
+    get priceId() {
+        this.checkDisposed("Billing.priceId");
+        return this.payload.price_id || null;
+    }
+    setPriceId(value) {
+        this.checkDisposed("Billing.setPriceId");
+        if (this.payload.price_id !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'price_id'], value);
+            batch.commit();
+        }
+    }
+    get productId() {
+        this.checkDisposed("Billing.productId");
+        return this.payload.product_id || null;
+    }
+    setProductId(value) {
+        this.checkDisposed("Billing.setProductId");
+        if (this.payload.product_id !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'product_id'], value);
+            batch.commit();
+        }
+    }
+    get paidUntil() {
+        this.checkDisposed("Billing.paidUntil");
+        return this.payload.paid_until;
+    }
+    setPaidUntil(value) {
+        this.checkDisposed("Billing.setPaidUntil");
+        if (this.paidUntil !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'paid_until'], value);
+            batch.commit();
+        }
+    }
+    get paymentStatus() {
+        this.checkDisposed("Billing.paymentStatus");
+        return this.payload.payment_status;
+    }
+    setPaymentStatus(value) {
+        this.checkDisposed("Billing.setPaymentStatus");
+        if (this.paymentStatus !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'payment_status'], value);
+            batch.commit();
+        }
+    }
+    get stripeCustomerId() {
+        this.checkDisposed("Billing.stripeCustomerId");
+        return this.payload.stripe_customer_id;
+    }
+    setStripeCustomerId(value) {
+        this.checkDisposed("Billing.setStripeCustomerId");
+        if (this.stripeCustomerId !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'stripe_customer_id'], value);
+            batch.commit();
+        }
+    }
+    get stripePaymentMethodId() {
+        this.checkDisposed("Billing.stripePaymentMethodId");
+        return this.payload.stripe_payment_method_id;
+    }
+    setStripePaymentMethodId(value) {
+        this.checkDisposed("Billing.setStripePaymentMethodId");
+        if (this.stripeCustomerId !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'stripe_payment_method_id'], value);
+            batch.commit();
+        }
+    }
+    get stripePaymentMethodType() {
+        this.checkDisposed("Billing.stripePaymentMethodType");
+        return this.payload.stripe_payment_method_id;
+    }
+    setStripePaymentMethodType(value) {
+        this.checkDisposed("Billing.setStripePaymentMethodType");
+        if (this.stripeCustomerId !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'stripe_payment_method_type'], value);
+            batch.commit();
+        }
+    }
+    get creditCard() {
+        this.checkDisposed("Billing.creditCard");
+        return this.payload.credit_card;
+    }
+    setCreditCard(value) {
+        this.checkDisposed("Billing.setCreditCard");
+        if (this.creditCard != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'credit_card'], value);
+            batch.commit();
+        }
+    }
+    get transactions() {
+        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.
+    get sortedTransactions() {
+        this.checkDisposed("Billing.sortedTransactions");
+        return Struct_1.Struct.clone(this._transactionsView.values).sort((a, b) => {
+            return Time_1.Time.compareDateTime(a.at_utc_time, b.at_utc_time);
+        });
+    }
+    getLastTransaction() {
+        this.checkDisposed("Billing.getLastTransaction");
+        if (this._transactionsView.length > 0) {
+            const transactions = this.sortedTransactions;
+            return transactions[transactions.length - 1];
+        }
+        else {
+            return null;
+        }
+    }
+    getLastPaymentTransaction() {
+        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 = transactions[i];
+            const topic = transaction.topic;
+            if (topic === TransactionTopic.PAYMENT_FAIL || topic === TransactionTopic.PAYMENT_SUCCESS) {
+                return transaction;
+            }
+        }
+        return null;
+    }
+    getActiveUserCoupon() {
+        this.checkDisposed("Billing.getActiveUserCoupon");
+        const nowInSeconds = (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 = transaction.topic;
+            if (topic === TransactionTopic.CANCEL_SUBSCRIPTION) {
+                return null;
+            }
+            if (topic === TransactionTopic.APPLY_COUPON) {
+                const discount = transaction.details;
+                const coupon = discount.coupon;
+                if (coupon.duration === "forever" || (nowInSeconds >= discount.start && nowInSeconds <= discount.end)) {
+                    return coupon;
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    daysPastDue() {
+        this.checkDisposed("Billing.daysPastDue");
+        const daysSincePaidUntil = Time_1.Time.timeSince(this.paidUntil, 'days');
+        return daysSincePaidUntil < 0 ? 0 : daysSincePaidUntil;
+    }
+    didLastPaymentFail() {
+        this.checkDisposed("Billing.didLastPaymentFail");
+        const t = this.getLastPaymentTransaction();
+        return t != null && t.topic === TransactionTopic.PAYMENT_FAIL;
+    }
+    didLastPaymentSucceed() {
+        this.checkDisposed("Billing.didLastPaymentSucceed");
+        const t = this.getLastPaymentTransaction();
+        return t != null && t.topic === TransactionTopic.PAYMENT_SUCCESS;
+    }
+    findTransactionByTopic(topic) {
+        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 = transactions[i];
+            if (transaction.topic === topic) {
+                return transaction;
+            }
+        }
+        return null;
+    }
+    cancel() {
+        this.checkDisposed("Billing.cancel");
+        const now = Time_1.MultiClock.utcNow();
+        const transaction = {
+            at_utc_time: now.utc_time,
+            topic: TransactionTopic.CANCEL_SUBSCRIPTION
+        };
+        const batch = new Operation_1.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();
+    }
+    restartPlan(plan, paidUntilEpochSeconds) {
+        this.checkDisposed("Billing.restartPlan");
+        const now = Time_1.MultiClock.utcNow();
+        const transaction = {
+            at_utc_time: now.utc_time,
+            topic: TransactionTopic.RESTART_SUBSCRIPTION
+        };
+        const batch = new Operation_1.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_1.Time.utcFromEpochSeconds(paidUntilEpochSeconds));
+        batch.setPathValue(['payload', 'payment_status'], PaymentStatus.PAID);
+        batch.commit();
+    }
+    restartPricedProduct(productId, priceId, paidUntilEpochSeconds) {
+        this.checkDisposed("Billing.restartPricedProduct");
+        const now = Time_1.MultiClock.utcNow();
+        const transaction = {
+            at_utc_time: now.utc_time,
+            topic: TransactionTopic.RESTART_SUBSCRIPTION
+        };
+        const batch = new Operation_1.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_1.Time.utcFromEpochSeconds(paidUntilEpochSeconds));
+        batch.setPathValue(['payload', 'payment_status'], PaymentStatus.PAID);
+        batch.commit();
+    }
+    static async findByStripeCustomerId(stripeCustomerId) {
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        return shareSync.findAndAcquire(ContentKind_1.ContentKind.BILLING, { "payload.stripe_customer_id": stripeCustomerId });
+    }
+    static describeCoupon(coupon) {
+        let description = "";
+        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_1.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;
+    }
+    static normalizeCreditCardBrand(brand) {
+        const lowerCaseNoSpaces = 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;
+    }
+}
+exports.Billing = Billing;

package/dist/models/content/Book.d.ts

@@ -0,0 +1,77 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from "../../repo/ShareSync";
+import { ArrayView } from './ArrayView';
+import { ContentBody, ContentId, ContentMeta, ContentRef } from './Content';
+import { Context } from './Context';
+import { ExportOptions } from "./ExportOptions";
+import { Fragment } from "./Fragment";
+import { ContentStub, Stub } from "./Stub";
+export declare enum BookType {
+    FICTION = "fiction",
+    NONFICTION = "non-fiction",
+    EMPTY = "empty"
+}
+export declare enum BookStubArrayKey {
+    MANUSCRIPT = "manuscript",
+    NOTEBOOK = "notebook",
+    TRASH = "trash"
+}
+export interface BookPayload {
+    name: string;
+    subtitle: string;
+    synopsis_ref: ContentRef;
+    cover_media_ref: ContentId;
+    author: string;
+    contributors: ContentId[];
+    copyright: string;
+    publisher: string;
+    isbn: string;
+    manuscript: Stub[];
+    notebook: Stub[];
+    export_options: ExportOptions;
+    trash: Stub[];
+    total_word_count: number;
+}
+export interface BookBody extends ContentBody {
+    meta: ContentMeta;
+    payload: BookPayload;
+}
+export declare class Book extends Context {
+    private _manuscriptView;
+    private _notebookView;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): BookPayload;
+    static create(userId: ContentId, template: BookType): Book;
+    get coverMediaRef(): ContentId;
+    setCoverMediaRef(value: ContentId): void;
+    get synopsisRef(): ContentRef;
+    setSynopsisId(value: ContentRef): void;
+    get name(): string;
+    setName(value: string): void;
+    get subtitle(): string;
+    setSubtitle(value: string): void;
+    get author(): string;
+    setAuthor(value: string): void;
+    get copyright(): string;
+    setCopyright(value: string): void;
+    get publisher(): string;
+    setPublisher(value: string): void;
+    get isbn(): string;
+    setIsbn(value: string): void;
+    get totalWordCount(): number;
+    get manuscript(): ArrayView<Stub>;
+    get notebook(): ArrayView<Stub>;
+    get exportOptions(): ExportOptions;
+    replaceExportOptions(newOptions: ExportOptions): void;
+    getStubArrayKeys(): BookStubArrayKey[];
+    getStubArrayView(key: BookStubArrayKey): ArrayView<Stub>;
+    addFragmentToManuscript(fragment: Fragment, activeId: ContentId): void;
+    addFragmentToNotebook(fragment: Fragment, activeId?: ContentId): void;
+    updateWordCount(): Promise<void>;
+    getAllCategories(context: BookStubArrayKey): string[];
+    getPlaceholder(): string;
+    asStub(): ContentStub;
+    static harvestUniqueCategories(bookPayload: BookPayload, context: BookStubArrayKey): string[];
+    mergeIncomingContext(incomingBook: BookBody): boolean;
+}