@social-mail/social-mail-web-server 1.8.495 → 1.8.499

package/src/server/model/events/VerificationTokenEvents.ts

@@ -153,8 +153,8 @@ export default class VerificationTokenEvents extends AuthenticatedEvents<Verific
                         const { email } = entity;
                         webSiteFolderID = w.folderID;
                         const user = await db.users.where({ webSiteFolderID, email }, (p) => (x) =>
-                                x.contactEmail === p.email
-                                && x.storeAccounts.some((s) => s.storeID === p.webSiteFolderID)
+                                x.storeAccounts.some((s) => s.storeID === p.webSiteFolderID
+                                && s.emails.some((e) => e.emailAddress.emailAddress === p.email))
                             )
                             .first();
                         if (user) {

package/src/server/seed/ui/seed-ui.ts

@@ -17,7 +17,7 @@ export default async function seedUI(config: DBConfig) {
     await config.saveVersion(UIPackageConfig, {
         package: "@social-mail/social-mail-client",
         view: "dist/web/AppIndex",
-        version: "1.9.121"
+        version: "1.9.126"
     });
 
     await config.saveVersion(WebComponentsPackageConfig, {

package/src/server/services/store/LedgerPaymentGateway.ts

@@ -2,6 +2,8 @@ import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
 import { StoreJournal } from "../../model/entities/StoreJournal.js";
 import StorePaymentAttempt from "../../model/entities/StorePaymentAttempt.js";
 import StorePaymentGateway from "../../model/entities/StorePaymentGateway.js";
+import StorePGSubscription from "../../model/entities/StorePGSubscription.js";
+import StoreSubscription from "../../model/entities/StoreSubscription.js";
 
 export default abstract class LedgerPaymentGateway {
 
@@ -14,4 +16,8 @@ export default abstract class LedgerPaymentGateway {
 
     abstract isSuccessful(pa: StorePaymentAttempt);
 
+    abstract createSubscription(host: string, gateway: StorePaymentGateway, subscription: StoreSubscription): Promise<{ url?, content? }>;
+
+    abstract fetchSubscriptionInfo(pgSubscription: StorePGSubscription): Promise<{ active?, error? }>;
+
 }

package/src/server/services/store/StorePaymentGatewayService.ts

@@ -5,6 +5,7 @@ import LedgerPaymentGateway from "./LedgerPaymentGateway.js";
 import XNode from "@entity-access/server-pages/dist/html/XNode.js";
 import QueueInvokeWebHookWorkflow from "../../workflows/web-hooks/QueueInvokeWebHookWorkflow.js";
 import { AppWorkflowContext } from "../../workflows/AppWorkflowContext.js";
+import StoreSubscription from "../../model/entities/StoreSubscription.js";
 
 @RegisterScoped
 export default class StorePaymentGatewayService {
@@ -87,6 +88,46 @@ export default class StorePaymentGatewayService {
         return payment;
     }
 
+    async createSubscription({ storeID, subscription ,ledgerID, host, userID }: { storeID, ledgerID?, userID?, subscription: StoreSubscription, host: string}) {
+
+        let q = this.db.storePaymentGateways.where({ storeID}, (p) => (x) =>
+            x.storeAccount.storeID === p.storeID
+        );
+
+        if (ledgerID) {
+            q = q.where({ ledgerID }, (p) => (x) => x.accountID === p.ledgerID);
+        } else{
+            q = q.where(void 0, (p) => (x) => x.isGatewayActive === true);
+        }
+
+        const gateway = await q
+            .orderByDescending(void 0, (p) => (x) => x.isDefault)
+            .first();
+
+        const pg = await LedgerPaymentGateway.for(this, gateway.paymentGateway);
+        const r = await pg.createSubscription(host, gateway, subscription);
+        await this.db.saveChanges();
+        return r;
+    }
+
+    async fetchSubscription(subscriptionID) {
+        const subscription = await this.db.storePGSubscriptions
+            .where({ subscriptionID}, (p) => (x) => x.subscriptionID === p.subscriptionID && x.active === true)
+            .include((x) => [x.gateway, x.subscription.itemPrice])
+            .first();
+
+        const { gateway } = subscription;
+
+        const pg = await LedgerPaymentGateway.for(this, gateway.paymentGateway);
+
+        const r = await pg.fetchSubscriptionInfo(subscription);
+        if (r.active) {
+            subscription.active = true;
+            await this.db.storePGSubscriptions.statements.update({ active: true}, { subscriptionID, paymentGatewayID: gateway.accountID });
+        }
+        return { ... r, subscription };
+    }
+
     private async updatePaymentStatus(orderID: any) {
 
         const order = await this.db.storeJournals.where({ orderID }, (p) => (x) => x.journalID === p.orderID)
@@ -139,4 +180,5 @@ export default class StorePaymentGatewayService {
             // });
         }
     }
+
 }

package/src/server/services/store/gateways/cashfree.tsx

@@ -0,0 +1,237 @@
+import Inject, { RegisterSingleton } from "@entity-access/entity-access/dist/di/di.js";
+import { StoreJournal } from "../../../model/entities/StoreJournal.js";
+import StorePaymentAttempt from "../../../model/entities/StorePaymentAttempt.js";
+import StorePaymentGateway from "../../../model/entities/StorePaymentGateway.js";
+import EncryptionService from "../../encryption/EncryptionService.js";
+import LedgerPaymentGateway from "../LedgerPaymentGateway.js";
+import SocialMailContext from "../../../model/SocialMailContext.js";
+import TimedCache from "@entity-access/entity-access/dist/common/cache/TimedCache.js";
+
+import { Cashfree, CFEnvironment } from "cashfree-pg";
+import HtmlDocument from "@entity-access/server-pages/dist/html/HtmlDocument.js";
+import XNode from "@entity-access/server-pages/dist/html/XNode.js";
+import StorePGSubscription from "../../../model/entities/StorePGSubscription.js";
+import StoreSubscription from "../../../model/entities/StoreSubscription.js";
+import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
+
+@RegisterSingleton
+class CashfreeClientCache {
+
+    cache = new TimedCache<any, Cashfree>();
+
+    @Inject
+    ecs: EncryptionService;
+
+    getClient(gateway: StorePaymentGateway) {
+        return this.cache.getOrCreate(gateway.accountID, gateway, (k, p) => {
+            const secret = this.ecs.secure.decrypt(p.encryptedSecret);
+
+            return new Cashfree(gateway.url ? CFEnvironment.SANDBOX : CFEnvironment.PRODUCTION,
+                gateway.clientID,
+                secret
+            );
+        });
+    }
+
+}
+
+export default class extends LedgerPaymentGateway {
+
+    @Inject
+    ecs: EncryptionService;
+
+    @Inject
+    pc: CashfreeClientCache;
+
+    @Inject
+    db: SocialMailContext;
+
+
+    async createPayment(host: string, gateway: StorePaymentGateway, order: StoreJournal, pa: StorePaymentAttempt) {
+
+        const pID = this.ecs.general.encrypt(pa.attemptID.toString());
+
+        const mode = gateway.url ? "sandbox" : "production";
+
+        const items = await this.db.storeJournalLineItems.where(order, (p) => (x) => x.journalID === p.journalID)
+            .include((x) => x.itemPrice.storeItem)
+            .toArray();
+
+        const client = this.pc.getClient(gateway);
+
+        const { emailAddress: { emailAddress: emailAddress}  } = await this.db.storeAccountEmails
+            .where(order, (p) => (x) => x.accountID === p.buyerID)
+            .include((x) => x.emailAddress)
+            .first();
+
+        const currencyCode = items[0].itemPrice.currency;
+
+
+        const { phoneNumberE64  } = await this.db.storeAccountPhones
+            .where(order, (p) => (x) => x.accountID === p.buyerID)
+            .first();
+
+        const returnUrl = `https://${host}/store/checkout-callback/${pID}`;
+
+        const pgOrder = await client.PGCreateOrder({
+            order_amount: order.total,
+            order_currency: currencyCode,
+            order_meta: {
+                return_url: returnUrl
+            },
+            customer_details: {
+                customer_id: emailAddress,
+                customer_email: emailAddress,
+                customer_phone: phoneNumberE64,
+            }
+        });
+
+        const paymentSessionId = pgOrder.data.payment_session_id;
+        pa.externalID = pgOrder.data.order_id;
+        await this.db.storePaymentAttempts.statements.update({ externalID: pa.externalID }, { attemptID: pa.attemptID });
+
+        return {
+            content: <HtmlDocument>
+                <head>
+                    <title>Creating Payment Request</title>
+                </head>
+                <body>
+                    <p>
+                        Creating Payment Request ...
+                    </p>
+                    <script src="https://sdk.cashfree.com/js/v3/cashfree.js"></script>
+                    <script>
+                        const cashfree = Cashfree({JSON.stringify({
+                            mode,
+                        })});
+                        let checkoutOptions = {JSON.stringify({
+                            paymentSessionId,
+                            redirectTarget: "_top",
+                        })};
+                        cashfree.checkout(checkoutOptions);
+                    </script>
+                </body>
+            </HtmlDocument>
+        };
+    }
+
+    async isSuccessful(pa: StorePaymentAttempt) {
+
+        const { gateway, externalID: id } = pa;
+
+        const client = this.pc.getClient(gateway);
+
+        const order = await client.PGFetchOrder(id);
+
+        if (/paid/i.test(order.data.order_status)) {
+            // let us capture...
+            return true;
+        }
+
+        return false;
+    }
+
+
+    async createSubscription(host: string, gateway: StorePaymentGateway, storeSubscription: StoreSubscription) {
+
+        try {
+            const client = this.pc.getClient(gateway);
+
+            const mode = gateway.url ? "sandbox" : "production";
+
+            const { emailAddress: { emailAddress: emailAddress}  } = await this.db.storeAccountEmails
+                .where(storeSubscription, (p) => (x) => x.accountID === p.buyerID)
+                .include((x) => x.emailAddress)
+                .first();
+
+            const { phoneNumberE64  } = await this.db.storeAccountPhones
+                .where(storeSubscription, (p) => (x) => x.accountID === p.buyerID)
+                .first();
+
+            const pID = this.ecs.general.encrypt(storeSubscription.subscriptionID.toString());
+
+            const returnUrl = `https://${host}/store/subscribe-callback/${pID}`;
+
+            const { itemPrice } = storeSubscription;
+
+            let plan_interval_type = "MONTH";
+            if (/year/i.test(itemPrice.intervalType)) {
+                plan_interval_type = "YEAR";
+            }
+
+            const sub = await client.SubsCreateSubscription({
+                subscription_meta: {
+                    return_url: returnUrl
+                },
+                plan_details: {
+                    plan_name: itemPrice.priceID.toString() + ": " + itemPrice.storeItem.name,
+                    plan_amount: Number(itemPrice.amount),
+                    plan_interval_type,
+                    plan_max_amount: Number(itemPrice.amount),
+                    plan_currency: itemPrice.currency,
+                    plan_type: "PERIODIC"
+                },
+                subscription_id: storeSubscription.subscriptionID.toString(),
+                customer_details: {
+                    customer_email: emailAddress,
+                    customer_phone: phoneNumberE64,
+                }
+            });
+
+            this.db.storePGSubscriptions.add({
+                gatewaySubscriptionID: sub.data.subscription_id,
+                active: true,
+                paymentGatewayID: gateway.accountID,
+                subscriptionID: storeSubscription.subscriptionID
+            });
+
+            await this.db.saveChanges();
+
+            const subsSessionId = sub.data.subscription_session_id;
+
+            return {
+                content: <HtmlDocument>
+                    <head>
+                        <title>Creating Payment Request</title>
+                    </head>
+                    <body>
+                        <p>
+                            Creating Payment Request ...
+                        </p>
+                        <script src="https://sdk.cashfree.com/js/v3/cashfree.js"></script>
+                        <script>
+                            const cashfree = Cashfree({JSON.stringify({
+                                mode,
+                            })});
+                            let checkoutOptions = {JSON.stringify({
+                                subsSessionId,
+                                redirectTarget: "_top",
+                            })};
+                            cashfree.subscriptionsCheckout(checkoutOptions);
+                        </script>
+                    </body>
+                </HtmlDocument>
+            };
+        } catch (error) {
+            if(error.response.data) {
+                throw new EntityAccessError(error.message, error.response.data);
+            }
+        }
+    }
+
+    async fetchSubscriptionInfo(pgSubscription: StorePGSubscription) {
+
+        const { gateway, gatewaySubscriptionID: id } = pgSubscription;
+        const client = this.pc.getClient(gateway);
+
+        const sub = await client.SubsFetchSubscription(id);
+
+        if (/ACTIVE/i.test(sub.data.subscription_status)) {
+            return {
+                active: true
+            };
+        }
+
+    }
+
+}

package/src/server/services/store/gateways/paypal.tsx

@@ -5,8 +5,16 @@ import StorePaymentGateway from "../../../model/entities/StorePaymentGateway.js"
 import EncryptionService from "../../encryption/EncryptionService.js";
 import LedgerPaymentGateway from "../LedgerPaymentGateway.js";
 import SocialMailContext from "../../../model/SocialMailContext.js";
-import { CaptureStatus, CheckoutPaymentIntent, Client, Environment, OrdersController, OrderStatus, PayeePaymentMethodPreference, PaypalExperienceLandingPage, PaypalExperienceUserAction } from "@paypal/paypal-server-sdk";
+import { CaptureStatus, CheckoutPaymentIntent, Client, Environment,
+    OrdersController, OrderStatus, PayeePaymentMethodPreference,
+    SubscriptionsController,
+    PaypalExperienceLandingPage, PaypalExperienceUserAction,
+    PlanRequestStatus,
+    IntervalUnit,
+    TenureType} from "@paypal/paypal-server-sdk";
 import TimedCache from "@entity-access/entity-access/dist/common/cache/TimedCache.js";
+import StorePGSubscription from "../../../model/entities/StorePGSubscription.js";
+import StoreSubscription from "../../../model/entities/StoreSubscription.js";
 
 @RegisterSingleton
 class PaypalClientCache {
@@ -27,7 +35,7 @@ class PaypalClientCache {
                     oAuthClientSecret: secret
                 }
             });
-        })
+        });
     }
 
 }
@@ -166,4 +174,67 @@ export default class extends LedgerPaymentGateway {
         // throw new Error("Method not implemented.");
     }
 
+    async createSubscription(host: string, gateway: StorePaymentGateway, subscription: StoreSubscription) {
+
+        const { accountID: paymentGatewayID } = gateway;
+        const { itemPrice: { priceID: itemPriceID, storeItem: { storeItemID } }} = subscription;
+
+        let pg = await this.db.storePgItemPrices.statements.select({}, { paymentGatewayID, itemPriceID});
+
+        const client = this.pc.getClient(gateway);
+        const sc = new SubscriptionsController(client);
+
+        if (!pg) {
+
+            const plan = await sc.createBillingPlan({
+                body: {
+                    name: itemPriceID.toString(),
+                    productId: storeItemID.toString(),
+                    paymentPreferences: {
+                        autoBillOutstanding: false,
+                        paymentFailureThreshold:2
+                    },
+                    billingCycles: [
+                        {
+                            frequency: {
+                                intervalUnit: IntervalUnit.Year,
+                                intervalCount: 1
+                            },
+                            sequence: 1,
+                            tenureType: TenureType.Regular,
+                        }
+                    ],
+                    quantitySupported: false,
+                    status: PlanRequestStatus.Active
+                }
+            });
+
+            pg = await this.db.storePgItemPrices.statements.selectOrInsert({
+                paymentGatewayID,
+                itemPriceID,
+                pgPriceID: plan.result.id,
+            }, {
+                paymentGatewayID,
+                itemPriceID,
+            });
+
+        }
+
+        const planId = pg.pgPriceID;
+
+        const pgSubscription = await sc.createSubscription({
+            body: {
+                planId,
+                autoRenewal: true,
+            }
+        });
+
+        return {
+            url: pgSubscription.result.links[0].href
+        };
+    }
+    async fetchSubscriptionInfo(pgSubscription: StorePGSubscription) {
+        return {};
+    }
+
 }

package/src/server/services/store/gateways/phone-pe.tsx

@@ -10,6 +10,8 @@ import XNode from "@entity-access/server-pages/dist/html/XNode.js";
 import StorePaymentAttempt from "../../../model/entities/StorePaymentAttempt.js";
 import StorePaymentGateway from "../../../model/entities/StorePaymentGateway.js";
 import SecureFetchBuilder from "../../../../common/fetch/SecureFetchBuilder.js";
+import StorePGSubscription from "../../../model/entities/StorePGSubscription.js";
+import StoreSubscription from "../../../model/entities/StoreSubscription.js";
 
 const signRequest = (id: any, salt: any, path = "/pg/v1/pay", payload: string = ""): { request: any; verify: any; } => {
     const request = Buffer.from(payload, "utf-8").toString("base64");
@@ -109,4 +111,11 @@ export default class extends LedgerPaymentGateway {
         return false;
     }
 
+    async createSubscription(host: string, gateway: StorePaymentGateway, subscription: StoreSubscription) {
+        return {};
+    }
+    async fetchSubscriptionInfo(pgSubscription: StorePGSubscription) {
+        return {};
+    }
+
 }

package/src/server/services/store/gateways/stripe.tsx

@@ -7,6 +7,8 @@ import SocialMailContext from "../../../model/SocialMailContext.js";
 
 import * as stripe from "stripe";
 import EncryptionService from "../../encryption/EncryptionService.js";
+import StorePGSubscription from "../../../model/entities/StorePGSubscription.js";
+import StoreSubscription from "../../../model/entities/StoreSubscription.js";
 
 export default class StripePaymentGateway extends LedgerPaymentGateway {
 
@@ -74,4 +76,11 @@ export default class StripePaymentGateway extends LedgerPaymentGateway {
         return s;
     }
 
+    async createSubscription(host: string, gateway: StorePaymentGateway, subscription: StoreSubscription) {
+        return {};
+    }
+    async fetchSubscriptionInfo(pgSubscription: StorePGSubscription) {
+        return {};
+    }
+
 }

package/src/wwwroot/routes/store/buy/[productID]/get.tsx

@@ -43,7 +43,7 @@ export default class extends Page {
                 currency = w.currency;
             }
 
-            const contact = await this.db.storeAccounts.where({userID }, (p) => (x) => x.accountID === p.userID)
+            const contact = await this.db.storeAccounts.where({userID }, (p) => (x) => x.userID === p.userID)
                 .include((x) => x.addresses)
                 .first() ?? EntityAccessError.throw(`Please signup as a store user instead of backend user.`);
 

package/src/wwwroot/routes/store/subscribe/[productID]/get.tsx

@@ -0,0 +1,82 @@
+import Inject from "@entity-access/entity-access/dist/di/di.js";
+import { Route } from "@entity-access/server-pages/dist/core/Route.js";
+import Page from "@entity-access/server-pages/dist/Page.js";
+import SocialMailContext from "../../../../../server/model/SocialMailContext.js";
+import StoreConfigService from "../../../../../server/services/store/StoreConfigService.js";
+import WebSiteContentService from "../../../../../server/services/files/WebSiteContentService.js";
+import StorePaymentGatewayService from "../../../../../server/services/store/StorePaymentGatewayService.js";
+import { Symbols } from "../../../../../common/Symbols.js";
+import { Prepare } from "@entity-access/server-pages/dist/decorators/Prepare.js";
+import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
+
+
+@Prepare.authorize
+export default class extends Page {
+
+    @Route
+    productID;
+
+    @Inject
+    db: SocialMailContext;
+
+    @Inject
+    storeConfigService: StoreConfigService;
+
+    @Inject
+    siteContentService: WebSiteContentService;
+
+    @Inject
+    pgs: StorePaymentGatewayService;
+
+    async run() {
+
+        // only if logged in...
+        // 1. Create order
+        // 2. Route to Checkout
+
+        let [ currency ] = this.childPath as any[];
+
+        const w = await this.siteContentService.getWebSite(this.request.hostName);
+        const storeID = w.folderID;
+
+        if (!currency) {
+            currency = w.currency;
+        }
+
+        // todo: optimization
+        // do not create new orders if new order for same item exists
+        // with only a single item...
+
+        const { productID } = this;
+
+        const { price } = await this.storeConfigService.getPrice(productID, currency, this.request.hostName, storeID);
+
+        const { userID } = this.sessionUser;
+
+        const contact = await this.db.storeAccounts.where({userID }, (p) => (x) => x.userID === p.userID)
+            .include((x) => x.addresses)
+            .first() ?? EntityAccessError.throw(`Please signup as a store user instead of backend user.`);
+
+        const subscription = this.db.storeSubscriptions.add({
+            storeID,
+            buyerID: contact.accountID,
+            status: "pending",
+            itemPrice: price
+        });
+
+        subscription[Symbols.enableSaveWithoutLogin] = true;
+
+        await this.db.saveChanges();
+
+        const host = this.request.hostName;
+
+        const c = await this.pgs.createSubscription({ storeID, subscription, host, userID: this.sessionUser.userID });
+
+        if (c.url) {
+            return this.redirect(c.url);
+        }
+
+        return this.content({ body: c.content, contentType: "text/html" });
+    }
+
+}

package/src/wwwroot/routes/store/subscribe-callback/[subscriptionID]/get.tsx

@@ -0,0 +1,30 @@
+import Inject from "@entity-access/entity-access/dist/di/di.js";
+import { Route } from "@entity-access/server-pages/dist/core/Route.js";
+import Page from "@entity-access/server-pages/dist/Page.js";
+import StorePaymentGatewayService from "../../../../../server/services/store/StorePaymentGatewayService.js";
+import EncryptionService from "../../../../../server/services/encryption/EncryptionService.js";
+
+
+export default class extends Page {
+
+    @Route
+    subscriptionID;
+
+    @Inject
+    pgs: StorePaymentGatewayService;
+
+    @Inject
+    ecs: EncryptionService;
+
+    async run() {
+
+        let { subscriptionID } = this;
+        subscriptionID = this.ecs.general.decrypt(subscriptionID);
+        const c = await this.pgs.fetchSubscription(subscriptionID);
+        if (c.active) {
+            this.cacheControl = "public, max-age=8600";
+        }
+        return this.redirect("/store/subscriptions/" + c.subscription.subscriptionID);
+
+    }
+}