All files / src/domains/inventory/reservations/services reservation.service.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import { Injectable, BadRequestException, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { StockReservation } from '../schemas/reservation.schema';
import { LedgerService } from '../../stock-ledger/services/ledger.service';
import { StockBalance } from '../../stock-ledger/schemas/ledger.schema';
 
@Injectable()
export class ReservationService {
  constructor(
    @InjectModel(StockReservation.name)
    private readonly reservationModel: Model<StockReservation>,
    @InjectModel(StockBalance.name)
    private readonly balanceModel: Model<StockBalance>,
    private readonly ledgerService: LedgerService
  ) {}
 
  async createReservation(tenantId: string, data: any): Promise<StockReservation> {
    // 1. Get available balance
    const balance = await this.balanceModel.findOne({
      tenantId,
      itemCode: data.itemCode,
      warehouseId: data.warehouseId,
      locationId: data.locationId || null,
      batchNumber: data.batchNumber || null,
      serialNumber: data.serialNumber || null,
    }).exec();
 
    const avail = balance ? balance.quantityAvailable : 0;
    if (avail < data.quantityReserved) {
      throw new BadRequestException(`Insufficient available quantity (${avail}) to satisfy reservation of ${data.quantityReserved}`);
    }
 
    // 2. Create reservation document
    const res = await this.reservationModel.create({
      ...data,
      tenantId,
      status: 'active',
      expiryDate: new Date(Date.now() + 60 * 60 * 1000), // default 60 mins expiry
    });
 
    // 3. Atomically decrement quantityAvailable in balance
    if (balance) {
      balance.quantityAvailable -= data.quantityReserved;
      balance.quantityReserved += data.quantityReserved;
      await balance.save();
    }
 
    return res;
  }
 
  async releaseReservation(tenantId: string, id: string): Promise<StockReservation> {
    const res = await this.reservationModel.findOne({ _id: id, tenantId, status: 'active' }).exec();
    if (!res) throw new NotFoundException('Active reservation not found');
 
    res.status = 'released';
    await res.save();
 
    // Revert available vs reserved balances
    const balance = await this.balanceModel.findOne({
      tenantId,
      itemCode: res.itemCode,
      warehouseId: res.warehouseId,
      locationId: res.locationId || null,
      batchNumber: res.batchNumber || null,
      serialNumber: res.serialNumber || null,
    }).exec();
 
    if (balance) {
      balance.quantityAvailable += res.quantityReserved;
      balance.quantityReserved -= res.quantityReserved;
      await balance.save();
    }
 
    return res;
  }
}