@things-factory/warehouse-base 4.0.0-y.0 → 4.0.0

package/server/{graphql/resolvers/inventory/update-multiple-inventory.ts → service/inventory/inventory-mutation.ts}

@@ -1,14 +1,99 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, MoreThan, SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
-import { EntityManager, MoreThan } from 'typeorm'
-import { Inventory, InventoryHistory, Location } from '../../../entities'
-import { InventoryNoGenerator } from '../../../utils'
-import { INVENTORY_STATUS } from '../../../constants'
+import { Domain } from '@things-factory/shell'
+
+import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE } from '../../constants'
+import { generateInventoryHistory, InventoryNoGenerator } 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: any): Promise<Inventory> {
+    const { tx }: { tx: EntityManager } = context.state
 
-export const updateMultipleInventory = {
-  async updateMultipleInventory(_: any, { patches }, context: any) {
+    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: any): Promise<Inventory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = 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: any
+  ): Promise<Inventory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(Inventory)
+    const inventory = await repository.findOne({ where: { domain: domain, 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: any): Promise<Boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    await tx.getRepository(Inventory).delete({ domain: context.state.domain, name })
+    return true
+  }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Inventory])
+  async updateMultipleInventory(
+    @Arg('patches', type => [InventoryPatch]) patches: InventoryPatch[],
+    @Ctx() context: any
+  ): Promise<Inventory[]> {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     let results = []
@@ -231,4 +316,70 @@ export const updateMultipleInventory = {
 
     return results
   }
+
+  @Directive('@privilege(category: "inventory", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventories(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { tx }: { tx: EntityManager } = 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('palletId') palletId: string,
+    @Arg('cartonId') cartonId: string,
+    @Arg('fromLocationName') fromLocationName: string,
+    @Arg('toLocationName') toLocationName: string,
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    // 1. check toLocation exist
+    const toLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain: domain, name: toLocationName },
+      relations: ['domain', 'warehouse']
+    })
+    if (!toLocation) throw new Error(`To location doesn't exists`)
+
+    const fromLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain: domain, name: fromLocationName },
+      relations: ['domain', 'warehouse']
+    })
+    if (!toLocation) throw new Error(`From location doesn't exists`)
+
+    // 2. search for related inventory
+    const invQb: SelectQueryBuilder<Inventory> = await tx
+      .getRepository(Inventory)
+      .createQueryBuilder('INV')
+      .where('INV.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('INV.location_id = :fromLocationId', { fromLocationId: fromLocation.id })
+
+    if (cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: cartonId })
+    else invQb.andWhere('INV.pallet_id = :palletId', { palletId: palletId })
+
+    let inventories: Inventory[] = await invQb.getMany()
+    if (!inventories?.length) throw new Error('Inventory not found')
+
+    await Promise.all(
+      inventories.map(async (inventory: Inventory) => {
+        inventory.warehouse = toLocation.warehouse
+        inventory.location = toLocation
+        inventory.zone = toLocation.zone
+        inventory.updater = user
+        inventory = await tx.getRepository(Inventory).save(inventory)
+
+        await generateInventoryHistory(inventory, null, INVENTORY_TRANSACTION_TYPE.RELOCATE, 0, 0, user, tx)
+      })
+    )
+
+    return true
+  }
 }