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

package/server/entities/index.ts

@@ -0,0 +1,8 @@
+import { Worksheet } from './worksheet'
+import { WorksheetDetail } from './worksheet-detail'
+import { WorksheetMovement } from './worksheet-movement'
+import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
+
+export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
+
+export { Worksheet, WorksheetDetail, WorksheetMovement }

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -0,0 +1,148 @@
+import { ViewColumn, ViewEntity } from 'typeorm'
+
+@ViewEntity({
+  expression: `  
+  select d.name as "domainName", b.name as "bizplaceName", src.* from (
+    WITH oi as (
+      select
+        oi.domain_id,
+        oi.bizplace_id,
+        SUM(oi.release_qty) AS release_qty,
+        SUM(oi.release_uom_value) AS release_uom_value,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+      FROM
+        order_inventories oi
+      WHERE
+        (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+        AND oi.batch_id NOTNULL
+        AND oi.product_id NOTNULL
+        AND oi.packing_type NOTNULL
+        AND oi.packing_size NOTNULL
+        AND oi.inventory_id IS NULL
+      GROUP BY
+        oi.domain_id,
+        oi.bizplace_id,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+    ) 
+    -- SINGLE ITEM INVENTORY QUERY
+    select
+    i.domain_id as "domainId",
+    i.bizplace_id as "bizplaceId",
+    i.packing_type as "packingType",
+    i.packing_size as "packingSize",
+    i.uom,
+    i.product_id as "productId",
+    null as "productBundleId",
+    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) AS "remainQty",
+    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)), 0) AS "remainUomValue",
+    COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
+    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uomValue",
+    'SINGLE' AS "groupType"
+    FROM inventories i
+    INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
+    LEFT JOIN oi ON i.batch_id = oi.batch_id AND i.product_id = oi.product_id AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
+    WHERE i.status = 'STORED'
+    GROUP by
+      i.domain_id,
+      i.bizplace_id,
+      i.product_id,
+      i.packing_type,
+      i.packing_size,
+      i.uom
+    union all
+    -- BUNDLE ITEM INVENTORY QUERY
+    SELECT 
+    pbs.domain_id as "domainId",
+    pbs.bizplace_id as "bizplaceId",
+    pb.packing_type as "packingType", 
+    pb.packing_size as "packingSize",
+    'UNIT' AS "uom", 
+    null as "productId",
+    pb.id AS "productBundleId",
+    COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
+    COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue",
+    COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
+    COALESCE(MIN(FLOOR(pbs."uomValue")), 0::double precision) AS "uomValue",
+    'BUNDLE' AS "groupType"
+    FROM product_bundles pb
+    INNER JOIN (
+      SELECT i.domain_id, i.bizplace_id, pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
+      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
+      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
+      (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
+      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uomValue"
+      FROM product_bundle_settings pbs 
+      LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED'
+      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE')    
+      LEFT JOIN oi ON oi.product_id = i.product_id
+      GROUP by
+        i.domain_id, 
+        i.bizplace_id,
+        pbs.product_id, 
+        pbs.product_bundle_id
+    ) pbs ON pbs.product_bundle_id = pb.id
+    GROUP BY 
+    pbs.domain_id,
+    pbs.bizplace_id,
+    pb.packing_type, 
+    pb.packing_size, 
+    pb.name, 
+    pb.sku, 
+    pb.id
+  )
+  AS src 
+  inner join domains d on d.id = src."domainId"
+  inner join bizplaces b on b.id = src."bizplaceId"
+  where src."remainQty" >= 0
+  and src."qty" > 0
+  order by src."domainId"
+  `
+})
+
+export class WarehouseBizplaceOnhandInventory {
+  @ViewColumn()
+  domainName: string
+
+  @ViewColumn()
+  bizplaceName: string
+
+  @ViewColumn()
+  domainId: string
+
+  @ViewColumn()
+  bizplaceId: string
+
+  @ViewColumn()
+  packingType: string
+
+  @ViewColumn()
+  packingSize: number
+
+  @ViewColumn()
+  uom: string
+
+  @ViewColumn()
+  productId: string
+
+  @ViewColumn()
+  productBundleId: string
+
+  @ViewColumn()
+  remainQty: number
+
+  @ViewColumn()
+  remainUomValue: number
+
+  @ViewColumn()
+  groupType: string
+}

package/server/entities/worksheet-detail.ts

@@ -0,0 +1,106 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, Worker } from '@things-factory/biz-base'
+import { OrderInventory, OrderProduct, OrderVas } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import { Worksheet } from './worksheet'
+
+@Entity()
+@Index(
+  'ix_worksheet-detail_0',
+  (worksheetDetail: WorksheetDetail) => [worksheetDetail.domain, worksheetDetail.bizplace, worksheetDetail.name],
+  { unique: true }
+)
+@Index(
+  'ix_worksheet-detail_1',
+  (worksheetDetail: WorksheetDetail) => [worksheetDetail.targetInventory]
+)
+@Index(
+  'ix_worksheet-detail_2',
+  (worksheetDetail: WorksheetDetail) => [worksheetDetail.id],
+  { unique: true }
+)
+export class WorksheetDetail {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @ManyToOne(type => Bizplace)
+  bizplace: Bizplace
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  /**
+   * @description Sequance for VAS Order
+   */
+  @Column({
+    nullable: true,
+    type: 'smallint',
+    default: 0
+  })
+  seq: number
+
+  @Column()
+  type: string
+
+  @Column()
+  status: string
+
+  @ManyToOne(type => Worksheet, {
+    nullable: false
+  })
+  worksheet: Worksheet
+
+  @ManyToOne(type => Worker)
+  worker: Worker
+
+  @ManyToOne(type => OrderProduct)
+  targetProduct: OrderProduct
+
+  @ManyToOne(type => OrderVas)
+  targetVas: OrderVas
+
+  @ManyToOne(type => OrderInventory)
+  targetInventory: OrderInventory
+
+  @ManyToOne(type => Location)
+  fromLocation: Location
+
+  @ManyToOne(type => Location)
+  toLocation: Location
+
+  @Column({
+    nullable: true
+  })
+  remark: string
+
+  @Column({
+    nullable: true
+  })
+  issue: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+}

package/server/entities/worksheet-movement.ts

@@ -0,0 +1,34 @@
+import { Domain } from '@things-factory/shell'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { Worksheet } from './worksheet'
+
+@Entity()
+@Index('ix_worksheet-movement_0', (worksheetMovement: WorksheetMovement) => [worksheetMovement.domain], {
+  unique: true
+})
+export class WorksheetMovement {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column({
+    nullable: true
+  })
+  date: Date
+
+  @ManyToOne(type => Worksheet)
+  worksheet: Worksheet
+
+  @Column({ nullable: true })
+  startTime: Date
+
+  @Column({ nullable: true })
+  endTime: Date
+
+  @Column({
+    nullable: true
+  })
+  description: string
+}

package/server/entities/worksheet.ts

@@ -0,0 +1,100 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import {
+  ArrivalNotice,
+  InventoryCheck,
+  ReleaseGood,
+  ShippingOrder,
+  VasOrder,
+  ReturnOrder
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+import { WorksheetDetail } from './worksheet-detail'
+
+@Entity()
+@Index('ix_worksheet_0', (worksheet: Worksheet) => [worksheet.domain, worksheet.bizplace, worksheet.name], {
+  unique: true
+})
+@Index('ix_worksheet_1', (worksheet: Worksheet) => [worksheet.arrivalNotice, worksheet.type])
+@Index('ix_worksheet_2', (worksheet: Worksheet) => [worksheet.releaseGood, worksheet.type])
+export class Worksheet {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @ManyToOne(type => Bizplace)
+  bizplace: Bizplace
+
+  @ManyToOne(type => ArrivalNotice)
+  arrivalNotice: ArrivalNotice
+
+  @ManyToOne(type => ReleaseGood)
+  releaseGood: ReleaseGood
+
+  @ManyToOne(type => ReturnOrder)
+  returnOrder: ReturnOrder
+
+  @ManyToOne(type => InventoryCheck)
+  inventoryCheck: InventoryCheck
+
+  @ManyToOne(type => VasOrder)
+  vasOrder: VasOrder
+
+  @ManyToOne(type => ShippingOrder)
+  shippingOrder: ShippingOrder
+
+  @ManyToOne(type => Location)
+  bufferLocation: Location
+
+  @Column()
+  name: string
+
+  @Column({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  taskNo: string
+
+  @Column()
+  type: string
+
+  @OneToMany(type => WorksheetDetail, worksheetDetail => worksheetDetail.worksheet)
+  worksheetDetails: WorksheetDetail[]
+
+  @Column()
+  status: string
+
+  @ManyToOne(type => User)
+  assignee: User
+
+  @Column({ nullable: true })
+  startedAt: Date
+
+  @Column({ nullable: true })
+  endedAt: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  creator: User
+
+  @ManyToOne(type => User, { nullable: true })
+  updater: User
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+}

package/server/graphql/index.ts

@@ -0,0 +1,7 @@
+import * as typeDefs from './types'
+import * as resolvers from './resolvers'
+
+export const schema = {
+  typeDefs,
+  resolvers
+}

package/server/graphql/resolvers/index.ts

@@ -0,0 +1,8 @@
+import * as Worksheet from './worksheet'
+import * as WorksheetDetail from './worksheet-detail'
+import * as WorksheetMovement from './worksheet-movement'
+import * as Pallet from './pallet'
+
+export const queries = [Worksheet.Query, WorksheetDetail.Query, WorksheetMovement.Query]
+
+export const mutations = [Worksheet.Mutation, WorksheetDetail.Mutation, WorksheetMovement.Mutation, Pallet.Mutation]

package/server/graphql/resolvers/pallet/index.ts

@@ -0,0 +1,7 @@
+import { palletOutbound } from './pallet-outbound'
+
+export const Mutation = {
+  ...palletOutbound
+}
+
+export const Query = {}

package/server/graphql/resolvers/pallet/pallet-outbound.ts

@@ -0,0 +1,92 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Pallet, PalletHistory } from '@things-factory/warehouse-base'
+
+export const palletOutbound = {
+  async palletOutbound(_: any, { refOrderNo, patches }, context: ResolverContext) {
+    const { tx, domain, user, bizplace } = context.state
+
+    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { name: refOrderNo },
+      relations: ['bizplace']
+    })
+
+    let palletPatches: Pallet[] =
+      patches.length > 0
+        ? await tx.getRepository(Pallet).find({
+            where: { id: In(patches.map(pallet => pallet.id)) },
+            relations: ['owner', 'holder', 'domain', 'creator', 'updater']
+          })
+        : []
+
+    let releasedPallets: Pallet[] = await tx.getRepository(Pallet).find({
+      where: { refOrderNo: refOrderNo },
+      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
+    })
+
+    // get added pallets
+    let addedPallets: Pallet[] = palletPatches
+      .filter(e => e.refOrderNo == null)
+      .map(pallet => {
+        return {
+          ...pallet,
+          holder: releaseGood.bizplace,
+          refOrderNo: refOrderNo,
+          seq: pallet.seq + 1
+        }
+      })
+
+    // get removed pallets
+    let removedPallets: Pallet[] = releasedPallets
+      .filter(e => !palletPatches.find(patch => patch.id == e.id))
+      .map(pallet => {
+        return {
+          ...pallet,
+          holder: pallet.owner,
+          refOrderNo: null,
+          seq: pallet.seq - 1
+        }
+      })
+
+    // Add into pallet history for outbound
+    await Promise.all(
+      addedPallets.map(async pallet => {
+        let newHistory = {
+          ...pallet,
+          pallet: pallet,
+          domain: domain,
+          creator: user,
+          updater: user,
+          transactionType: 'OUTBOUND'
+        }
+        delete newHistory.id
+
+        await tx.getRepository(PalletHistory).save({
+          ...newHistory
+        })
+      })
+    )
+
+    // Roll back pallet history
+    await Promise.all(
+      removedPallets.map(async item => {
+        tx.getRepository(PalletHistory).delete({ name: item.name, seq: item.seq + 1 })
+      })
+    )
+
+    // Update Pallet data
+    await Promise.all(
+      [...addedPallets, ...removedPallets].map(async item => {
+        await tx.getRepository(Pallet).save({
+          ...item
+        })
+      })
+    )
+
+    return true
+  }
+}

package/server/graphql/resolvers/worksheet/batch-picking-worksheet.ts

@@ -0,0 +1,137 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { InventoryChange } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const batchPickingWorksheetResolver = {
+  async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: ResolverContext) {
+    const { domain } = context.state
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        taskNo,
+        type: WORKSHEET_TYPE.BATCH_PICKING,
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+
+    if (!worksheet) throw new Error(`Couldn't find picking worksheet - (${taskNo})`)
+
+    const qb: SelectQueryBuilder<WorksheetDetail> = getRepository(WorksheetDetail).createQueryBuilder('WSD')
+    qb.select('INV.id', 'inventoryId')
+      .addSelect('SUM(T_INV.releaseQty)', 'releaseQty')
+      .addSelect('SUM(T_INV.pickedQty)', 'pickedQty')
+      .addSelect('"INV".pallet_id', 'palletId')
+      .addSelect('"INV".carton_id', 'cartonId')
+      .addSelect('"INV".expiration_date', 'expirationDate')
+      .addSelect('"INV".batch_id', 'batchId')
+      .addSelect('"PROD".id', 'productId')
+      .addSelect('"PROD".name', 'productName')
+      .addSelect('"PROD".sku', 'productSku')
+      .addSelect('"PROD".description', 'productDescription')
+      .addSelect('"INV".qty', 'qty')
+      .addSelect('"INV".packing_type', 'packingType')
+      .addSelect('"INV".packing_size', 'packingSize')
+      .addSelect('"T_INV".batch_id', 'targetBatchId')
+      .addSelect('"T_INV".packing_type', 'targetPackingType')
+      .addSelect('LOC.name', 'locationName')
+      .addSelect('LOC.zone', 'zone')
+      .addSelect('LOC.row', 'row')
+      .addSelect('LOC.column', 'column')
+      .addSelect('LOC.shelf', 'shelf')
+      .addSelect('BIN_LOC.name', 'binLocationName')
+      .addSelect('WSD.status', 'status')
+      .leftJoin('WSD.targetInventory', 'T_INV')
+      .leftJoin('T_INV.inventory', 'INV')
+      .leftJoin('T_INV.product', 'PROD')
+      .leftJoin('T_INV.binLocation', 'BIN_LOC')
+      .leftJoin('INV.location', 'LOC')
+      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+      .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
+      .groupBy('"INV".id')
+      .addGroupBy('"INV".pallet_id')
+      .addGroupBy('"INV".carton_id')
+      .addGroupBy('"INV".expiration_date')
+      .addGroupBy('"INV".batch_id')
+      .addGroupBy('"INV".qty')
+      .addGroupBy('"INV".packing_type')
+      .addGroupBy('"INV".packing_size')
+      .addGroupBy('"PROD".id')
+      .addGroupBy('"PROD".name')
+      .addGroupBy('"PROD".sku')
+      .addGroupBy('"PROD".description')
+      .addGroupBy('"T_INV".batch_id')
+      .addGroupBy('"T_INV".packing_type')
+      .addGroupBy('BIN_LOC.name')
+      .addGroupBy('LOC.name')
+      .addGroupBy('LOC.zone')
+      .addGroupBy('LOC.column')
+      .addGroupBy('LOC.row')
+      .addGroupBy('LOC.shelf')
+      .addGroupBy('WSD.status')
+
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
+
+    const items: any[] = await qb.getRawMany()
+
+    return {
+      worksheetInfo: {
+        startedAt: worksheet.startedAt,
+        bizplaceName: worksheet.bizplace.name,
+        partnerDomainId: worksheet.bizplace?.domain.id
+      },
+      worksheetDetailInfos: items.map(async (item: any) => {
+        const inventoryChangesCount: number = await getRepository(InventoryChange).count({
+          where: {
+            inventory: { id: item.inventoryId },
+            status: 'PENDING',
+            transactionType: 'MISSING'
+          },
+          relations: ['inventory', 'product']
+        })
+
+        return {
+          palletId: item?.palletId,
+          cartonId: item?.cartonId,
+          batchId: item?.batchId,
+          product: {
+            id: item?.productId,
+            name: item?.productName,
+            description: item?.productDescription,
+            sku: item?.productSku
+          },
+          qty: item?.qty,
+          releaseQty: item.releaseQty,
+          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false,
+          status: item.status,
+          pickedQty: item.pickedQty,
+          packingType: item?.packingType,
+          packingSize: item?.packingSize,
+          expirationDate: item?.expirationDate,
+          location: { name: item?.locationName },
+          binLocation: { name: item?.binLocationName },
+          relatedOrderInv: {
+            batchId: item?.targetBatchId,
+            packingType: item?.targetPackingType,
+            product: {
+              id: item?.productId,
+              name: item?.productName,
+              description: item?.productDescription,
+              sku: item?.productSku
+            }
+          }
+        }
+      })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/cancel-draft-release-order.ts

@@ -0,0 +1,20 @@
+import { DraftReleaseGood, ORDER_STATUS } from '@things-factory/sales-base'
+
+export const cancelDraftReleaseOrder = {
+  async cancelDraftReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    const foundDRO: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    if (foundDRO) {
+      await tx.getRepository(DraftReleaseGood).save({
+        ...foundDRO,
+        status: ORDER_STATUS.CANCELLED,
+        updater: user
+      })
+    }
+    return
+  }
+}