@things-factory/warehouse-base 8.0.0-beta.8 → 8.0.0

package/server/service/inventory/inventory-mutation.ts

@@ -0,0 +1,530 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, MoreThan, SelectQueryBuilder, Equal } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { Product } from '@things-factory/product-base'
+// @ts-ignore
+import { ArrivalNotice } from '@things-factory/sales-base'
+
+import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS, RULE_TYPE } from '../../constants'
+import { SellercraftController } from '../../controllers'
+import { DateGenerator, InventoryNoGenerator, InventoryUtil } from '../../utils'
+import { InventoryHistory } from '../inventory-history/inventory-history'
+import { Location } from '../location/location'
+import { Inventory } from './inventory'
+import { InventoryPatch, NewInventory } from './inventory-types'
+
+@Resolver(Inventory)
+export class InventoryMutation {
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Inventory)
+  async createInventory(
+    @Arg('inventory') inventory: NewInventory,
+    @Ctx() context: ResolverContext
+  ): Promise<Inventory> {
+    const { tx } = context.state
+
+    return await tx.getRepository(Inventory).save({
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user,
+      ...inventory
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Inventory)
+  async updateInventory(@Arg('patch') patch: InventoryPatch, @Ctx() context: ResolverContext): Promise<Inventory> {
+    const { domain, user, tx } = context.state
+
+    const invQb: SelectQueryBuilder<Inventory> = await tx
+      .getRepository(Inventory)
+      .createQueryBuilder('INV')
+      .where('INV.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('INV.bizplace_id = :bizplaceId', { bizplaceId: patch.bizplace.id })
+      .andWhere('INV.batch_id = :batchId', { batchId: patch.batchId })
+      .andWhere('INV.product_id = :productId', { productId: patch.product.id })
+      .andWhere('INV.packing_type = :packingType', { packingType: patch.packingType })
+      .andWhere('INV.packing_size = :packingSize', { packingSize: patch.packingSize })
+
+    if (patch?.cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: patch.cartonId })
+    else invQb.andWhere('INV.pallet_id = :palletId', { palletId: patch.palletId })
+
+    const inventory = await invQb.getOne()
+
+    return await tx.getRepository(Inventory).save({
+      ...inventory,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Inventory)
+  async updateInventoryRemark(
+    @Arg('id') id: string,
+    @Arg('remark') remark: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Inventory> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Inventory)
+    const inventory = await repository.findOne({ where: { domain: { id: domain.id }, id } })
+
+    return await repository.save({
+      ...inventory,
+      remark,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(Inventory).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Inventory])
+  async updateMultipleInventory(
+    @Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Inventory[]> {
+    return await updateMultipleInventory(patches, context)
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventories(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(Inventory).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async inventoryTransfer(
+    @Arg('originPalletId') originPalletId: string,
+    @Arg('palletId', { nullable: true }) palletId: string,
+    @Arg('cartonId', { nullable: true }) cartonId: string,
+    @Arg('fromLocationName') fromLocationName: string,
+    @Arg('toLocationName') toLocationName: string,
+    @Arg('qty') qty: number,
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, user, tx } = context.state
+
+    const fromLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain: { id: domain.id }, name: fromLocationName },
+      relations: ['domain', 'warehouse']
+    })
+    // 1. check toLocation exist
+    const toLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain: { id: domain.id }, name: toLocationName },
+      relations: ['domain', 'warehouse']
+    })
+    if (!toLocation) throw new Error(context.t(`error.To_location_does_not_exists`))
+
+    if (qty < 0) throw new Error(`Invalid quantity`)
+
+    // 2. search for related inventory
+    const invQb: SelectQueryBuilder<Inventory> = await tx
+      .getRepository(Inventory)
+      .createQueryBuilder('INV')
+      .innerJoinAndSelect('INV.location', 'loc')
+      .innerJoinAndSelect('INV.product', 'product')
+      .innerJoinAndSelect('INV.bizplace', 'bizplace')
+      .leftJoinAndSelect('INV.refInventory', 'refInventory')
+      .leftJoinAndSelect('INV.reusablePallet', 'reusablePallet')
+      .leftJoinAndSelect('INV.productDetail', 'productDetail')
+      .leftJoinAndSelect('bizplace.domain', 'domain')
+      .leftJoinAndSelect('product.productDetails', 'productDetails')
+      .leftJoinAndSelect('INV.originInventory', 'originInventory')
+      .where('INV.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('INV.pallet_id = :palletId', { palletId: originPalletId })
+
+    let inventory: Inventory = await invQb.getOne()
+    if (!inventory) throw new Error('Inventory not found')
+    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: {
+        domain: { id: domain.id },
+        id: Equal(inventory.refOrderId)
+      }
+    })
+
+    if (qty > inventory.qty - (inventory?.lockedQty > 0 ? inventory.lockedQty : 0))
+      throw new Error('Transfer quantity exceeded inventory quantity')
+
+    if (toLocation.name == inventory.location.name) throw new Error('Inventory is in current location')
+
+    let transactionInventory = new InventoryUtil(tx, domain, user)
+
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+      where: { domain: { id: inventory.bizplace.domain.id }, status: SellercraftStatus.ACTIVE },
+      relations: ['domain']
+    })
+
+    const partialTransferFunc = async function (inventory, qty, fromLocation, toLocation, cartonId, palletId, context) {
+      const { user, tx } = context.state
+
+      if (qty < inventory.qty - (inventory?.lockedQty > 0 ? inventory.lockedQty : 0)) {
+        if (!palletId || palletId.trim() == '') throw new Error('Require new lot id for partial transfer')
+
+        let transferQty = qty
+        let transferUomValue = (inventory.uomValue / inventory.qty) * qty
+        let newInventory = {
+          ...inventory,
+          palletId,
+          location: toLocation,
+          warehouse: toLocation.warehouse,
+          zone: toLocation.zone,
+          creator: user,
+          updater: user
+        }
+
+        delete newInventory.id
+        delete newInventory.updatedAt
+
+        newInventory.cartonId = cartonId
+        newInventory.qty = transferQty
+        newInventory.lockedQty = 0
+        newInventory.uomValue = transferUomValue
+        newInventory.lockedUomValue = 0
+        if (inventory.originInventory?.id) {
+          newInventory.originInventory = { id: inventory.originInventory.id }
+        } else {
+          newInventory.originInventory = { id: inventory.id }
+        }
+
+        await transactionInventory.transactionInventory(
+          { ...inventory, qty: inventory.qty - transferQty, uomValue: inventory.uomValue - transferUomValue },
+          arrivalNotice,
+          -transferQty,
+          -transferUomValue,
+          INVENTORY_TRANSACTION_TYPE.RELOCATE,
+          reason || null
+        )
+
+        await transactionInventory.transactionInventory(
+          newInventory,
+          arrivalNotice,
+          transferQty,
+          transferUomValue,
+          INVENTORY_TRANSACTION_TYPE.RELOCATE,
+          reason || null
+        )
+
+        if (sellercraft) {
+          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+          await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+          await sellercraftCtrl.updateSellercraftStock(sellercraft, newInventory)
+        }
+      } else {
+        inventory.warehouse = toLocation.warehouse
+        inventory.location = toLocation
+        inventory.zone = toLocation.zone
+        inventory.updater = user
+        inventory.cartonId = cartonId
+
+        let isEmptyLocation = await tx.getRepository(Inventory).find({
+          where: { location: { id: fromLocation.id } }
+        })
+
+        if ((isEmptyLocation.length = 1)) {
+          await tx.getRepository(Location).save({
+            ...fromLocation,
+            status: LOCATION_STATUS.EMPTY
+          })
+        }
+
+        await transactionInventory.transactionInventory(
+          inventory,
+          arrivalNotice,
+          0,
+          0,
+          INVENTORY_TRANSACTION_TYPE.RELOCATE,
+          reason || null
+        )
+
+        if (sellercraft) {
+          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+          await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+        }
+      }
+    }
+
+    if (inventory.cartonId && inventory.cartonId != '') {
+      if (!cartonId) throw new Error('Require carton id')
+
+      if (qty < inventory.qty - (inventory?.lockedQty > 0 ? inventory.lockedQty : 0)) {
+        palletId = await generateId({
+          domain: domain,
+          type: RULE_TYPE.LOT_NUMBER_ID,
+          seed: { date: DateGenerator.generateDate() }
+        })
+      }
+
+      await partialTransferFunc(inventory, qty, fromLocation, toLocation, cartonId, palletId, context)
+    } else {
+      if (!palletId) {
+        palletId = await generateId({
+          domain: domain,
+          type: RULE_TYPE.LOT_NUMBER_ID,
+          seed: { date: DateGenerator.generateDate() }
+        })
+      }
+      await partialTransferFunc(inventory, qty, fromLocation, toLocation, null, palletId, context)
+    }
+
+    return true
+  }
+}
+
+export async function updateMultipleInventory(
+  patches: InventoryPatch[],
+  context: ResolverContext
+): Promise<Inventory[]> {
+  const { domain, user, tx } = context.state
+
+  let results = []
+  const _createRecords = patches.filter((patch: any) => !patch.id)
+  const _updateRecords = patches.filter((patch: any) => patch.id)
+
+  const inventoryRepo = tx.getRepository(Inventory)
+  if (_createRecords.length > 0) {
+    let today = new Date()
+    let year = today.getFullYear()
+    let month = today.getMonth()
+    let date = today.getDate()
+
+    for (let i = 0; i < _createRecords.length; i++) {
+      const total = await tx.getRepository(Inventory).countBy({
+        createdAt: MoreThan(new Date(year, month, date))
+      })
+
+      const newRecord = _createRecords[i]
+
+      if (newRecord.location && newRecord.location.id) {
+        var location = await tx.getRepository(Location).findOne({
+          where: { id: newRecord.location.id },
+          relations: ['warehouse']
+        })
+        newRecord.location = location
+        newRecord.zone = location.zone
+        newRecord.warehouse = location.warehouse
+      }
+
+      if (newRecord.bizplace && newRecord.bizplace.id) {
+        newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
+      }
+
+      if (newRecord.product && newRecord.product.id) {
+        var product = (await tx.getRepository(Product).findOneBy({ id: newRecord.product.id })) as any
+        newRecord.product = product
+      }
+
+      let palletId =
+        'P' +
+        year.toString().substr(year.toString().length - 2) +
+        ('0' + (month + 1).toString()).substr(('0' + (month + 1).toString()).toString().length - 2) +
+        ('0' + date.toString()).substr(('0' + date.toString()).length - 2) +
+        ('0000' + (total + 1).toString()).substr(('0000' + (total + 1).toString()).length - 4)
+
+      newRecord.name = palletId
+      newRecord.status = newRecord.qty < 1 ? 'TERMINATED' : 'STORED'
+      newRecord.palletId = palletId
+
+      const result = await inventoryRepo.save({
+        domain: domain,
+        creator: user,
+        updater: user,
+        lastSeq: 0,
+        ...newRecord
+      } as any)
+
+      await tx.getRepository(InventoryHistory).save({
+        ...newRecord,
+        domain: domain,
+        creator: user,
+        updater: user,
+        name: InventoryNoGenerator.inventoryHistoryName(),
+        seq: 0,
+        transactionType: 'NEW',
+        productId: newRecord.product.id,
+        warehouseId: newRecord.warehouse.id,
+        locationId: newRecord.location.id
+      })
+
+      results.push({ ...result, cuFlag: '+' })
+    }
+  }
+
+  if (_updateRecords.length > 0) {
+    for (let i = 0; i < _updateRecords.length; i++) {
+      const newRecord = _updateRecords[i]
+      const newHistoryRecord = JSON.parse(JSON.stringify(_updateRecords[i]))
+      let transactionType = ''
+
+      let inventory = await inventoryRepo.findOne({
+        where: { id: newRecord.id },
+        relations: ['warehouse', 'location', 'product', 'bizplace']
+      })
+      newHistoryRecord.openingQty = inventory.qty
+      newHistoryRecord.openingUomValue = inventory.uomValue
+
+      // Get last sequence from InventoryHistory
+      let latestEntry = await tx.getRepository(InventoryHistory).find({
+        where: { palletId: inventory.palletId },
+        order: { seq: 'DESC' },
+        take: 1
+      })
+      let lastSeq = latestEntry[0].seq
+
+      // Condition 1: Change location (RELOCATE)
+      if (newRecord.location && newRecord.location.id) {
+        var location = await tx.getRepository(Location).findOne({
+          where: { id: newRecord.location.id },
+          relations: ['warehouse']
+        })
+        newRecord.location = location
+        newRecord.zone = location.zone
+        newRecord.warehouse = location.warehouse
+
+        newHistoryRecord.location = location
+        newHistoryRecord.zone = location.zone
+        newHistoryRecord.warehouse = location.warehouse
+
+        transactionType = 'RELOCATE'
+      }
+
+      // Condition 2: Change of qty or uomValue.
+      // Set qty movement for inventory history
+      if (typeof newRecord.qty != 'undefined') {
+        transactionType = 'ADJUSTMENT'
+        newHistoryRecord.qty = newRecord.qty - inventory.qty
+        if (newRecord.qty < 1) {
+          newRecord.status = 'TERMINATED'
+          newRecord.qty = 0
+          newRecord.uomValue = 0
+        }
+      } else {
+        newHistoryRecord.qty = 0
+      }
+      // Set uomValue movement for inventory history
+      if (typeof newRecord.uomValue != 'undefined') {
+        transactionType = 'ADJUSTMENT'
+        newHistoryRecord.uomValue = newRecord.uomValue - inventory.uomValue
+        if (newRecord.uomValue < 1) {
+          newRecord.uomValue = 0
+        }
+      } else {
+        newHistoryRecord.uomValue = 0
+      }
+
+      // Condition 3: Change of bizplace or product or batch id or packing type
+      if (newRecord.bizplace && newRecord.bizplace.id) {
+        newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
+      }
+
+      if (newRecord.product && newRecord.product.id) {
+        newRecord.product = (await tx.getRepository(Product).findOneBy({ id: newRecord.product.id })) as any
+      }
+
+      if (
+        (newRecord.product && newRecord.product.id) ||
+        (newRecord.bizplace && newRecord.bizplace.id) ||
+        newRecord.batchId ||
+        newRecord.packingType
+      ) {
+        if (
+          inventory.bizplace.id !== (newRecord.bizplace ? newRecord.bizplace.id : '') ||
+          inventory.product.id !== (newRecord.product ? newRecord.product.id : '') ||
+          inventory.batchId !== newRecord.batchId ||
+          inventory.packingType !== newRecord.packingType
+        ) {
+          transactionType = 'ADJUSTMENT'
+          lastSeq = lastSeq + 1
+          let inventoryHistory: any = {
+            ...inventory,
+            domain: domain,
+            bizplace: inventory.bizplace.id,
+            openingQty: inventory.qty,
+            openingUomValue: inventory.uomValue,
+            qty: -inventory.qty || 0,
+            uomValue: -inventory.uomValue || 0,
+            name: InventoryNoGenerator.inventoryHistoryName(),
+            seq: lastSeq,
+            inventory,
+            transactionType: transactionType,
+            status: INVENTORY_STATUS.TERMINATED,
+            productId: inventory.product.id,
+            warehouseId: inventory.warehouse.id,
+            locationId: inventory.location.id,
+            creator: user,
+            updater: user
+          }
+
+          delete inventoryHistory.id
+          await tx.getRepository(InventoryHistory).save(inventoryHistory as any)
+
+          newHistoryRecord.qty = newRecord.qty || inventory.qty
+          newHistoryRecord.uomValue = newRecord.uomValue || inventory.uomValue || 0
+          newHistoryRecord.openingQty = 0
+          newHistoryRecord.openingUomValue = 0
+          newHistoryRecord.batchId = newRecord.batchId || inventory.batchId || '-'
+        }
+      }
+
+      //Transaction type will be RELOCATE if there is only location change. Any other changes will be considered Adjustment.
+      lastSeq = lastSeq + 1
+      let inventoryHistory = {
+        ...inventory,
+        ...newHistoryRecord,
+        domain: domain,
+        creator: user,
+        updater: user,
+        name: InventoryNoGenerator.inventoryHistoryName(),
+        seq: lastSeq,
+        inventory,
+        transactionType: transactionType == '' ? 'ADJUSTMENT' : transactionType,
+        productId: newHistoryRecord.product ? newHistoryRecord.product.id : inventory.product.id,
+        warehouseId: newHistoryRecord.warehouse ? newHistoryRecord.warehouse.id : inventory.warehouse.id,
+        locationId: newHistoryRecord.location ? newHistoryRecord.location.id : inventory.location.id
+      }
+
+      delete inventoryHistory.id
+      await tx.getRepository(InventoryHistory).save(inventoryHistory)
+
+      const result = await inventoryRepo.save({
+        ...inventory,
+        ...newRecord,
+        updater: user,
+        lastSeq: lastSeq
+      })
+
+      results.push({ ...result, cuFlag: 'M' })
+    }
+  }
+
+  return results
+}