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

package/server/index.ts

@@ -1,7 +1,11 @@
 export * from './constants'
-export * from './entities'
-export * from './graphql'
-export { createLocation, deleteLocation, deleteLocations, updateLocation } from './graphql/resolvers/location'
-export { createWarehouse, deleteWarehouse, deleteWarehouses, updateWarehouse } from './graphql/resolvers/warehouse'
+export { createLocation, deleteLocation, deleteLocations, updateLocation } from './service/location/location-mutation'
+export {
+  createWarehouse,
+  deleteWarehouse,
+  deleteWarehouses,
+  updateWarehouse
+} from './service/warehouse/warehouse-mutation'
 export * from './migrations'
 export * from './utils'
+export * from './service'

package/server/service/index.ts

@@ -0,0 +1,61 @@
+import { entities as InventoryEntities, resolvers as InventoryResolvers } from './inventory'
+import { entities as InventoryChangeEntities, resolvers as InventoryChangeResolvers } from './inventory-change'
+import { entities as InventoryHistoryEntities, resolvers as InventoryHistoryResvolers } from './inventory-history'
+import { entities as LocationEntities, resolvers as LocationResolvers } from './location'
+import { entities as MovementEntities, resolvers as MovementResolvers } from './movement'
+import { entities as PalletEntities, resolvers as PalletResolvers } from './pallet'
+import { entities as PalletCountEntities, resolvers as PalletCountResolvers } from './pallet-count'
+import { entities as PalletHistoryEntities, resolvers as PalletHistoryResolvers } from './pallet-history'
+import { entities as ReducedInventoryHistoryEntities } from './reduced-inventory-history'
+import { entities as WarehouseEntities, resolvers as WarehouseResolvers } from './warehouse'
+
+/* EXPORT ENTITY TYPES */
+export * from './inventory/inventory'
+export * from './inventory-change/inventory-change'
+export * from './inventory-history/inventory-history'
+export * from './location/location'
+export * from './movement/movement'
+export * from './pallet/pallet'
+export * from './pallet-count/pallet-count'
+export * from './pallet-history/pallet-history'
+export * from './warehouse/warehouse'
+export * from './reduced-inventory-history/reduced-inventory-history'
+
+/* EXPORT TYPES */
+export * from './inventory/inventory-types'
+export * from './inventory/inventory-types'
+export * from './inventory-change/inventory-change-types'
+export * from './inventory-history/inventory-history-types'
+export * from './location/location-types'
+export * from './movement/movement-types'
+export * from './pallet/pallet-types'
+export * from './pallet-count/pallet-count-types'
+export * from './pallet-history/pallet-history-types'
+export * from './warehouse/warehouse-types'
+
+export const entities = [
+  ...InventoryEntities,
+  ...InventoryChangeEntities,
+  ...InventoryHistoryEntities,
+  ...LocationEntities,
+  ...MovementEntities,
+  ...PalletEntities,
+  ...PalletCountEntities,
+  ...PalletHistoryEntities,
+  ...WarehouseEntities,
+  ...ReducedInventoryHistoryEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    ...InventoryResolvers,
+    ...InventoryChangeResolvers,
+    ...InventoryHistoryResvolers,
+    ...LocationResolvers,
+    ...MovementResolvers,
+    ...PalletResolvers,
+    ...PalletCountResolvers,
+    ...PalletHistoryResolvers,
+    ...WarehouseResolvers
+  ]
+}

package/server/service/inventory/index.ts

@@ -0,0 +1,6 @@
+import { Inventory } from './inventory'
+import { InventoryMutation } from './inventory-mutation'
+import { InventoryQuery } from './inventory-query'
+
+export const entities = [Inventory]
+export const resolvers = [InventoryQuery, InventoryMutation]

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
+  }
 }