@social-mail/social-mail-web-server 1.8.320 → 1.8.322

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@social-mail/social-mail-web-server",
-  "version": "1.8.320",
+  "version": "1.8.322",
   "description": "## Phase 1",
   "main": "index.js",
   "type": "module",

package/src/server/model/entities/StoreItem.ts

@@ -111,6 +111,9 @@ export class StoreItem {
     @ReadOnlyJsonProperty
     public maxPrice: number;
 
+    @Column({ dataType: "Char", length: 20, nullable: true})
+    public taxCode: string;
+
     public store: WebSite;
 
     public vendor: StoreAccount;

package/src/server/model/entities/StoreJournal.ts

@@ -126,6 +126,9 @@ export class StoreJournal {
     @Column({ dataType: "Char", nullable: true})
     taxExemptTaxID: string;
 
+    @Column({ dataType: "Char", length: 200, nullable: true})
+    invoiceID: string;
+
     buyer: StoreAccount;
     seller: StoreAccount;
 

package/src/server/model/entities/WebSite.ts

@@ -151,6 +151,12 @@ export default class WebSite {
     @Column({ dataType:"Char", length: 10, default: () => "USD"})
     public currency: string;
 
+    @Column({ dataType: "Char", length: 16, nullable: true})
+    public invoicePrefix: string;
+
+    @Column({ dataType: "BigInt", default: () => 1})
+    public nextInvoiceID: number;
+
     public folder: AppFile;
 
     currentVersion: AppFile;

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

@@ -137,10 +137,26 @@ export default class StoreJournalEvents extends AuthenticatedEvents<StoreJournal
         return this.updateBalances(entity, entry);
     }
 
-    updateBalances(entity: StoreJournal, entry: ChangeEntry<StoreJournal>) {
+    async updateBalances(entity: StoreJournal, entry: ChangeEntry<StoreJournal>) {
         if (!entity.posted) {
             return;
         }
+
+        if (entity.journalType === "sales-invoice") {
+            if (entity.invoiceID) {
+                const m = /(?<id>\d+)$/.exec(entity.invoiceID);
+                const id = m?.groups["id"];
+                if (id) {
+                    const { storeID } = entity;
+                    const nextInvoiceID = (BigInt(id) + 1n).toString() as any;
+                    await this.db.websiteFolders.where({ storeID, nextInvoiceID }, (p) => (x) =>
+                        x.folderID === p.storeID
+                        && x.nextInvoiceID < p.nextInvoiceID)
+                        .update({ nextInvoiceID }, (p) => (x) => ({ nextInvoiceID }));
+                }
+            }
+        }
+
         this.db.queuePostSaveTask(async () => {
             await entry.loadNavigationAsync((x) => x.entries);
 

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.23"
+        version: "1.9.24"
     });
 
     await config.saveVersion(WebComponentsPackageConfig, {

package/src/server/services/accounts/JournalService.ts

@@ -16,7 +16,18 @@ export default class JournalService {
 
     async syncEntries(entry: ChangeEntry<StoreJournal>, entity: StoreJournal) {
 
-        const { total } = entity;
+        const { total, storeID } = entity;
+
+        // create an anonymous customer
+        // if buyerID is null
+        if (!entity.buyerID) {
+            const account = await this.chartOfAccounts.ensureAccount({
+                storeID,
+                name: "Customer",
+                head: "Customers"
+            });
+            entity.buyerID = account.accountID;
+        }
 
         await this.addEntry({
             entity,
@@ -33,7 +44,7 @@ export default class JournalService {
             await ce.loadNavigationAsync((x) => x.item);
             await ce.loadNavigationAsync((x) => x.itemPrice);
 
-            if(!lineItem.source) {
+            if(!lineItem.source && !lineItem.taxFor) {
                 await this.addEntry({
                     account: AccountNames.Sales,
                     lineItem,

package/src/server/services/accounts/chart-of-accounts/ChartOfAccounts.ts

@@ -1,5 +1,9 @@
 import Inject, { RegisterTransient } from "@entity-access/entity-access/dist/di/di.js";
 import SocialMailContext from "../../../model/SocialMailContext.js";
+import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
+import { randomUUID } from "node:crypto";
+import CryptoService from "../../CryptoService.js";
+import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
 
 @RegisterTransient
 export default class ChartOfAccounts {
@@ -7,19 +11,65 @@ export default class ChartOfAccounts {
     @Inject
     db: SocialMailContext;
 
-    async ensureAccount({storeID , name , parentID = null, parentName = null, customerID = null, head = null}) {
+    @Inject
+    cryptoService: CryptoService;
+
+    async ensureAccount({storeID , name , parentID = null, parentName = null, userID = null, createUser = true, head = null}) {
+
+        let path = name;
 
         if (parentName) {
             const parent = await this.ensureAccount({ storeID, name: parentName, head });
             parentID = parent.accountID;
             head = parent.head;
+            path = `${parentName}/${name}`;
+        }
+
+        const existing = await this.db.storeAccounts.statements.select({}, {
+            parentID,
+            storeID,
+            name,
+            path,
+            head
+        });
+
+        if (existing) {
+            return existing;
+        }
+
+        if (!userID) {
+            if (!createUser) {
+                throw new EntityAccessError(`UserID not specified to create an account`);
+            }
+
+            // let us create a unique user...
+            const password = randomUUID();
+
+            const { cryptoService } = this;
+
+            const passwordSalt = cryptoService.generateSalt();
+            const passwordHash = cryptoService.hash(passwordSalt, password);
+
+            const dateCreated = DateTime.now;
+
+            const user = await this.db.users.statements.insert({
+                userName: randomUUID(),
+                displayName: `${name} (${storeID})`,
+                passwordSalt,
+                passwordHash,
+                multiFactor: false,
+                dateUpdated: dateCreated,
+                isExternal: true
+            });
+            userID = user.userID;
         }
 
         return await this.db.storeAccounts.statements.selectOrInsert({
             parentID,
             storeID,
             name,
-            accountID: customerID,
+            path,
+            accountID: userID,
             head,
         });
     }