@things-factory/sales-base 4.3.449 → 4.3.453

package/server/service/draft-release-good/draft-release-good-type.ts

@@ -1,4 +1,9 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import {
+  Field,
+  InputType,
+  Int,
+  ObjectType
+} from 'type-graphql'
 
 import { ObjectRef } from '@things-factory/shell'
 
@@ -266,8 +271,29 @@ export class DraftReleaseGoodPatch {
 @ObjectType()
 export class DraftReleaseGoodList {
   @Field(type => [DraftReleaseGood])
-  items: DraftReleaseGood[]
+  items?: DraftReleaseGood[]
 
   @Field(type => Int)
   total: number
+
+  @Field({ nullable: true })
+  settingValue: string
+}
+
+@ObjectType()
+export class SuccessReleasedDraftOrder {
+  @Field({ nullable: true })
+  draftName?: string
+
+  @Field({ nullable: true })
+  isProductBundle?: Boolean
+}
+
+@InputType()
+export class DraftReleaseGoodInfos {
+  @Field()
+  id: String
+
+  @Field()
+  releaseType?: string
 }

package/server/service/draft-release-good/draft-release-good.ts

@@ -17,8 +17,8 @@ import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
 import { LastMileDelivery } from '@things-factory/integration-lmd'
+import { Domain } from '@things-factory/shell'
 
 import { OrderProduct, ReleaseGood, ShippingOrder, ShippingOrderInfo } from '../'
 import { ReleaseOrderType } from '../../constants'
@@ -66,14 +66,9 @@ export class DraftReleaseGood {
   @Field({ nullable: true })
   name: string
 
-  @OneToOne(type => ReleaseGood)
-  @JoinColumn()
+  @OneToMany(type => ReleaseGood, releaseGood => releaseGood.draftReleaseGood)
   @Field(type => ReleaseGood, { nullable: true })
   releaseGood: ReleaseGood
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.releaseGood)
-  releaseGoodId: string
-
   @OneToOne(type => ShippingOrder)
   @JoinColumn()
   @Field(type => ShippingOrder, { nullable: true })
@@ -356,4 +351,3 @@ export class DraftReleaseGood {
   @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.lastMileDelivery)
   lastMileDeliveryId?: string
 }
-

package/server/service/draft-release-good/index.ts

@@ -1,9 +1,11 @@
 import { DraftReleaseGood } from './draft-release-good'
-import { DraftReleaseGoodQuery } from './draft-release-good-query'
+import { DraftReleaseGoodCreate } from './draft-release-good-create'
 import { DraftReleaseGoodMutation } from './draft-release-good-mutation'
+import { DraftReleaseGoodQuery } from './draft-release-good-query'
 
 export const entities = [DraftReleaseGood]
-export const resolvers = [DraftReleaseGoodQuery, DraftReleaseGoodMutation]
+export const resolvers = [DraftReleaseGoodQuery, DraftReleaseGoodMutation, DraftReleaseGoodCreate]
 
 export * from './draft-release-good-mutation'
 export * from './draft-release-good-query'
+export * from './draft-release-good-create'

package/server/service/order-vas/order-vas-mutation.ts

@@ -1,8 +1,12 @@
+import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository } from 'typeorm'
-import { OrderVasPatch } from '../'
+import { EntityManager, getRepository, In } from 'typeorm'
+import { OrderVasPatch, OrderVasItemPatch } from '../'
 import { OrderVas } from './order-vas'
+import { OrderVasItem } from '../order-vas-item/order-vas-item'
+import { ReleaseGood } from '../release-good/release-good'
+import { v4 as uuidv4 } from 'uuid'
 // import { WorksheetDetail } from '@things-factory/worksheet-base'
 
 @Resolver(OrderVas)
@@ -23,46 +27,61 @@ export class OrderVasMutation {
   @Directive('@transaction')
   @Mutation(returns => [OrderVas])
   async updateMultipleOrderVas(
+    @Arg('orderNo') orderNo: string,
     @Arg('patches', type => [OrderVasPatch]) patches: OrderVasPatch[],
     @Ctx() context: any
-  ): Promise<OrderVasPatch[]> {
-    const { domain, user } = context.state
+  ): Promise<OrderVas[]> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
 
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const orderVasRepo = getRepository(OrderVas)
+    const releaseGood = await tx.getRepository(ReleaseGood).findOne({ where: { name: orderNo, domain: domain.id } })
+
+    patches.forEach(patch => (patch.releaseGood = releaseGood))
+
+    const createPatches = patches.filter(patch => patch.cuFlag.toUpperCase() === '+')
+    const updatePatches = patches.filter(patch => patch.cuFlag.toUpperCase() === 'M')
 
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
+    const orderVasRepo = tx.getRepository(OrderVas)
+    const orderVasItemRepo = tx.getRepository(OrderVasItem)
+    let results = []
 
-        const result = await orderVasRepo.save({
-          ...newRecord,
+    // Handle creation
+    for (const newRecord of createPatches) {
+      const savedOrderVas = await orderVasRepo.save({
+        ...newRecord,
+        name: uuidv4(),
+        releaseGood: newRecord.releaseGood,
+        domain: domain,
+        creator: user,
+        updater: user
+      })
+
+      results.push(savedOrderVas)
+
+      for (const itemPatch of newRecord.orderVasItemsPatch) {
+        await orderVasItemRepo.save({
+          orderVas: savedOrderVas,
+          name: `${itemPatch.vas.name} (${itemPatch.vas.description})- ${savedOrderVas.id}`,
+          vas: itemPatch.vas,
+          vasQty: itemPatch.vasQty,
+          vasRemark: itemPatch.vasRemark,
           domain: domain,
-          creator: user,
-          updater: user
+          creator: user
         })
-
-        results.push({ ...result, cuFlag: '+' })
       }
     }
 
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const orderVas = await orderVasRepo.findOne({
-          where: { domain, id: newRecord.id },
-          relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
-        })
+    // Handle updates
+    for (const patch of updatePatches) {
+      for (const itemPatch of patch.orderVasItemsPatch) {
+        const existingOrderVasItem = await orderVasItemRepo.findOne({ where: { orderVas: patch.id } })
 
-        const result = await orderVasRepo.save({
-          ...orderVas,
-          ...newRecord,
+        const updateData = {
+          vasQty: itemPatch.vasQty,
+          vasRemark: itemPatch.vasRemark,
           updater: user
-        })
+        }
 
-        results.push({ ...result, cuFlag: 'M' })
+        await orderVasItemRepo.update(existingOrderVasItem.id, updateData)
       }
     }
 
@@ -74,6 +93,15 @@ export class OrderVasMutation {
   @Mutation(returns => Boolean)
   async deleteOrderVas(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
     const { tx }: { tx: EntityManager } = context.state
+
+    // Retrieve and delete all related OrderVasItems
+    const orderVasItemRepo = tx.getRepository(OrderVasItem)
+    const orderVasItems = await orderVasItemRepo.find({ where: { orderVas: id } })
+    if (orderVasItems.length > 0) {
+      await orderVasItemRepo.remove(orderVasItems)
+    }
+
+    // Delete the OrderVas
     await tx.getRepository(OrderVas).delete(id)
     return true
   }

package/server/service/order-vas/order-vas-query.ts

@@ -2,7 +2,7 @@ import { User } from '@things-factory/auth-base'
 import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { getRepository } from 'typeorm'
-import { OrderVasList } from '../'
+import { OrderVasList, ReleaseGood } from '../'
 import { OrderVas } from './order-vas'
 
 @Resolver(OrderVas)
@@ -34,6 +34,48 @@ export class OrderVasQuery {
     return { items, total }
   }
 
+  @Query(returns => OrderVasList)
+  async orderVasList(
+    @Ctx() context: any,
+    @Arg('bizplaceId') bizplaceId: string,
+    @Arg('orderNo') orderNo: string
+  ): Promise<OrderVasList> {
+    const { domain }: { domain: Domain } = context.state
+
+    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      where: { name: orderNo, domain: domain.id, bizplace: bizplaceId }
+    })
+
+    // Possible enhancement: Add creator type or add a new boolean column to determine is vas is added by warehouse staff
+    const qb = getRepository(OrderVas).createQueryBuilder('ov')
+    qb.innerJoinAndSelect('ov.orderVasItems', 'ovi')
+      .innerJoinAndSelect('ovi.vas', 'v')
+      .where('ov.bizplace_id = :bizplaceId AND ov.domain_id = :domainId AND ov.release_good_id = :releaseGoodId', {
+        bizplaceId,
+        domainId: domain.id,
+        releaseGoodId: releaseGood.id
+      })
+      .andWhere('ov.batch_id IS NULL')
+      .andWhere('ov.qty IS NULL')
+      .andWhere('ov.output_qty IS NULL')
+      .andWhere('ov.product_id IS NULL')
+      .andWhere('ov.product_detail_id IS NULL')
+
+    let items = await qb.getRawMany()
+
+    items = items.map(item => {
+      return {
+        ...item,
+        orderVas: { id: item.ov_id },
+        vassId: item.v_id,
+        vasName: item.v_name,
+        vasQty: item?.ovi_vas_qty,
+        vasRemark: item?.ovi_vas_remark
+      }
+    })
+    return { items }
+  }
+
   @Query(returns => OrderVas)
   async orderVas(@Arg('name') name: string, @Ctx() context: any): Promise<OrderVas> {
     const { domain }: { domain: Domain } = context.state

package/server/service/order-vas/order-vas-types.ts

@@ -1,10 +1,4 @@
-import {
-  Field,
-  Float,
-  InputType,
-  Int,
-  ObjectType
-} from 'type-graphql'
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
 
 import { ObjectRef } from '@things-factory/shell'
 
@@ -17,7 +11,7 @@ export class OrderVasList {
   items: OrderVas[]
 
   @Field(type => Int, { nullable: true })
-  total: number
+  total?: number
 }
 
 @InputType()
@@ -175,6 +169,9 @@ export class OrderVasPatch {
   @Field({ nullable: true })
   newProductDetail: string
 
+  @Field({ nullable: true })
+  newBatchId: string
+
   @Field({ nullable: true })
   newPackingType: string
 

package/server/service/order-vas/order-vas.ts

@@ -1,8 +1,4 @@
-import {
-  Field,
-  ID,
-  ObjectType
-} from 'type-graphql'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -17,10 +13,7 @@ import {
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import {
-  Product,
-  ProductDetail
-} from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
@@ -60,7 +53,7 @@ export class OrderVas {
   bizplaceId: string
 
   @Column()
-  @Field()
+  @Field({ nullable: true })
   name: string
 
   @Column({ nullable: true })
@@ -259,6 +252,10 @@ export class OrderVas {
   @Field({ nullable: true })
   remark: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  newBatchId: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   newPackingType: string
@@ -304,4 +301,16 @@ export class OrderVas {
 
   @RelationId((orderVas: OrderVas) => orderVas.updater)
   updaterId: string
+
+  @Field({ nullable: true })
+  vassId: string
+
+  @Field({ nullable: true })
+  vasName?: string
+
+  @Field({ nullable: true })
+  vasQty?: number
+
+  @Field({ nullable: true })
+  vasRemark?: string
 }

package/server/service/order-vas-item/order-vas-item-type.ts

@@ -20,6 +20,9 @@ export class NewOrderVasItem {
 
   @Field({ nullable: true })
   params?: string
+
+  @Field({ nullable: true })
+  vasRemark?: string
 }
 
 @InputType()
@@ -57,6 +60,9 @@ export class OrderVasItemPatch {
   @Field({ nullable: true })
   active?: boolean
 
+  @Field({ nullable: true })
+  vasRemark?: string
+
   @Field()
   cuFlag: string
 }

package/server/service/order-vas-item/order-vas-item.ts

@@ -96,6 +96,10 @@ export class OrderVasItem {
   @Field({ nullable: true })
   executedAt?: Date
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  vasRemark?: string
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/release-good/release-good-mutation.ts

@@ -122,6 +122,7 @@ export class ReleaseGoodMutation {
 
           // update orderInventories if availableItems are valid
           releaseGoods[i].orderInventories = availableItems
+          
 
           const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
             releaseGoods[i],
@@ -129,6 +130,7 @@ export class ReleaseGoodMutation {
             roNoSetting,
             domain,
             user,
+            null,
             childTx
           )
 
@@ -1490,6 +1492,7 @@ export async function bulkGenerateReleaseGood(
   roNoSetting: any,
   domain: Domain,
   user: User,
+  draftOrder?: any,
   tx?: EntityManager
 ): Promise<ReleaseGood> {
   try {
@@ -1536,6 +1539,7 @@ export async function bulkGenerateReleaseGood(
       refNo: releaseGood.refNo,
       refNo2: releaseGood.refNo2,
       refNo3: releaseGood.refNo3,
+      draftReleaseGood: draftOrder || null,
       releaseDate: releaseGood.releaseDate,
       ownTransport: releaseGood?.ownTransport || false,
       orderMethod: ORDER_METHOD.SELECT_BY_PRODUCT,
@@ -1657,8 +1661,12 @@ export async function bulkGenerateReleaseGood(
         newOrderProduct = await tx.getRepository(OrderProduct).save({
           ...oi.orderProduct,
           totalUomValue: `${oi.orderProduct.releaseUomValue} ${oi.orderProduct.uom}`,
-          status: ORDER_PRODUCT_STATUS.ASSIGNED,
-          updater: newReleaseGood?.updater || user
+          status:
+            oi.orderProduct.status === 'partial-release'
+              ? ORDER_PRODUCT_STATUS.PARTIAL_RELEASED
+              : ORDER_PRODUCT_STATUS.ASSIGNED,
+          updater: newReleaseGood?.updater || user,
+          releaseGood: newReleaseGood
         })
       }
 

package/server/service/release-good/release-good-query.ts

@@ -179,6 +179,7 @@ export class ReleaseGoodQuery {
         relations: [
           'domain',
           'bizplace',
+          'draftReleaseGood',
           'shippingOrder',
           'arrivalNotice',
           'orderProducts',
@@ -494,6 +495,7 @@ export class ReleaseGoodQuery {
       qb.leftJoinAndSelect('rg.creator', 'creator')
       qb.leftJoinAndSelect('rg.updater', 'updater')
       qb.leftJoinAndSelect('rg.acceptedBy', 'acceptedBy')
+      qb.leftJoinAndSelect('rg.draftReleaseGood', 'draftReleaseGood')
       qb.leftJoinAndSelect('rg.deliverTo', 'deliverTo')
       qb.leftJoin(
         subQuery => {
@@ -567,12 +569,15 @@ export class ReleaseGoodQuery {
           })
           .join(',')
 
-        qb.andWhere(`(
+        qb.andWhere(
+          `(
           lower(rg.name) like any(array[${orderInfos}])
           or lower(rg.ref_no) like any(array[${orderInfos}])
           or lower(rg.ref_no_2) like any(array[${orderInfos}])
           or lower(rg.ref_no_3) like any(array[${orderInfos}])
-        )`)
+          or lower(draftReleaseGood.name) like any(array[${orderInfos}])
+          )`
+        )
       }
 
       const arrChildSortData = ['bizplace', 'creator']

package/server/service/release-good/release-good.ts

@@ -23,6 +23,7 @@ import { Domain } from '@things-factory/shell'
 import {
   ArrivalNotice,
   DeliveryOrder,
+  DraftReleaseGood,
   InventoryInfos,
   Manifest,
   OrderInventory,
@@ -81,6 +82,13 @@ export class ReleaseGood {
   @RelationId((releaseGood: ReleaseGood) => releaseGood.bizplace)
   bizplaceId: string
 
+  @ManyToOne(() => DraftReleaseGood, draftReleaseGood => draftReleaseGood.releaseGood)
+  @Field(type => DraftReleaseGood, { nullable: true })
+  draftReleaseGood: DraftReleaseGood
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.draftReleaseGood)
+  draftReleaseGoodId: string
+
   @ManyToOne(type => Manifest)
   @Field(type => Manifest, { nullable: true })
   manifest: Manifest

package/server/service/vas/vas-mutation.ts

@@ -166,6 +166,7 @@ export async function editVas(
             name: `${newRecord.orderVasItemsPatch[ii].vas.name} (${newRecord.orderVasItemsPatch[ii].vas.description})- ${result.id}`,
             vas: newRecord.orderVasItemsPatch[ii].vas,
             vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
+            vasRemark: newRecord.orderVasItemsPatch[ii]?.vasRemark,
             domain: domain,
             creator: user,
             createdAt: new Date()
@@ -198,6 +199,7 @@ export async function editVas(
               name: `${newRecord.orderVasItemsPatch[ii].vas.name}- ${result.id}`,
               vas: newRecord.orderVasItemsPatch[ii].vas,
               vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
+              vasRemark: newRecord.orderVasItemsPatch[ii]?.vasRemark,
               domain: domain,
               creator: user,
               createdAt: new Date()
@@ -232,6 +234,7 @@ export async function editVas(
           name: `${newRecord.vas.name}- ${newRecord.orderVas.id}`,
           vas: newRecord.vas,
           vasQty: newRecord.vasQty,
+          vasRemark: newRecord?.vasRemark,
           domain: domain,
           creator: user,
           createdAt: new Date()
@@ -248,7 +251,7 @@ export async function editVas(
           {
             id: newRecord.id
           },
-          { vasQty: newRecord.vasQty, updater: user.id, updatedAt: new Date() }
+          { vasQty: newRecord.vasQty,vasRemark: newRecord?.vasRemark, updater: user.id, updatedAt: new Date() }
         )
 
         results.push({ ...result, cuFlag: 'M' })

package/server/utils/inventory-util.ts

@@ -1,10 +1,29 @@
-import { EntityManager, Equal, getRepository, In, Not, Raw, Repository, SelectQueryBuilder } from 'typeorm'
+import {
+  EntityManager,
+  Equal,
+  getRepository,
+  In,
+  Not,
+  Raw,
+  Repository,
+  SelectQueryBuilder
+} from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain, ListParam } from '@things-factory/shell'
+import {
+  Product,
+  ProductBundle,
+  ProductDetail
+} from '@things-factory/product-base'
+import {
+  PartnerSetting,
+  Setting
+} from '@things-factory/setting-base'
+import {
+  Domain,
+  ListParam
+} from '@things-factory/shell'
 import {
   generateInventoryHistory,
   Inventory,
@@ -238,6 +257,8 @@ export const InventoryUtil = {
         items = await trxMgr.query(`select * from temp_inventory_product_group`)
       }
 
+      await trxMgr.query(`drop table temp_inventory_product_group`)
+
       return { items, total }
     } catch (error) {
       throw error
@@ -745,7 +766,7 @@ export const InventoryUtil = {
       }
     })
 
-    return _composeTargetInventories(productDetail, orderInventory, inventories)
+    return _composeTargetInventories(product, productDetail, orderInventory, inventories)
   },
 
   /**
@@ -1059,6 +1080,7 @@ export async function switchLocationStatus(
 }
 
 export function _composeTargetInventories(
+  product: Product,
   productDetail: ProductDetail,
   record: any,
   inventories: Inventory[]
@@ -1068,7 +1090,8 @@ export function _composeTargetInventories(
   let compReleaseQty: number = 0
   let compReleaseUomValue: number = 0
   let totalInventoryQty: number = inventories.reduce((total, inventory) => total + inventory.remainQty, 0)
-  let product = productDetail.product
+
+  if (!product) product = productDetail.product
 
   if (totalInventoryQty < record.releaseQty) {
     throw new Error(`invalid release qty for ${product?.sku}`)