@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.2

package/server/entities/index.ts

@@ -1,8 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

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

package/server/graphql/resolvers/index.ts

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,92 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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
-  }
-}