@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

package/server/controllers/worksheet-controller.ts

@@ -1,8 +1,7 @@
-import { EntityManager, EntitySchema, Equal, FindOneOptions, In, Not } from 'typeorm'
+import { EntityManager, EntitySchema, Equal, FindOneOptions, In, Not, getRepository } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   ArrivalNotice,
@@ -165,7 +164,7 @@ export class WorksheetController {
     condition = this.tidyConditions(condition)
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
-        domain: this.domain,
+        domain: { id: this.domain.id },
         ...condition
       },
       relations
@@ -183,7 +182,7 @@ export class WorksheetController {
    * ex) findWorksheetById(id, ['arrivalNotice', 'releaseGood'])
    */
   async findWorksheetById(id: string, relations: string[] = ['worksheetDetails']): Promise<Worksheet> {
-    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne(id, { relations })
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({ where: { id }, relations })
     if (!worksheet) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(id))
 
     return worksheet
@@ -198,7 +197,7 @@ export class WorksheetController {
    */
   async findWorksheetByNo(worksheetNo: string, relations: string[] = ['worksheetDetails']): Promise<Worksheet> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
-      where: { domain: this.domain, name: worksheetNo },
+      where: { domain: { id: this.domain.id }, name: worksheetNo },
       relations
     })
 
@@ -247,10 +246,10 @@ export class WorksheetController {
     const bizplace: Bizplace = refOrder.bizplace
     const condition: FindOneOptions = {
       where: {
-        bizplace,
-        domain: this.domain,
+        bizplace: { id: bizplace.id },
+        domain: { id: this.domain.id },
         type,
-        [refOrderField]: refOrder
+        [refOrderField]: { id: refOrder.id }
       },
       relations
     }
@@ -308,7 +307,7 @@ export class WorksheetController {
     condition = this.tidyConditions(condition)
     const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
       where: {
-        domain: this.domain,
+        domain: { id: this.domain.id },
         ...condition
       },
       relations
@@ -326,7 +325,7 @@ export class WorksheetController {
    */
   async findWorksheetDetailByName(worksheetDetailName: string, relations?: string[]): Promise<WorksheetDetail> {
     const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
-      where: { domain: this.domain, name: worksheetDetailName },
+      where: { domain: { id: this.domain.id }, name: worksheetDetailName },
       relations
     })
 
@@ -336,7 +335,7 @@ export class WorksheetController {
 
   async findWorksheetDetailByNames(worksheetDetailNames: [string], relations?: string[]): Promise<WorksheetDetail[]> {
     const worksheetDetails: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
-      where: { domain: this.domain, name: In(worksheetDetailNames) },
+      where: { domain: { id: this.domain.id }, name: In(worksheetDetailNames) },
       relations
     })
 
@@ -393,7 +392,7 @@ export class WorksheetController {
     let existingWorksheet: Worksheet
     try {
       existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
-    } catch (e) {}
+    } catch (e) { }
 
     if (existingWorksheet)
       throw new Error(
@@ -489,7 +488,11 @@ export class WorksheetController {
    * @description
    * Update reference order like (ArrivalNotice, ReleaseGood, VasOrder, InventoryCheck)
    */
-  async updateRefOrder(refOrder: ReferenceOrderType, entitySchema?: EntitySchema): Promise<any> {
+  async updateRefOrder(
+    refOrder: ReferenceOrderType,
+    entitySchema?: EntitySchema,
+    currentStatus?: string
+  ): Promise<any> {
     if (!entitySchema) {
       if (refOrder instanceof ArrivalNotice) {
         entitySchema = ArrivalNotice
@@ -507,6 +510,25 @@ export class WorksheetController {
     if (!refOrder.id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
     if (!refOrder.updater?.id) refOrder = this.setStamp(refOrder)
 
+    if (currentStatus && entitySchema == ReleaseGood) {
+
+      let res = await getRepository(entitySchema).query(
+        `
+        update release_goods
+        set status = $1
+        where id = $2
+        and status = $3
+        returning id
+      `,
+        [refOrder.status, refOrder.id, currentStatus]
+      )
+
+      if (res[1] == 0) {
+        this.trxMgr.queryRunner.rollbackTransaction()
+        throw new Error('Worksheet has already been created')
+      }
+    }
+
     return await this.trxMgr.getRepository(entitySchema).save(refOrder)
   }
 
@@ -821,10 +843,15 @@ export class WorksheetController {
    */
   async notifyToUsers(users: User[], message: NotificationMsgInterface): Promise<void> {
     const receivers: any[] = users.map(user => user.id)
-    await sendNotification({
-      receivers,
-      message
-    })
+
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message
+    // })
   }
 
   /**
@@ -878,7 +905,8 @@ export class WorksheetController {
       worksheet.returnOrder ||
       null
     if (!refOrder) {
-      const wsWithRefOrd: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne(worksheet.id, {
+      const wsWithRefOrd: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+        where: { id: worksheet.id },
         relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder']
       })
 
@@ -903,7 +931,7 @@ export class WorksheetController {
    */
   async extractMultipleRefOrderFromWorksheet(worksheet: Worksheet): Promise<ReferenceOrderType> {
     const wsdWithRefOrd: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
-      where: { domain: this.domain, worksheet },
+      where: { domain: { id: this.domain.id }, worksheet: { id: worksheet.id } },
       relations: ['targetInventory', 'targetInventory.releaseGood']
     })
 
@@ -920,8 +948,8 @@ export class WorksheetController {
    * If there's positive result it will throw an error cause pallet is duplicated
    */
   async checkPalletDuplication(palletId: string): Promise<void> {
-    const duplicatedPalletCnt: number = await this.trxMgr.getRepository(Inventory).count({
-      domain: this.domain,
+    const duplicatedPalletCnt: number = await this.trxMgr.getRepository(Inventory).countBy({
+      domain: { id: this.domain.id },
       palletId,
       status: Not(Equal(INVENTORY_STATUS.TERMINATED))
     })
@@ -930,7 +958,7 @@ export class WorksheetController {
 
     const duplicatedReusablePalletCnt: number = await this.trxMgr.getRepository(Pallet).count({
       where: {
-        domain: this.domain,
+        domain: { id: this.domain.id },
         name: palletId
       }
     })
@@ -944,8 +972,8 @@ export class WorksheetController {
    * If there's positive result it will throw an error cause carton is duplicated
    */
   async checkCartonDuplication(cartonId: string, orderId: string): Promise<void> {
-    const duplicatedCartonCnt: number = await this.trxMgr.getRepository(Inventory).count({
-      domain: this.domain,
+    const duplicatedCartonCnt: number = await this.trxMgr.getRepository(Inventory).countBy({
+      domain: { id: this.domain.id },
       cartonId,
       refOrderId: Not(Equal(orderId)),
       status: Not(Equal(INVENTORY_STATUS.TERMINATED))
@@ -960,9 +988,9 @@ export class WorksheetController {
    * If there's positive result it will throw an error cause serial number is duplicated
    */
   async checkSerialNumberDuplication(serialNumber: string, product: Product): Promise<void> {
-    const duplicatedSerialNumberCnt: number = await this.trxMgr.getRepository(InventoryItem).count({
-      domain: this.domain,
-      product,
+    const duplicatedSerialNumberCnt: number = await this.trxMgr.getRepository(InventoryItem).countBy({
+      domain: { id: this.domain.id },
+      product: { id: product.id },
       serialNumber,
       status: Not(Equal(INVENTORY_STATUS.DELETED))
     })
@@ -1026,6 +1054,48 @@ export class WorksheetController {
     return childQty
   }
 
+  public async getDirectQty(
+    productDetail: ProductDetail,
+    productBarcode: string,
+    qty: number
+  ): Promise<any> {
+    try {
+      console.time('getDirectQty')
+      let results = await this.trxMgr.query(`
+        WITH RECURSIVE cte as (
+          select * from (
+            select pd.product_id as "productId", id, pd.packing_size as "packingSize",
+            pd.packing_type as "packingType", pd.uom as "uom", (pd.uom_value * $2::float) as "uomValue", $2::float as "qty", pd.gtin            
+            from product_details pd 
+            where pd.id = $1
+          ) as dt
+          union all
+          select pd.product_id as "productId", pd.id, pd.packing_size as "packingSize",
+          pd.packing_type as "packingType", pd.uom,
+          dt1.qty * pd.packing_size * pd.uom_value as "uomValue", dt1.qty * pd.packing_size as "qty", pd.gtin
+          from product_details pd
+          inner join cte dt1 on dt1.id = pd.child_product_detail_id 
+          where pd.deleted_at is null
+        )
+        select * from cte where gtin = $3
+      `, [
+        productDetail.id,
+        qty,
+        productBarcode
+      ])
+
+      if (results.length <= 0)
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+      console.timeEnd('getDirectQty')
+      return results[0]
+    } catch (error) {
+      throw error
+    }
+  }
+
+
+
   /**
    * @summary Check for product child qty at any scanned level
    * @description It will check every level of product detail by comparing scanned level and GAN registered level.

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

@@ -103,7 +103,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
   AS src 
   inner join domains d on d.id = src."domainId"
   inner join bizplaces b on b.id = src."bizplaceId"
-  where src."remainQty" > 0
+  where src."remainQty" >= 0
+  and src."qty" > 0
   order by src."domainId"
   `
 })

package/server/entities/worksheet-detail.ts

@@ -12,6 +12,15 @@ import { Worksheet } from './worksheet'
   (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

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

@@ -1,18 +1,15 @@
+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'
-import { EntityManager, getRepository, In } from 'typeorm'
 
 export const palletOutbound = {
-  async palletOutbound(_: any, { refOrderNo, patches }, context: any) {
-    const {
-      tx,
-      domain,
-      user,
-      bizplace
-    }: { tx: EntityManager; domain: Domain; user: User; bizplace: Bizplace } = context.state
+  async palletOutbound(_: any, { refOrderNo, patches }, context: ResolverContext) {
+    const { tx, domain, user, bizplace }: { tx: EntityManager; domain: Domain; user: User; bizplace?: Bizplace } =
+      context.state
 
     const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
       where: { name: refOrderNo },

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

@@ -1,16 +1,18 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
+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'
-import { InventoryChange } from '@things-factory/warehouse-base'
 
 export const batchPickingWorksheetResolver = {
-  async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: ResolverContext) {
+    const { domain } = context.state
     const worksheet: Worksheet = await getRepository(Worksheet).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         taskNo,
         type: WORKSHEET_TYPE.BATCH_PICKING,
         status: WORKSHEET_STATUS.EXECUTING

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

@@ -1,18 +1,11 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import {
-  ORDER_STATUS,
-  DraftReleaseGood
-} from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { DraftReleaseGood, ORDER_STATUS } from '@things-factory/sales-base'
 
 export const cancelDraftReleaseOrder = {
-  async cancelDraftReleaseOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async cancelDraftReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
 
     const foundDRO: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     if (foundDRO) {

package/server/graphql/resolvers/worksheet/check-inventory-release.ts

@@ -1,16 +1,17 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository, In, Repository } from 'typeorm'
+import { In, Repository } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS, ORDER_TYPES, OrderInventory } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { OrderInventory, ORDER_INVENTORY_STATUS, ORDER_TYPES } from '@things-factory/sales-base'
 
 export const checkInventoryReleaseResolver = {
-  async checkInventoryRelease(_: any, { palletId }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async checkInventoryRelease(_: any, { palletId }, context: ResolverContext) {
+    const { domain } = context.state
     const invRepo: Repository<Inventory> = getRepository(Inventory)
     const oiRepo: Repository<OrderInventory> = getRepository(OrderInventory)
 
     const inventory: Inventory = await invRepo.findOne({
-      where: { domain, palletId },
+      where: { domain: { id: domain.id }, palletId },
       relations: ['bizplace']
     })
 
@@ -23,7 +24,7 @@ export const checkInventoryReleaseResolver = {
     ]
 
     const orderInventories: OrderInventory[] = await oiRepo.find({
-      where: { domain, inventory, type: ORDER_TYPES.RELEASE_OF_GOODS, status: In(oiStatuses) }
+      where: { domain: { id: domain.id }, inventory, type: ORDER_TYPES.RELEASE_OF_GOODS, status: In(oiStatuses) }
     })
 
     return Boolean(orderInventories?.length > 0)

package/server/graphql/resolvers/worksheet/check-stock-take-current-location.ts

@@ -1,23 +1,25 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository, Repository } from 'typeorm'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Repository } from 'typeorm'
+
 import { InventoryCheck, OrderInventory } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import { WorksheetDetail } from '../../../entities'
 
 export const checkStockTakeCurrentLocationResolver = {
-  async checkStockTakeCurrentLocation(_: any, { palletId, cycleCountNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async checkStockTakeCurrentLocation(_: any, { palletId, cycleCountNo }, context: ResolverContext) {
+    const { domain } = context.state
     const invRepo: Repository<Inventory> = getRepository(Inventory)
     const worksheetDetailRepo: Repository<WorksheetDetail> = getRepository(WorksheetDetail)
     const inventoryCheckRepo: Repository<InventoryCheck> = getRepository(InventoryCheck)
 
     const inventory: Inventory = await invRepo.findOne({
-      where: { domain, palletId },
+      where: { domain: { id: domain.id }, palletId },
       relations: ['bizplace']
     })
 
     const cycleCount: InventoryCheck = await inventoryCheckRepo.findOne({
-      where: { domain, name: cycleCountNo },
+      where: { domain: { id: domain.id }, name: cycleCountNo },
       relations: [
         'orderInventories',
         'orderInventories.inventory',
@@ -37,7 +39,7 @@ export const checkStockTakeCurrentLocationResolver = {
         .filter((oi: OrderInventory) => oi.inventory.palletId === inventory.palletId)
         .map(async (oi: OrderInventory) => {
           const matchingWSD = await worksheetDetailRepo.findOne({
-            where: { domain, targetInventory: oi }
+            where: { domain: { id: domain.id }, targetInventory: oi }
           })
 
           return matchingWSD