Merge pull request #1443 from Gadha2311/autogenerate-batch

feat : added Batch Autogeneration

fyo/models/BatchSeries.ts

@@ -0,0 +1,69 @@
+import { Doc } from 'fyo/model/doc';
+import { ReadOnlyMap, ValidationMap } from 'fyo/model/types';
+import { ValidationError } from 'fyo/utils/errors';
+
+const invalidNumberSeries = /[/\=\?\&\%]/;
+
+function getPaddedName(prefix: string, next: number, padZeros: number): string {
+  return prefix + next.toString().padStart(padZeros ?? 4, '0');
+}
+
+export default class BatchSeries extends Doc {
+  validations: ValidationMap = {
+    name: (value) => {
+      if (typeof value !== 'string') {
+        return;
+      }
+
+      if (invalidNumberSeries.test(value)) {
+        throw new ValidationError(
+          this.fyo
+            .t`The following characters cannot be used ${'/, ?, &, =, %'} in a Number Series name.`
+        );
+      }
+    },
+  };
+
+  setCurrent() {
+    let current = this.get('current') as number | null;
+
+    if (!current) {
+      current = this.get('start') as number;
+    } else {
+      current = current + 1;
+    }
+
+    this.current = current;
+  }
+
+  async next(schemaName: string) {
+    this.setCurrent();
+    const exists = await this.checkIfCurrentExists(schemaName);
+
+    if (exists) {
+      this.current = (this.current as number) + 1;
+    }
+
+    await this.sync();
+    return this.getPaddedName(this.current as number);
+  }
+
+  async checkIfCurrentExists(schemaName: string) {
+    if (!schemaName) {
+      return true;
+    }
+
+    const name = this.getPaddedName(this.current as number);
+    return await this.fyo.db.exists(schemaName, name);
+  }
+
+  getPaddedName(next: number): string {
+    return getPaddedName(this.name as string, next, this.padZeros as number);
+  }
+
+  readOnly: ReadOnlyMap = {
+    referenceType: () => this.inserted,
+    padZeros: () => this.inserted,
+    start: () => this.inserted,
+  };
+}

fyo/models/index.ts

@@ -1,4 +1,5 @@
 import { ModelMap } from 'fyo/model/types';
+import BatchSeries from './BatchSeries';
 import NumberSeries from './NumberSeries';
 import SerialNumberSeries from './SerialNumberSeries';
 import SystemSettings from './SystemSettings';
@@ -6,6 +7,7 @@ import { CustomField } from './CustomField';
 import { CustomForm } from './CustomForm';
 
 export const coreModels = {
+  BatchSeries,
   NumberSeries,
   SerialNumberSeries,
   SystemSettings,

models/baseModels/InvoiceItem/InvoiceItem.ts

@@ -3,6 +3,7 @@ import { DocValue, DocValueMap } from 'fyo/core/types';
 import { Doc } from 'fyo/model/doc';
 import {
   CurrenciesMap,
+  ChangeArg,
   FiltersMap,
   FormulaMap,
   HiddenMap,
@@ -25,6 +26,13 @@ import {
   getItemVisibility,
 } from 'models/helpers';
 import { SalesInvoice } from '../SalesInvoice/SalesInvoice';
+import { getSuggestedBatchName } from 'models/inventory/helpers';
+import { ValuationMethod } from 'models/inventory/types';
+import {
+  getRawStockLedgerEntries,
+  getStockLedgerEntries,
+  getStockBalanceEntries,
+} from 'reports/inventory/helpers';
 import { QueryFilter } from 'utils/db/types';
 
 export abstract class InvoiceItem extends Doc {
@@ -112,6 +120,27 @@ export abstract class InvoiceItem extends Doc {
     this._setGetCurrencies();
   }
 
+  override async change(ch: ChangeArg): Promise<void> {
+    await super.change(ch);
+
+    if (ch.changed === 'item') {
+      if (!this.isSales && this.item) {
+        const hasBatch = await this.fyo.getValue(
+          ModelNameEnum.Item,
+          this.item,
+          'hasBatch'
+        );
+
+        if (hasBatch) {
+          const batchName = await getSuggestedBatchName(this.fyo, this.item);
+          if (batchName) {
+            await this.set('batch', batchName);
+          }
+        }
+      }
+    }
+  }
+
   async getTotalTaxRate(): Promise<number> {
     if (!this.tax) {
       return 0;
@@ -611,15 +640,115 @@ export abstract class InvoiceItem extends Doc {
         filters: { uom: value as string, parent: this.item },
       });
 
-      if (item.length < 1)
+      if (item.length < 1) {
         throw new ValidationError(
           t`Transfer Unit ${value as string} is not applicable for Item ${
             this.item
           }`
         );
+      }
+    },
+
+    qty: async (value: DocValue) => {
+      const requiredQuantity = Math.abs(value as number);
+
+      if (!this.item || requiredQuantity <= 0) {
+        return;
+      }
+
+      if (!this.isSales) {
+        return;
+      }
+
+      if (!this.fyo.singles.InventorySettings?.enableBatches) {
+        return;
+      }
+
+      if (!this.batch) {
+        return;
+      }
+
+      await this.validateBatchQuantity(this.batch, requiredQuantity);
+    },
+
+    batch: async (value: DocValue) => {
+      if (!value || !this.item) {
+        return;
+      }
+
+      if (!this.isSales) {
+        return;
+      }
+
+      if (!this.fyo.singles.InventorySettings?.enableBatches) {
+        return;
+      }
+
+      const requiredQuantity = this.quantity ?? 0;
+
+      if (requiredQuantity > 0) {
+        await this.validateBatchQuantity(value as string, requiredQuantity);
+      } else if (requiredQuantity < 0) {
+        await this.validateBatchQuantity(
+          value as string,
+          Math.abs(requiredQuantity)
+        );
+      }
     },
   };
 
+  async validateBatchQuantity(
+    batchName: string,
+    requiredQuantity: number
+  ): Promise<void> {
+    let inventoryLocation: string | undefined;
+
+    if (this.location) {
+      inventoryLocation = this.location as string;
+    } else {
+      const posProfileName = this.fyo.singles.POSSettings?.posProfile;
+
+      if (posProfileName) {
+        const inventory = await this.fyo.getValue(
+          ModelNameEnum.POSProfile,
+          posProfileName as string,
+          'inventory'
+        );
+
+        inventoryLocation = inventory as string | undefined;
+      } else {
+        inventoryLocation = this.fyo.singles.POSSettings?.inventory;
+      }
+    }
+
+    const valuationMethod =
+      (this.fyo.singles.InventorySettings
+        ?.valuationMethod as ValuationMethod) ?? ValuationMethod.FIFO;
+
+    const rawSLEs = await getRawStockLedgerEntries(this.fyo);
+    const computedSLEs = getStockLedgerEntries(rawSLEs, valuationMethod);
+
+    const stockBalance = getStockBalanceEntries(computedSLEs, {
+      item: this.item!,
+      location: inventoryLocation,
+      batch: batchName,
+    });
+
+    const availableQuantity = stockBalance.reduce(
+      (sum, entry) => sum + (entry.balanceQuantity || 0),
+      0
+    );
+
+    if (requiredQuantity > availableQuantity) {
+      throw new ValidationError(
+        this.fyo.t`
+        Batch ${batchName} only has ${availableQuantity} quantity available
+        but ${requiredQuantity} is required
+      `
+      );
+    }
+  }
+
   hidden: HiddenMap = {
     itemDiscountedTotal: () => {
       if (!this.enableDiscounting) {
@@ -680,15 +809,92 @@ export abstract class InvoiceItem extends Doc {
       return filters;
     },
     batch: async (doc: Doc) => {
-      const batches = await doc.fyo.db.getAll(ModelNameEnum.Batch, {
-        fields: ['name'],
-        filters: { item: doc.item as string },
-      });
-      const batchName = batches.map((b) => b.name) as string[];
+      const hasBatch = !!(await doc.fyo.getValue(
+        ModelNameEnum.Item,
+        doc.item as string,
+        'hasBatch'
+      ));
 
-      return {
-        name: ['in', batchName],
-      };
+      if (!hasBatch) {
+        return { name: ['in', []] };
+      }
+
+      let suggestedBatch: string | undefined;
+
+      if (!doc.isSales) {
+        suggestedBatch = await getSuggestedBatchName(
+          doc.fyo,
+          doc.item as string
+        );
+
+        if (suggestedBatch) {
+          await doc.set('batch', suggestedBatch);
+        }
+      }
+
+      try {
+        let inventoryLocation: string | undefined;
+
+        if (doc.location) {
+          inventoryLocation = doc.location as string;
+        } else {
+          const posProfileName = doc.fyo.singles.POSSettings?.posProfile;
+          if (posProfileName) {
+            const posProfile = await doc.fyo.doc.getDoc(
+              ModelNameEnum.POSProfile,
+              posProfileName as string
+            );
+            inventoryLocation = posProfile?.inventory as string | undefined;
+          } else {
+            inventoryLocation = doc.fyo.singles.POSSettings?.inventory;
+          }
+        }
+
+        const rawSLEs = await getRawStockLedgerEntries(doc.fyo);
+
+        const valuationMethod =
+          (doc.fyo.singles.InventorySettings
+            ?.valuationMethod as ValuationMethod) ?? ValuationMethod.FIFO;
+
+        const computedSLEs = getStockLedgerEntries(rawSLEs, valuationMethod);
+
+        const stockBalance = getStockBalanceEntries(computedSLEs, {
+          item: doc.item as string,
+          location: inventoryLocation,
+        });
+
+        const batchesWithStock = stockBalance
+          .filter((entry) => entry.batch && entry.balanceQuantity > 0)
+          .map((entry) => entry.batch);
+
+        const allBatches = new Set<string>(batchesWithStock);
+        if (suggestedBatch) {
+          allBatches.add(suggestedBatch);
+        }
+
+        const finalBatchList = Array.from(allBatches);
+
+        return {
+          name: ['in', finalBatchList],
+        };
+      } catch (error) {
+        const batches = await doc.fyo.db.getAll(ModelNameEnum.Batch, {
+          fields: ['name'],
+          filters: { item: doc.item as string },
+        });
+        const batchNames = batches.map((b) => b.name) as string[];
+
+        const allBatches = new Set<string>(batchNames);
+        if (suggestedBatch) {
+          allBatches.add(suggestedBatch);
+        }
+
+        const finalBatchList = Array.from(allBatches);
+
+        return {
+          name: ['in', finalBatchList],
+        };
+      }
     },
     transferUnit: async (doc: Doc) => {
       const conversionItems = await doc.fyo.db.getAll(

models/baseModels/Item/Item.ts

@@ -26,6 +26,7 @@ export class Item extends Doc {
   itemType?: 'Product' | 'Service';
   for?: 'Purchases' | 'Sales' | 'Both';
   hasBatch?: boolean;
+  batchSeries?: string;
   itemGroup?: string;
   hsnCode?: number;
   hasSerialNumber?: boolean;
@@ -101,6 +102,13 @@ export class Item extends Doc {
         this.serialNumberSeries = series + '-';
       }
     }
+
+    if (this.batchSeries && this.hasBatch) {
+      const series = this.batchSeries.trim();
+      if (series && !series.endsWith('-')) {
+        this.batchSeries = series + '-';
+      }
+    }
   }
 
   async afterSync(): Promise<void> {
@@ -126,6 +134,27 @@ export class Item extends Doc {
           .sync();
       }
     }
+
+    if (this.hasBatch && this.batchSeries) {
+      const seriesName = this.batchSeries?.trim();
+
+      if (!seriesName) {
+        return;
+      }
+
+      const exists = await this.fyo.db.exists('BatchSeries', seriesName);
+
+      if (!exists) {
+        await this.fyo.doc
+          .getNewDoc('BatchSeries', {
+            name: seriesName,
+            start: 1001,
+            padZeros: 4,
+            current: 1001,
+          })
+          .sync();
+      }
+    }
   }
 
   static filters: FiltersMap = {
@@ -174,6 +203,21 @@ export class Item extends Doc {
         );
       }
     },
+    batchSeries: (value: DocValue) => {
+      if (!value) {
+        return;
+      }
+
+      const series = (value as string).trim();
+      const invalidChars = /[/\=\?\&\%]/;
+
+      if (invalidChars.test(series)) {
+        throw new ValidationError(
+          this.fyo
+            .t`Batch Series cannot contain the following characters: /, ?, &, =, %`
+        );
+      }
+    },
   };
 
   static getActions(fyo: Fyo): Action[] {
@@ -227,6 +271,7 @@ export class Item extends Doc {
         this.fyo.singles.InventorySettings?.enableSerialNumber && this.trackItem
       ),
     serialNumberSeries: () => !this.hasSerialNumber,
+    batchSeries: () => !this.hasBatch,
     uomConversions: () =>
       !this.fyo.singles.InventorySettings?.enableUomConversions,
     itemGroup: () => !this.fyo.singles.AccountingSettings?.enableitemGroup,

models/baseModels/PurchaseInvoice/PurchaseInvoice.ts

@@ -5,10 +5,44 @@ import { ModelNameEnum } from 'models/types';
 import { getInvoiceActions, getTransactionStatusColumn } from '../../helpers';
 import { Invoice } from '../Invoice/Invoice';
 import { PurchaseInvoiceItem } from '../PurchaseInvoiceItem/PurchaseInvoiceItem';
+import { createBatch } from 'models/inventory/helpers';
 
 export class PurchaseInvoice extends Invoice {
   items?: PurchaseInvoiceItem[];
 
+  async beforeSubmit(): Promise<void> {
+    await super.beforeSubmit();
+
+    if (this.isReturn) {
+      return;
+    }
+
+    const batchesToCreate: { item: string; batch: string }[] = [];
+
+    for (const item of this.items ?? []) {
+      if (!item.item || !item.batch) {
+        continue;
+      }
+
+      const hasBatch = await this.fyo.getValue(
+        ModelNameEnum.Item,
+        item.item,
+        'hasBatch'
+      );
+
+      if (hasBatch) {
+        batchesToCreate.push({
+          item: item.item,
+          batch: item.batch,
+        });
+      }
+    }
+
+    for (const { item, batch } of batchesToCreate) {
+      await createBatch(this.fyo, item, batch);
+    }
+  }
+
   async getPosting() {
     const exchangeRate = this.exchangeRate ?? 1;
     const posting: LedgerPosting = new LedgerPosting(this, this.fyo);

models/helpers.ts

@@ -48,7 +48,10 @@ import {
   getStockLedgerEntries,
 } from 'reports/inventory/helpers';
 import { LoyaltyPointEntry } from './baseModels/LoyaltyPointEntry/LoyaltyPointEntry';
-import { generateSerialNumbersForItem } from './inventory/helpers';
+import {
+  generateSerialNumbersForItem,
+  generateBatchForItem,
+} from './inventory/helpers';
 
 export function getQuoteActions(
   fyo: Fyo,
@@ -834,6 +837,13 @@ export async function addItem<M extends ModelsWithItems>(name: string, doc: M) {
 
   await item.set('item', name);
 
+  if (doc instanceof Invoice && !doc.isSales) {
+    const batchName = await generateBatchForItem(doc.fyo, name);
+    if (batchName) {
+      await item.set('batch', batchName);
+    }
+  }
+
   if (
     doc instanceof StockTransfer &&
     doc.schemaName === ModelNameEnum.PurchaseReceipt

models/inventory/StockMovement.ts

@@ -16,6 +16,8 @@ import { StockMovementItem } from './StockMovementItem';
 import { Transfer } from './Transfer';
 import {
   canValidateSerialNumber,
+  createBatch,
+  generateBatchForItem,
   getSerialNumberFromDoc,
   updateSerialNumbers,
   validateBatch,
@@ -65,6 +67,42 @@ export class StockMovement extends Transfer {
     await updateSerialNumbers(this, false);
   }
 
+  async beforeSubmit(): Promise<void> {
+    await super.beforeSubmit();
+
+    const batchesToCreate: { item: string; batch: string }[] = [];
+
+    for (const item of this.items ?? []) {
+      if (!item.item || !item.batch) {
+        continue;
+      }
+
+      const hasBatch = await this.fyo.getValue(
+        ModelNameEnum.Item,
+        item.item,
+        'hasBatch'
+      );
+
+      if (hasBatch) {
+        const batchExists = await this.fyo.db.exists(
+          ModelNameEnum.Batch,
+          item.batch
+        );
+
+        if (!batchExists) {
+          batchesToCreate.push({
+            item: item.item,
+            batch: item.batch,
+          });
+        }
+      }
+    }
+
+    for (const { item, batch } of batchesToCreate) {
+      await createBatch(this.fyo, item, batch);
+    }
+  }
+
   async afterCancel(): Promise<void> {
     await super.afterCancel();
     await updateSerialNumbers(this, true);
@@ -125,10 +163,10 @@ export class StockMovement extends Transfer {
       item: row.item!,
       rate: row.rate!,
       quantity: row.quantity!,
-      batch: row.batch!,
-      serialNumber: row.serialNumber!,
-      fromLocation: row.fromLocation,
-      toLocation: row.toLocation,
+      batch: row.batch ?? undefined,
+      serialNumber: row.serialNumber ?? undefined,
+      fromLocation: row.fromLocation ?? undefined,
+      toLocation: row.toLocation ?? undefined,
     }));
   }
 
@@ -142,19 +180,30 @@ export class StockMovement extends Transfer {
       throw new ValidationError(t`Item ${name} not found`);
     }
 
+    let batch: string | null | undefined =
+      (itemDoc.defaultBatch as string | null | undefined) ?? null;
+
+    if (
+      this.movementType === MovementTypeEnum.MaterialReceipt &&
+      itemDoc.hasBatch &&
+      !batch
+    ) {
+      batch = await generateBatchForItem(this.fyo, name);
+    }
+
     const item = {
       name: itemDoc.name,
-      batch: itemDoc.defaultBatch ?? null,
+      batch,
     };
 
     if (item.batch) {
       const batchDoc = await this.fyo.doc.getDoc(
         ModelNameEnum.Batch,
-        item.batch as string
+        item.batch
       );
       if (batchDoc && batchDoc.item !== name) {
         throw new ValidationError(
-          t`Batch ${item.batch as string} does not belong to Item ${name}`
+          t`Batch ${item.batch} does not belong to Item ${name}`
         );
       }
     }

models/inventory/StockMovementItem.ts

@@ -13,7 +13,7 @@ import { ValidationError } from 'fyo/utils/errors';
 import { ModelNameEnum } from 'models/types';
 import { Money } from 'pesa';
 import { safeParseFloat } from 'utils/index';
-import { generateSerialNumbersForItem } from './helpers';
+import { generateSerialNumbersForItem, getSuggestedBatchName } from './helpers';
 import { StockMovement } from './StockMovement';
 import { TransferItem } from './TransferItem';
 import { MovementTypeEnum } from './types';
@@ -80,14 +80,43 @@ export class StockMovementItem extends TransferItem {
       };
     },
     batch: async (doc: Doc) => {
+      let suggestedBatch: string | undefined;
+      let hasBatch = false;
+
+      if (doc.parentdoc?.movementType === MovementTypeEnum.MaterialReceipt) {
+        hasBatch = !!(await doc.fyo.getValue(
+          ModelNameEnum.Item,
+          doc.item as string,
+          'hasBatch'
+        ));
+
+        if (hasBatch) {
+          suggestedBatch = await getSuggestedBatchName(
+            doc.fyo,
+            doc.item as string
+          );
+
+          if (suggestedBatch) {
+            await doc.set('batch', suggestedBatch);
+          }
+        }
+      }
+
       const batches = await doc.fyo.db.getAll(ModelNameEnum.Batch, {
         fields: ['name'],
         filters: { item: doc.item as string },
       });
-      const batchName = batches.map((b) => b.name) as string[];
+      const existingBatchNames = batches.map((b) => b.name) as string[];
+
+      const allBatches = new Set<string>(existingBatchNames);
+      if (suggestedBatch) {
+        allBatches.add(suggestedBatch);
+      }
+
+      const finalBatchList = Array.from(allBatches);
 
       return {
-        name: ['in', batchName],
+        name: ['in', finalBatchList],
       };
     },
   };
@@ -338,6 +367,24 @@ export class StockMovementItem extends TransferItem {
     if (ch.changed === 'item') {
       await this.set('serialNumber', '');
 
+      if (
+        this.parentdoc?.movementType === MovementTypeEnum.MaterialReceipt &&
+        this.item
+      ) {
+        const hasBatch = await this.fyo.getValue(
+          ModelNameEnum.Item,
+          this.item,
+          'hasBatch'
+        );
+
+        if (hasBatch) {
+          const batchName = await getSuggestedBatchName(this.fyo, this.item);
+          if (batchName) {
+            await this.set('batch', batchName);
+          }
+        }
+      }
+
       if (shouldGenerateSerialNumbers) {
         await this.generateAndSetSerialNumbers();
       }

models/inventory/helpers.ts

@@ -11,6 +11,7 @@ import type { StockTransferItem } from './StockTransferItem';
 import { Transfer } from './Transfer';
 import { TransferItem } from './TransferItem';
 import type { SerialNumberStatus } from './types';
+import BatchSeries from 'fyo/models/BatchSeries';
 import SerialNumberSeries from 'fyo/models/SerialNumberSeries';
 
 export async function validateBatch(
@@ -19,6 +20,35 @@ export async function validateBatch(
   if (doc.schemaName === ModelNameEnum.SalesQuote) {
     return;
   }
+
+  if (
+    doc.schemaName === ModelNameEnum.PurchaseInvoice ||
+    doc.schemaName === ModelNameEnum.PurchaseReceipt ||
+    doc.schemaName === ModelNameEnum.StockMovement ||
+    doc.schemaName === ModelNameEnum.Shipment
+  ) {
+    for (const row of doc.items ?? []) {
+      if (row.item && row.batch) {
+        const hasBatch = await doc.fyo.getValue(
+          ModelNameEnum.Item,
+          row.item,
+          'hasBatch'
+        );
+
+        if (hasBatch) {
+          const batchExists = await doc.fyo.db.exists(
+            ModelNameEnum.Batch,
+            row.batch
+          );
+
+          if (!batchExists) {
+            await createBatch(doc.fyo, row.item, row.batch);
+          }
+        }
+      }
+    }
+  }
+
   for (const row of doc.items ?? []) {
     await validateItemRowBatch(row);
   }
@@ -531,3 +561,137 @@ export async function getExistingActiveSerialNumbersForItem(
 
   return selectedSerialNumbers.join('\n');
 }
+
+export async function getSuggestedBatchName(
+  fyo: Fyo,
+  itemName: string
+): Promise<string | undefined> {
+  try {
+    const batchSeries = await fyo.getValue(
+      ModelNameEnum.Item,
+      itemName,
+      'batchSeries'
+    );
+
+    if (!batchSeries) {
+      return undefined;
+    }
+
+    const seriesName = (batchSeries as string).trim();
+
+    const seriesExists = await fyo.db.exists('BatchSeries', seriesName);
+
+    if (!seriesExists) {
+      await fyo.doc
+        .getNewDoc('BatchSeries', {
+          name: seriesName,
+          start: 1001,
+          padZeros: 4,
+          current: 1001,
+        })
+        .sync();
+    }
+
+    const batchSeriesDoc = (await fyo.doc.getDoc(
+      'BatchSeries',
+      seriesName
+    )) as BatchSeries;
+
+    const padZeros = (batchSeriesDoc.padZeros as number) ?? 4;
+
+    const existingBatches = (await fyo.db.getAllRaw(ModelNameEnum.Batch, {
+      fields: ['name'],
+      filters: { item: itemName },
+    })) as { name: string }[];
+
+    let nextNumber: number;
+
+    if (existingBatches && existingBatches.length > 0) {
+      let highestNumber = -1;
+
+      for (const batch of existingBatches) {
+        const batchName = batch.name;
+        // Extract numeric part from batch name (handles names like "com-1001")
+        const numericPart = batchName.replace(seriesName, '');
+        const num = parseInt(numericPart, 10);
+
+        if (!isNaN(num) && num > highestNumber) {
+          highestNumber = num;
+        }
+      }
+
+      if (highestNumber >= 0) {
+        nextNumber = highestNumber + 1;
+      } else {
+        nextNumber = (batchSeriesDoc.start as number) ?? 1001;
+      }
+    } else {
+      nextNumber = (batchSeriesDoc.start as number) ?? 1001;
+    }
+
+    const batchName = `${seriesName}${nextNumber
+      .toString()
+      .padStart(padZeros, '0')}`;
+
+    return batchName;
+  } catch (error) {
+    return undefined;
+  }
+}
+
+export async function createBatch(
+  fyo: Fyo,
+  itemName: string,
+  batchName: string
+): Promise<boolean> {
+  try {
+    const batchExists = await fyo.db.exists(ModelNameEnum.Batch, batchName);
+    if (batchExists) {
+      return true;
+    }
+
+    const batchDoc = fyo.doc.getNewDoc('Batch', {
+      name: batchName,
+      item: itemName,
+    });
+
+    await batchDoc.sync();
+
+    const batchSeries = await fyo.getValue(
+      ModelNameEnum.Item,
+      itemName,
+      'batchSeries'
+    );
+
+    if (batchSeries) {
+      const seriesName = (batchSeries as string).trim();
+      const batchSeriesDoc = (await fyo.doc.getDoc(
+        'BatchSeries',
+        seriesName
+      )) as BatchSeries;
+
+      const num = parseInt(batchName, 10);
+      if (!isNaN(num)) {
+        await batchSeriesDoc.set('current', num);
+        await batchSeriesDoc.sync();
+      }
+    }
+
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function generateBatchForItem(
+  fyo: Fyo,
+  itemName: string
+): Promise<string | undefined> {
+  const batchName = await getSuggestedBatchName(fyo, itemName);
+  if (!batchName) {
+    return undefined;
+  }
+
+  const success = await createBatch(fyo, itemName, batchName);
+  return success ? batchName : undefined;
+}

models/types.ts

@@ -15,6 +15,7 @@ export enum ModelNameEnum {
   AccountingSettings = 'AccountingSettings',
   Address = 'Address',
   Batch = 'Batch',
+  BatchSeries = 'BatchSeries',
   Color = 'Color',
   Currency = 'Currency',
   GetStarted = 'GetStarted',

schemas/app/BatchSeries.json

@@ -0,0 +1,38 @@
+{
+  "name": "BatchSeries",
+  "label": "Batch Series",
+  "naming": "manual",
+  "isSingle": false,
+  "isChild": false,
+  "fields": [
+    {
+      "fieldname": "name",
+      "label": "Prefix",
+      "fieldtype": "Data",
+      "required": true
+    },
+    {
+      "fieldname": "start",
+      "label": "Start",
+      "fieldtype": "Int",
+      "default": 1001,
+      "required": true,
+      "minvalue": 0
+    },
+    {
+      "fieldname": "padZeros",
+      "label": "Pad Zeros",
+      "fieldtype": "Int",
+      "default": 4,
+      "required": true
+    },
+    {
+      "fieldname": "current",
+      "label": "Current",
+      "fieldtype": "Int",
+      "required": true,
+      "readOnly": true
+    }
+  ],
+  "quickEditFields": ["start", "padZeros"]
+}

schemas/app/Item.json

@@ -153,6 +153,12 @@
       "default": false,
       "section": "Inventory"
     },
+    {
+      "fieldname": "batchSeries",
+      "label": "Batch Series",
+      "fieldtype": "Data",
+      "section": "Inventory"
+    },
     {
       "fieldname": "hasSerialNumber",
       "label": "Has Serial Number",

schemas/schemas.ts

@@ -3,6 +3,7 @@ import AccountingLedgerEntry from './app/AccountingLedgerEntry.json';
 import AccountingSettings from './app/AccountingSettings.json';
 import Address from './app/Address.json';
 import Batch from './app/Batch.json';
+import BatchSeries from './app/BatchSeries.json';
 import Color from './app/Color.json';
 import Currency from './app/Currency.json';
 import Defaults from './app/Defaults.json';
@@ -108,6 +109,7 @@ export const appSchemas: Schema[] | SchemaStub[] = [
   Defaults as Schema,
   NumberSeries as Schema,
   SerialNumberSeries as Schema,
+  BatchSeries as Schema,
 
   PrintSettings as Schema,
 

src/components/POS/Classic/SelectedItemRow.vue

@@ -2,10 +2,10 @@
   <feather-icon
     :name="isExapanded ? 'chevron-up' : 'chevron-down'"
     class="w-4 h-4 inline-flex cursor-pointer text-gray-700 dark:text-gray-200"
-    @click="isExapanded = !isExapanded"
+    @click="toggleExpand"
   />
 
-  <div class="relative" @click="emitSelectedRow">
+  <div class="relative" @click="toggleExpandAndEmit">
     <Link
       class="pt-2"
       :df="{
@@ -27,7 +27,7 @@
     </p>
   </div>
 
-  <div class="flex items-center" @click="emitSelectedRow">
+  <div class="flex items-center">
     <Int
       :df="{
         fieldname: 'quantity',
@@ -115,7 +115,7 @@
   <div></div>
 
   <template v-if="isExapanded">
-    <div class="px-4 pt-6 col-span-1" @click="emitSelectedRow">
+    <div class="px-4 pt-6 col-span-1">
       <Int
         v-if="isUOMConversionEnabled"
         :df="{
@@ -286,7 +286,7 @@ import Link from 'src/components/Controls/Link.vue';
 import Text from 'src/components/Controls/Text.vue';
 import { inject } from 'vue';
 import { fyo } from 'src/initFyo';
-import { defineComponent } from 'vue';
+import { defineComponent, PropType } from 'vue';
 import { SalesInvoiceItem } from 'models/baseModels/SalesInvoiceItem/SalesInvoiceItem';
 import { Money } from 'pesa';
 import { DiscountType } from '../types';
@@ -305,8 +305,17 @@ export default defineComponent({
   props: {
     row: { type: SalesInvoiceItem, required: true },
     batchAdded: { type: Boolean, default: false },
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
-  emits: ['runSinvFormulas', 'applyPricingRule', 'selectedRow'],
+  emits: [
+    'runSinvFormulas',
+    'applyPricingRule',
+    'selectedRow',
+    'setExpandedBatchId',
+  ],
   setup() {
     return {
       isDiscountingEnabled: inject('isDiscountingEnabled') as boolean,
@@ -331,11 +340,17 @@ export default defineComponent({
     };
   },
   watch: {
+    expandedBatchId(newVal) {
+      if (newVal !== this.row.name) {
+        this.isExapanded = false;
+      }
+    },
     'row.batch': {
       async handler(newBatch) {
         if (newBatch) {
           this.availableQtyInBatch = await this.getAvailableQtyInBatch();
           this.isExapanded = true;
+          this.$emit('setExpandedBatchId', this.row.name);
         }
       },
       immediate: true,
@@ -466,6 +481,19 @@ export default defineComponent({
   },
 
   methods: {
+    toggleExpand() {
+      if (this.isExapanded) {
+        this.isExapanded = false;
+        this.$emit('setExpandedBatchId', undefined);
+      } else {
+        this.isExapanded = true;
+        this.$emit('setExpandedBatchId', this.row.name);
+      }
+    },
+    toggleExpandAndEmit() {
+      this.toggleExpand();
+      this.$emit('selectedRow', this.row);
+    },
     emitSelectedRow() {
       this.$emit('selectedRow', this.row);
     },

src/components/POS/Classic/SelectedItemTable.vue

@@ -53,6 +53,10 @@
     >
       <SelectedItemRow
         :row="(row as SalesInvoiceItem)"
+        :expanded-batch-id="expandedBatchId"
+        @set-expanded-batch-id="
+          (rowName) => $emit('setExpandedBatchId', rowName)
+        "
         @run-sinv-formulas="runSinvFormulas"
         @apply-pricing-rule="$emit('applyPricingRule')"
         @selected-row="selectedItemRow"
@@ -70,7 +74,7 @@ import RowEditForm from 'src/pages/CommonForm/RowEditForm.vue';
 import SelectedItemRow from './SelectedItemRow.vue';
 import { isNumeric } from 'src/utils';
 import { inject } from 'vue';
-import { defineComponent } from 'vue';
+import { defineComponent, PropType } from 'vue';
 import { SalesInvoiceItem } from 'models/baseModels/SalesInvoiceItem/SalesInvoiceItem';
 import { SalesInvoice } from 'models/baseModels/SalesInvoice/SalesInvoice';
 import { Field } from 'schemas/types';
@@ -90,12 +94,13 @@ export default defineComponent({
       sinvDoc: inject('sinvDoc') as SalesInvoice,
     };
   },
-  data() {
-    return {
-      isExapanded: false,
-    };
+  props: {
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
-  emits: ['applyPricingRule', 'selectedRow'],
+  emits: ['applyPricingRule', 'selectedRow', 'setExpandedBatchId'],
   computed: {
     ratio() {
       return [0.1, 0.9, 0.8, 0.8, 0.8, 0.8, 0.2];

src/components/POS/Modern/ModernPOSSelectedItemRow.vue

@@ -3,11 +3,11 @@
     <feather-icon
       :name="isExapanded ? 'chevron-up' : 'chevron-down'"
       class="w-4 h-4 inline-flex dark:text-white"
-      @click="isExapanded = !isExapanded"
+      @click="toggleExpand"
     />
   </div>
 
-  <div class="relative" @click="isExapanded = !isExapanded">
+  <div class="relative" @click="toggleExpand">
     <Link
       :df="{
         fieldname: 'item',
@@ -245,7 +245,7 @@ import Link from 'src/components/Controls/Link.vue';
 import Text from 'src/components/Controls/Text.vue';
 import { inject } from 'vue';
 import { fyo } from 'src/initFyo';
-import { defineComponent } from 'vue';
+import { defineComponent, PropType } from 'vue';
 import { SalesInvoiceItem } from 'models/baseModels/SalesInvoiceItem/SalesInvoiceItem';
 import { Money } from 'pesa';
 import { validateSerialNumberCount } from 'src/utils/pos';
@@ -256,8 +256,18 @@ export default defineComponent({
   props: {
     row: { type: SalesInvoiceItem, required: true },
     batchAdded: { type: Boolean, default: false },
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
-  emits: ['toggleModal', 'runSinvFormulas', 'selectedRow', 'applyPricingRule'],
+  emits: [
+    'toggleModal',
+    'runSinvFormulas',
+    'selectedRow',
+    'applyPricingRule',
+    'setExpandedBatchId',
+  ],
 
   setup() {
     return {
@@ -278,11 +288,17 @@ export default defineComponent({
     };
   },
   watch: {
+    expandedBatchId(newVal) {
+      if (newVal !== this.row.name) {
+        this.isExapanded = false;
+      }
+    },
     'row.batch': {
       async handler(newBatch) {
         if (newBatch) {
           this.availableQtyInBatch = await this.getAvailableQtyInBatch();
           this.isExapanded = true;
+          this.$emit('setExpandedBatchId', this.row.name);
         }
       },
       immediate: true,
@@ -300,6 +316,15 @@ export default defineComponent({
     },
   },
   methods: {
+    toggleExpand() {
+      if (this.isExapanded) {
+        this.isExapanded = false;
+        this.$emit('setExpandedBatchId', undefined);
+      } else {
+        this.isExapanded = true;
+        this.$emit('setExpandedBatchId', this.row.name);
+      }
+    },
     handleOpenKeyboard(row: SalesInvoiceItem, field: string) {
       if (this.isReadOnly) {
         return;

src/components/POS/Modern/ModernPOSSelectedItemTable.vue

@@ -41,6 +41,10 @@
     >
       <ModernPOSSelectedItemRow
         :row="(row as SalesInvoiceItem)"
+        :expanded-batch-id="expandedBatchId"
+        @set-expanded-batch-id="
+          (rowName) => $emit('setExpandedBatchId', rowName)
+        "
         @selected-row="selectedItemRow"
         @run-sinv-formulas="runSinvFormulas"
         @apply-pricing-rule="$emit('applyPricingRule')"
@@ -59,7 +63,7 @@ import RowEditForm from 'src/pages/CommonForm/RowEditForm.vue';
 import ModernPOSSelectedItemRow from './ModernPOSSelectedItemRow.vue';
 import { isNumeric } from 'src/utils';
 import { t } from 'fyo';
-import { inject, defineComponent } from 'vue';
+import { inject, defineComponent, PropType } from 'vue';
 import { SalesInvoiceItem } from 'models/baseModels/SalesInvoiceItem/SalesInvoiceItem';
 import { SalesInvoice } from 'models/baseModels/SalesInvoice/SalesInvoice';
 import { Field } from 'schemas/types';
@@ -79,12 +83,18 @@ export default defineComponent({
       sinvDoc: inject('sinvDoc') as SalesInvoice,
     };
   },
-  data() {
-    return {
-      isExapanded: false,
-    };
+  props: {
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
-  emits: ['toggleModal', 'selectedRow', 'applyPricingRule'],
+  emits: [
+    'toggleModal',
+    'selectedRow',
+    'applyPricingRule',
+    'setExpandedBatchId',
+  ],
   computed: {
     ratio() {
       return [0.1, 0.8, 0.4, 0.8, 0.8, 0.3];

src/pages/POS/ClassicPOS.vue

@@ -186,6 +186,10 @@
             />
 
             <SelectedItemTable
+              :expanded-batch-id="expandedBatchId"
+              @set-expanded-batch-id="
+                (rowName) => $emit('setExpandedBatchId', rowName)
+              "
               @apply-pricing-rule="emitEvent('applyPricingRule')"
               @selected-row="(row) => $emit('selectedRow', row)"
             />
@@ -502,8 +506,13 @@ export default defineComponent({
       type: String,
       default: '',
     },
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
   emits: [
+    'setExpandedBatchId',
     'addItem',
     'toggleView',
     'toggleModal',

src/pages/POS/ModernPOS.vue

@@ -119,6 +119,10 @@
             />
 
             <ModernPOSSelectedItemTable
+              :expanded-batch-id="expandedBatchId"
+              @set-expanded-batch-id="
+                (rowName) => $emit('setExpandedBatchId', rowName)
+              "
               @selected-row="selectedRow"
               @apply-pricing-rule="emitEvent('applyPricingRule')"
               @toggle-modal="emitEvent('toggleModal', 'Keyboard')"
@@ -508,8 +512,13 @@ export default defineComponent({
       type: String,
       default: '',
     },
+    expandedBatchId: {
+      type: String as PropType<string | null | undefined>,
+      default: undefined,
+    },
   },
   emits: [
+    'setExpandedBatchId',
     'addItem',
     'toggleView',
     'toggleModal',

src/pages/POS/POS.vue

@@ -44,6 +44,8 @@
       :open-return-sales-invoice-modal="openReturnSalesInvoiceModal"
       :open-batch-selection-modal="openBatchSelectionModal"
       :selected-item-for-batch="selectedItemForBatch"
+      :expanded-batch-id="expandedBatchId"
+      @set-expanded-batch-id="setExpandedBatchId"
       @add-item="addItem"
       @toggle-view="toggleView"
       @set-sinv-doc="setSinvDoc"
@@ -102,6 +104,8 @@
       :open-return-sales-invoice-modal="openReturnSalesInvoiceModal"
       :open-batch-selection-modal="openBatchSelectionModal"
       :selected-item-for-batch="selectedItemForBatch"
+      :expanded-batch-id="expandedBatchId"
+      @set-expanded-batch-id="setExpandedBatchId"
       @add-item="addItem"
       @toggle-view="toggleView"
       @set-sinv-doc="setSinvDoc"
@@ -266,6 +270,7 @@ export default defineComponent({
       quickQtyKeyUpHandler: null as ((e: KeyboardEvent) => void) | null,
       selectedItemForBatch: '' as string,
       pendingBatchItem: null as { item: POSItem; quantity: number } | null,
+      expandedBatchId: undefined as string | null | undefined,
       itemVisibilityValue: 'Inventory Items' as ItemVisibility,
     };
   },
@@ -326,6 +331,9 @@ export default defineComponent({
     setQuickQtySelectedRow(row: SalesInvoiceItem) {
       this.quickQtyRow = row;
     },
+    setExpandedBatchId(rowName: string | null) {
+      this.expandedBatchId = rowName;
+    },
     addQuickQtyListeners() {
       this.quickQtyKeyDownHandler = (e: KeyboardEvent) =>
         this.onQuickQtyKeyDown(e);