@things-factory/sales-base 3.7.15 → 3.8.0

package/server/graphql/resolvers/release-good/bulk-add-release-goods.ts

@@ -0,0 +1,343 @@
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { sendNotification } from '@things-factory/notification'
+import { Product } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS } from '../../../constants'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_PRODUCT_STATUS
+} from '../../../constants/order'
+import { OrderInventory, OrderProduct, ReleaseGood } from '../../../entities'
+import { ValidationError } from '../../../errors'
+import { OrderNoGenerator } from '../../../utils/order-no-generator'
+import { bulkReleaseGoodsAvailableItemsFunction } from './bulk-release-goods-available-items'
+
+export const bulkAddReleaseGoods = {
+  async bulkAddReleaseGoods(_: any, { rawReleaseGoods, bizplaceId }, context: any) {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    if (!bizplaceId) throw new Error('company ID is not provided')
+
+    let createdReleaseGoods: ReleaseGood[] = []
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    const roNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
+      }
+    })
+
+    let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
+
+    for (let i = 0, l = releaseGoods.length; i < l; i++) {
+      // generate release good by group to avoid duplication
+      // if this function is called simultaneously by different users
+      let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+        _,
+        [...releaseGoods[i].orderInventories],
+        bizplaceId,
+        context,
+        tx
+      )
+
+      if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
+        throw new ValidationError({
+          ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+          detail: { data: JSON.stringify(availableItems) }
+        })
+
+      // update orderInventories if availableItems are valid
+      releaseGoods[i].orderInventories = availableItems
+
+      const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGoods(
+        _,
+        releaseGoods[i],
+        bizplaceId,
+        roNoSetting,
+        domain,
+        user,
+        tx
+      )
+
+      createdReleaseGoods.push(createdReleaseGood)
+    }
+
+    let confirmedReleaseGoods: ReleaseGood[] = await bulkConfirmReleaseGoods(
+      createdReleaseGoods.map(rg => rg.name),
+      domain,
+      user,
+      context,
+      tx
+    )
+
+    return confirmedReleaseGoods
+  }
+}
+
+async function bulkGenerateReleaseGoods(
+  _: any,
+  releaseGood: any,
+  bizplaceId: string,
+  roNoSetting: any,
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<ReleaseGood> {
+  try {
+    let warehouseDomain: Domain = domain
+    let { orderInventories } = releaseGood
+
+    let bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+
+    let newReleaseGood: ReleaseGood = {
+      ...releaseGood,
+      name: roNoSetting
+        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
+        : OrderNoGenerator.releaseGood(),
+      domain: warehouseDomain,
+      bizplace: bizplace,
+      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
+      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
+      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
+      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
+      deliveryAddress5: releaseGood?.deliveryAddress5 || null,
+      attentionTo: releaseGood?.attentionTo || null,
+      attentionCompany: releaseGood?.attentionCompany || null,
+      city: releaseGood?.city || null,
+      state: releaseGood?.state || null,
+      postalCode: releaseGood?.postalCode || null,
+      country: releaseGood?.country || null,
+      phone1: releaseGood?.phone1 || null,
+      phone2: releaseGood?.phone2 || null,
+      email: releaseGood?.email || null,
+      airwayBill: releaseGood?.airwayBill,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      refNo3: releaseGood.refNo3,
+      releaseDate: releaseGood.releaseDate,
+      ownTransport: releaseGood?.ownTransport || false,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    }
+
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
+    for (let oi of orderInventories) {
+      delete oi.sku
+
+      let newOrderInv: OrderInventory = Object.assign(new OrderInventory(), oi)
+      newOrderInv = {
+        ...newOrderInv,
+        domain: warehouseDomain,
+        bizplace: bizplace,
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        batchId: oi?.batchId || '',
+        releaseGood: newReleaseGood,
+        product: await tx.getRepository(Product).findOne(oi.productId),
+        creator: user,
+        updater: user
+      }
+
+      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
+      newOrderProduct = {
+        ...newOrderProduct,
+        packQty: 0,
+        actualPackQty: 0,
+        palletQty: 0,
+        actualPalletQty: 0,
+        status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN
+      }
+
+      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+
+      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
+    }
+
+    // Change the status to PENDING_RECEIVE
+
+    return newReleaseGood
+  } catch (error) {
+    throw error
+  }
+}
+
+async function bulkConfirmReleaseGoods(
+  releaseGoodsNo: string[],
+  domain: Domain,
+  user: User,
+  context: any,
+  tx?: EntityManager
+): Promise<ReleaseGood[]> {
+  let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
+    where: { name: In(releaseGoodsNo), status: ORDER_STATUS.PENDING },
+    relations: [
+      'domain',
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain',
+      'orderProducts',
+      'orderProducts.product',
+      'orderInventories',
+      'orderInventories.product',
+      'orderVass'
+    ]
+  })
+
+  if (!foundReleaseGoods.length) throw new Error(`Release good order doesn't exists.`)
+  let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
+
+  let foundOrderInventories: OrderInventory[] = foundReleaseGoods
+    .map((releaseGood: ReleaseGood) => releaseGood.orderInventories)
+    .reduce((orderInventories, currOIs) => {
+      orderInventories.push(...currOIs)
+      return orderInventories
+    }, [])
+
+  await tx
+    .getRepository(ReleaseGood)
+    .update({ id: In(foundReleaseGoods.map(rg => rg.id)) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+
+  await tx
+    .getRepository(OrderInventory)
+    .update(
+      { id: In(foundOrderInventories.map(oi => oi.id)) },
+      { status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE, updater: user }
+    )
+
+  if (context?.state?.type != 'api') {
+    const users: any[] = await tx
+      .getRepository('users_roles')
+      .createQueryBuilder('ur')
+      .select('ur.users_id', 'id')
+      .where(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select('role.id')
+          .from(Role, 'role')
+          .where("role.name = 'Office Admin'")
+          .andWhere('role.domain_id = :domain', { domain: domain.id })
+          .getQuery()
+        return 'ur.roles_id IN ' + subQuery
+      })
+      .getRawMany()
+
+    // send notification to Office Admin Users
+    if (users?.length) {
+      const receivers: any[] = users.map(user => user.id)
+      const msg = {
+        title: `New Release Order from ${customerBizplace.name}`,
+        body: `New incoming bulk release orders are pending for receiving`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      }
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+  }
+
+  return foundReleaseGoods.map((releaseGood: ReleaseGood) => {
+    return {
+      ...releaseGood,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    }
+  })
+}
+
+function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
+  return rawReleaseGoods.reduce((releaseGoods, item) => {
+    const idx: number = releaseGoods.findIndex(rg => {
+      // consider these attributes if they are exist in "item"
+      const comparison = [
+        'refNo2',
+        'refNo3',
+        'attentionTo',
+        'phone1',
+        'deliveryAddress1',
+        'deliveryAddress2',
+        'deliveryAddress3',
+        'deliveryAddress4',
+        'postalCode'
+      ]
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (item[cc]) {
+          a[cc] = item[cc]
+          b[cc] = rg[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return rg.refNo == item.refNo && rg.releaseDate == item.releaseDate && a === b
+    })
+
+    if (idx >= 0) {
+      const duplicateSkuIdx: number = releaseGoods[idx].orderInventories.findIndex(
+        oi => oi.sku === item.sku && oi.packingType === item.packingType && oi.packingSize === item.packingSize
+      )
+
+      if (duplicateSkuIdx >= 0) {
+        releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty += item.releaseQty
+      } else {
+        releaseGoods[idx].orderInventories.push({
+          sku: item.sku,
+          productId: item.productId,
+          packingType: item.packingType,
+          packingSize: item.packingSize,
+          uom: item.uom,
+          releaseQty: item.releaseQty,
+          releaseUomValue: item.releaseUomValue
+        })
+      }
+    } else {
+      releaseGoods.push({
+        releaseDate: item.releaseDate,
+        refNo: item.refNo,
+        refNo2: item.refNo2,
+        refNo3: item.refNo3,
+        attentionTo: item.attentionTo,
+        phone1: item.phone1,
+        deliveryAddress1: item.deliveryAddress1,
+        deliveryAddress2: item.deliveryAddress2,
+        deliveryAddress3: item.deliveryAddress3,
+        deliveryAddress4: item.deliveryAddress4,
+        city: item.city,
+        postalCode: item.postalCode,
+        state: item.state,
+        country: item.country,
+        orderInventories: [
+          {
+            sku: item.sku,
+            productId: item.productId,
+            packingType: item.packingType,
+            packingSize: item.packingSize,
+            uom: item.uom,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue
+          }
+        ]
+      })
+    }
+
+    return releaseGoods
+  }, [])
+}

package/server/graphql/resolvers/release-good/bulk-release-goods-available-items.ts

@@ -0,0 +1,207 @@
+import { EntityManager } from 'typeorm'
+
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+export const bulkReleaseGoodsAvailableItems = {
+  async bulkReleaseGoodsAvailableItems(_: any, { rawReleaseGoods, bizplaceId }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+    const availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+      _,
+      rawReleaseGoods,
+      bizplaceId,
+      context,
+      tx
+    )
+
+    return availableItems
+  }
+}
+
+export async function bulkReleaseGoodsAvailableItemsFunction(
+  _: any,
+  rawReleaseGoods: any[],
+  bizplaceId: string,
+  context: any,
+  tx?: EntityManager
+): Promise<any[]> {
+  const { domain }: { domain: Domain } = context.state
+  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  if (!rawReleaseGoods) return
+
+  const json_oi = JSON.stringify(
+    rawReleaseGoods.map(raw => {
+      return {
+        sku: raw.sku,
+        packing_type: raw.packingType,
+        packing_size: raw.packingSize,
+        uom: raw.uom,
+        release_qty: raw.releaseQty
+      }
+    })
+  )
+
+  await tx.query(
+    `
+        CREATE TEMP TABLE temp_order_products(
+          product_id VARCHAR(50),
+          sku VARCHAR(150),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+          );
+      `
+  )
+
+  await tx.query(
+    `
+        INSERT INTO temp_order_products
+        SELECT p.id AS product_id, js.sku,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
+        js.release_qty
+        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
+        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
+      `,
+    [companyBizplaceId.id]
+  )
+
+  let availableItems = await tx.query(
+    `
+        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) 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.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) 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.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        INNER JOIN (
+          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
+          FROM temp_order_products top
+          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      `,
+    [domain.id, bizplaceId]
+  )
+
+  await tx.query('DROP TABLE temp_order_products')
+
+  availableItems = availableItems.map(item => {
+    return {
+      productId: item.product_id,
+      sku: item.sku,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      remainQty: item.remain_qty,
+      remainUomValue: item.remain_uom_value
+    }
+  })
+
+  return _extractData(rawReleaseGoods, availableItems)
+}
+
+function _extractData(rawData, validatedData) {
+  return rawData.map(raw => {
+    const idx = validatedData.findIndex(val => {
+      const comparison = ['packingType', 'packingSize', 'uom']
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc]) {
+          a[cc] = raw[cc]
+          b[cc] = val[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return val.sku == raw.sku && a === b
+    })
+
+    let releaseUomValue = 0
+
+    // if sku is matched, assign qty and product id
+    if (idx >= 0) {
+      // assign qty to rawData as much as possible
+      releaseUomValue =
+        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
+
+      raw.assignedQty =
+        validatedData[idx].remainQty >= raw.releaseQty
+          ? raw.releaseQty > 0
+            ? raw.releaseQty
+            : 0
+          : validatedData[idx].remainQty
+
+      raw.assignedUomValue =
+        validatedData[idx].remainUomValue >= releaseUomValue
+          ? releaseUomValue > 0
+            ? releaseUomValue
+            : 0
+          : validatedData[idx].remainUomValue
+
+      // deduct qty & uomValue from validateData
+      validatedData[idx].remainQty -= raw.assignedQty
+      validatedData[idx].remainUomValue -= raw.assignedUomValue
+
+      raw.productId = validatedData[idx].productId
+      raw.packingType = validatedData[idx].packingType
+      raw.packingSize = validatedData[idx].packingSize
+      raw.uom = validatedData[idx].uom
+      raw.batchId = validatedData[idx].batchId
+    } else {
+      raw.assignedQty = 0
+      raw.assignedUomValue = 0
+      raw.productId = null
+    }
+
+    return {
+      ...raw,
+      releaseUomValue
+    }
+  })
+}

package/server/graphql/resolvers/release-good/generate-release-good.ts

@@ -216,8 +216,6 @@ export async function generateReleaseGoodFunction(
       newReleaseGood.arrivalNotice = crossDockingGAN
     }
 
-    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-
     // Make relation with RO for cross docking
     if (newReleaseGood.crossDocking) {
       crossDockingGAN.releaseGood = newReleaseGood
@@ -267,6 +265,9 @@ export async function generateReleaseGoodFunction(
 
     orderInventories = [...singleProductOIs, ...splitBundleOIs]
 
+    newReleaseGood.noOfItems = orderInventories.length
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
     for (let oi of orderInventories) {
       let newOrderInv: OrderInventory = Object.assign({}, oi)
       newOrderInv = {

package/server/graphql/resolvers/release-good/index.ts

@@ -1,5 +1,7 @@
-import { confirmReleaseGoodResolver } from './confirm-release-good'
 import { addReleaseGood } from './add-release-good'
+import { bulkAddReleaseGoods } from './bulk-add-release-goods'
+import { bulkReleaseGoodsAvailableItems } from './bulk-release-goods-available-items'
+import { confirmReleaseGoodResolver } from './confirm-release-good'
 import { deleteReleaseGoodResolver } from './delete-release-good'
 import { deleteReleaseGoods } from './delete-release-goods'
 import { generateReleaseGood } from './generate-release-good'
@@ -13,6 +15,7 @@ import { releaseGoodsResolver } from './release-goods'
 import { updateReleaseGoodDetailsResolver } from './update-release-good-details'
 
 export const Query = {
+  ...bulkReleaseGoodsAvailableItems,
   ...releaseGoodsResolver,
   ...releaseGoodResolver,
   ...releaseGoodRequestsResolver,
@@ -21,6 +24,7 @@ export const Query = {
 }
 
 export const Mutation = {
+  ...bulkAddReleaseGoods,
   ...deleteReleaseGoodResolver,
   ...deleteReleaseGoods,
   ...confirmReleaseGoodResolver,

package/server/graphql/resolvers/release-good/release-good-requests.ts

@@ -14,6 +14,8 @@ export const releaseGoodRequestsResolver = {
 
       const statusFilter = params.filters.some(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      const noOfItemsFilter = params.filters.find(param => param.name === 'noOfItems')
+      const skuFilter = params.filters.find(param => param.name === 'sku')
 
       if (!statusFilter) {
         params.filters.push({
@@ -33,6 +35,10 @@ export const releaseGoodRequestsResolver = {
         })
       }
 
+      if (skuFilter) {
+        params.filters = params.filters.filter(param => param.name !== 'sku')
+      }
+
       const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
       if (fromDateParamIdx >= 0) {
         let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
@@ -59,6 +65,10 @@ export const releaseGoodRequestsResolver = {
         })
       }
 
+      if (noOfItemsFilter && noOfItemsFilter.value == 1) {
+        params.filters.find(param => param.name === 'noOfItems').operator = 'eq'
+      }
+
       const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
@@ -83,6 +93,19 @@ export const releaseGoodRequestsResolver = {
         'cc.status = rg.status'
       )
 
+      if (skuFilter) {
+        qb.andWhere(
+          `
+        exists (select * from  order_inventories oi  
+        inner join products p on oi.product_id = p.id
+        inner join inventories i on i.product_id = p.id
+        where oi.release_good_id = rg.id
+        and lower(p.sku) like :sku)
+        `,
+          { sku: skuFilter.value.toLowerCase() }
+        )
+      }
+
       const arrChildSortData = ['bizplace', 'creator']
       const sort = (params.sortings || []).reduce(
         (acc, sort) => ({

package/server/graphql/resolvers/release-good/update-release-good-details.ts

@@ -28,12 +28,12 @@ export async function updateReleaseGoodFunction(
 ) {
   const { domain, user }: { domain: Domain; user: User } = context.state
   let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { id: releaseGood.id, name: releaseGood.name, domain },
+    where: { id: releaseGood.id, domain },
     relations: ['shippingOrder']
   })
 
   if (!foundReleaseGood) {
-    throw new Error(`Release Order ${releaseGood.name} is not found.`)
+    throw new Error(`Release order ${releaseGood.name} is not found.`)
   }
 
   // case to update existing shippingOrder
@@ -55,7 +55,10 @@ export async function updateReleaseGoodFunction(
     releaseGood.shippingOrder = newShippingOrder
   }
 
-  await tx.getRepository(ReleaseGood).update(foundReleaseGood.id, releaseGood)
-  // return updated Release Good
-  return await tx.getRepository(ReleaseGood).findOne(foundReleaseGood.id)
+  foundReleaseGood = await tx.getRepository(ReleaseGood).save({
+    ...foundReleaseGood,
+    ...releaseGood
+  })
+
+  return foundReleaseGood
 }