@things-factory/sales-base 4.0.36 → 4.0.40

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

@@ -1,4 +1,8 @@
-import { Attachment, createAttachments, deleteAttachment } from '@things-factory/attachment-base'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, Repository } from 'typeorm'
+
+import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getPermittedBizplaces } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
@@ -6,9 +10,7 @@ import { Product } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import {
   ArrivalNotice,
   NewPurchaseOrder,
@@ -40,14 +42,14 @@ export class PurchaseOrderMutation {
   async upsertPurchaseOrder(
     @Ctx() context: any,
     @Arg('purchaseOrder', type => PurchaseOrderPatch) purchaseOrder: PurchaseOrderPatch,
-    @Arg('file', type => [GraphQLUpload], { nullable: true }) file?: FileUpload
+    @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload
   ): Promise<PurchaseOrder> {
     try {
       const { tx }: { tx: EntityManager } = context.state
       const createdPurchaseOrder: PurchaseOrder = await upsertPurchaseOrderFunction(
         null,
         purchaseOrder,
-        file,
+        files,
         context,
         tx
       )
@@ -197,17 +199,14 @@ export class PurchaseOrderMutation {
 export async function upsertPurchaseOrderFunction(
   _: any,
   purchaseOrder: any,
-  file: Attachment,
+  files: FileUpload[],
   context: any,
   tx?: EntityManager
 ): Promise<PurchaseOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
-
   if (!purchaseOrder.id) {
-    purchaseOrder = await createPurchaseOrderFunction(_, purchaseOrder, file, context, tx)
+    purchaseOrder = await createPurchaseOrderFunction(_, purchaseOrder, files, context, tx)
   } else {
-    purchaseOrder = await updatePurchaseOrderFunction(_, purchaseOrder, file, context, tx)
+    purchaseOrder = await updatePurchaseOrderFunction(_, purchaseOrder, files, context, tx)
   }
 
   return purchaseOrder
@@ -216,7 +215,7 @@ export async function upsertPurchaseOrderFunction(
 export async function createPurchaseOrderFunction(
   _: any,
   purchaseOrder: any,
-  file: Attachment,
+  files: FileUpload[],
   context: any,
   tx?: EntityManager
 ): Promise<PurchaseOrder> {
@@ -297,8 +296,8 @@ export async function createPurchaseOrderFunction(
   }
 
   // // 4. Create Attacments
-  if (file?.length) {
-    const attachments: Attachment[] = file.map(attachment => {
+  if (files?.length) {
+    const attachments: Attachment[] = files.map(attachment => {
       return {
         file: attachment,
         refBy: createdPurchaseOrder.id,
@@ -314,7 +313,7 @@ export async function createPurchaseOrderFunction(
 export async function updatePurchaseOrderFunction(
   _: any,
   purchaseOrder: any,
-  file: Attachment,
+  files: FileUpload[],
   context: any,
   tx?: EntityManager
 ): Promise<PurchaseOrder> {
@@ -386,14 +385,13 @@ export async function updatePurchaseOrderFunction(
   })
 
   // // 6. Remove All Attachment
-  for await (const file of foundAttachments.filter(attachment => !file.find(file => file.id == attachment.id))) {
-    await deleteAttachment(_, { id: file.id }, context)
+  if (foundAttachments?.length) {
+    await deleteAttachmentsByRef(_, { refBys: foundAttachments.map(file => file.refBy) }, context)
   }
 
   // // 7. Add New Attachment
-  const newAttachments = file.filter(attachment => !attachment.id)
-  if (newAttachments.length > 0) {
-    const attachments: Attachment[] = newAttachments.map(attachment => {
+  if (files?.length > 0) {
+    const attachments: Attachment[] = files.map(attachment => {
       return {
         file: attachment,
         refBy: updatePurchaseOrder.id,

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

@@ -21,17 +21,6 @@ import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
-import {
-  ArrivalNotice,
-  NewReleaseGood,
-  OrderInventory,
-  OrderProduct,
-  OrderVas,
-  ReleaseGoodPatch,
-  ShippingOrder,
-  ShippingOrderPatch,
-  Vas
-} from '../'
 import {
   ATTACHMENT_TYPE,
   ORDER_INVENTORY_STATUS,
@@ -46,7 +35,15 @@ import {
 import { EcommerceController, SellercraftController } from '../../controllers'
 import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderProduct } from '../order-product/order-product'
+import { OrderVas } from '../order-vas/order-vas'
+import { NewReleaseGood, ReleaseGoodPatch } from '../release-good/release-good-types'
+import { ShippingOrder } from '../shipping-order/shipping-order'
+import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
+import { Vas } from '../vas/vas'
 import { ReleaseGood } from './release-good'
 import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
 
@@ -76,7 +73,7 @@ export class ReleaseGoodMutation {
 
     let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
 
-    let errorsFound: any[] = []
+    let errorsCaught: any[] = []
     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
@@ -90,7 +87,7 @@ export class ReleaseGoodMutation {
               domain
             }
           })
-          if (existingReleaseGood) throw new Error('release good order is already exist in the system')
+          if (existingReleaseGood) throw new Error('this order is already exist in the system')
 
           let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
             [...releaseGoods[i].orderInventories],
@@ -119,25 +116,30 @@ export class ReleaseGoodMutation {
 
           createdReleaseGoods.push(createdReleaseGood)
         })
-      } catch (e) {
-        errorsFound.push(e)
+      } catch (error) {
+        let rawReleaseGoods = formRawReleaseGoods(releaseGoods[i], error.message)
+        errorsCaught.push(...rawReleaseGoods)
       }
     }
 
     let confirmedReleaseGoods: ReleaseGood[] = []
-    try {
-      confirmedReleaseGoods = await bulkConfirmReleaseGoods(
-        createdReleaseGoods.map(rg => rg.name),
-        domain,
-        user,
-        context,
-        tx
-      )
-    } catch (e) {
-      errorsFound.push(e)
-    }
 
-    // if (errorsFound.length) { then ?? }
+    if (createdReleaseGoods.length)
+      try {
+        confirmedReleaseGoods = await bulkConfirmReleaseGoods(
+          createdReleaseGoods.map(rg => rg.name),
+          domain,
+          user,
+          context,
+          tx
+        )
+      } catch (error) {}
+
+    if (errorsCaught.length)
+      throw new ValidationError({
+        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
+        detail: { data: JSON.stringify(errorsCaught) }
+      })
 
     return confirmedReleaseGoods
   }
@@ -815,11 +817,9 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
         if (foundMarketplaceProductVariations) {
           await Promise.all(
             foundMarketplaceProductVariations.map(async variation => {
-              if (variation.marketplaceProduct.marketplaceStore.id != matchedMarketplaceStore.id) {
-                variation.reserveQty -= oi.releaseQty
+              variation.reserveQty -= oi.releaseQty
 
-                await tx.getRepository(MarketplaceProductVariation).save(variation)
-              }
+              await tx.getRepository(MarketplaceProductVariation).save(variation)
             })
           )
         }
@@ -1252,29 +1252,15 @@ export async function bulkConfirmReleaseGoods(
 ): 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'
-    ]
+    relations: ['bizplace']
   })
 
   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
-    }, [])
+  let foundOrderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, releaseGood: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) }
+  })
 
   await tx
     .getRepository(ReleaseGood)
@@ -1307,7 +1293,7 @@ export async function bulkConfirmReleaseGoods(
     // send notification to Office Admin Users
     if (users?.length) {
       const receivers: any[] = users.map(user => user.id)
-      const msg = {
+      const message = {
         title: `New Release Order from ${customerBizplace.name}`,
         body: `New incoming bulk release orders are pending for receiving`,
         url: context.header.referer,
@@ -1315,18 +1301,21 @@ export async function bulkConfirmReleaseGoods(
       }
       await sendNotification({
         receivers,
-        message: { ...msg }
+        message
       })
     }
   }
 
-  return foundReleaseGoods.map((releaseGood: ReleaseGood) => {
-    return {
-      ...releaseGood,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    }
-  })
+  return Promise.all(
+    foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
+      return {
+        ...releaseGood,
+        orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
+        status: ORDER_STATUS.PENDING_RECEIVE,
+        updater: user
+      }
+    })
+  )
 }
 
 function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
@@ -1413,3 +1402,20 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
     return releaseGoods
   }, [])
 }
+
+function formRawReleaseGoods(releaseGood, errorMsg) {
+  let rawReleaseGoods = []
+  for (let i = 0, l = releaseGood.orderInventories.length; i < l; i++) {
+    let rawReleaseGood = {
+      ...releaseGood,
+      ...releaseGood.orderInventories[i],
+      errorMsg
+    }
+
+    delete rawReleaseGood.orderInventories
+    delete rawReleaseGood.product
+
+    rawReleaseGoods.push(rawReleaseGood)
+  }
+  return rawReleaseGoods
+}

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

@@ -9,16 +9,11 @@ import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
-import {
-  InventoryInfos,
-  NewReleaseGood,
-  OrderInventory,
-  ReleasableInventoryList,
-  ReleaseGoodList,
-  ShippingOrder
-} from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { ShippingOrder } from '../shipping-order/shipping-order'
 import { ReleaseGood } from './release-good'
+import { InventoryInfos, NewReleaseGood, ReleasableInventoryList, ReleaseGoodList } from './release-good-types'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodQuery {
@@ -648,7 +643,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
   let availableItems = await tx.query(
     `
         WITH inv AS (
-        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom,
+        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, 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 
@@ -686,7 +681,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         AND i.domain_id = $1
         AND i.bizplace_id = $2
         WHERE l.type NOT IN ($3, $4)
-        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
+        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.packing_type, i.packing_size, i.uom
         ORDER BY foo.sku, remain_qty
       ) SELECT * FROM inv WHERE remain_qty > 0
       `,
@@ -701,7 +696,6 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
       productDetailId: item.product_detail_id,
       productInfo: item.product_info,
       sku: item.sku,
-      batchId: item.batch_id,
       packingType: item.packing_type,
       packingSize: Number(item.packing_size || 0),
       uom: item.uom,
@@ -762,10 +756,10 @@ function _extractData(rawData, validatedData) {
 
       raw.productId = validatedData[idx].productId
       raw.productDetailId = validatedData[idx].productDetailId
+      raw.productInfo = validatedData[idx].productInfo
       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

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

@@ -45,6 +45,8 @@ export enum DispatchmentStatus {
 }
 @Entity()
 @Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
+@Index('ix_release-good_1', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo])
+@Index('ix_release-good_2', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo2])
 @ObjectType()
 export class ReleaseGood {
   @PrimaryGeneratedColumn('uuid')

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

@@ -1,3 +1,7 @@
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
@@ -5,9 +9,7 @@ import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+
 import { NewOrderInventory, NewReturnOrder, OrderInventory, OrderVas, ReturnOrderPatch } from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../constants'
 import { OrderNoGenerator } from '../../utils'
@@ -48,9 +50,31 @@ export class ReturnOrderMutation {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
 
     const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(returnOrder.customerBizplaceId)
+
     let orderInventories: NewOrderInventory[] = returnOrder.orderInventories
     let foundInv = Inventory
 
+    const mergedOrderInventories = orderInventories.reduce((acc, curr) => {
+      let existingItem = acc.find(
+        itm =>
+          itm.product.id === curr.product.id &&
+          itm.packingType === curr.packingType &&
+          itm.batchId === curr.batchId &&
+          itm.packingSize === curr.packingSize
+      )
+
+      if (!existingItem) {
+        acc.push(curr)
+      } else {
+        existingItem.returnQty = existingItem.returnQty + curr.returnQty
+        existingItem.returnUomValue = existingItem.returnUomValue + curr.returnUomValue
+      }
+
+      return acc
+    }, [])
+
+    returnOrder.orderInventories = mergedOrderInventories
+
     let newReturnOrder: NewReturnOrder = {
       ...returnOrder,
       name: OrderNoGenerator.returnOrder(),
@@ -67,14 +91,14 @@ export class ReturnOrderMutation {
 
     let createdReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save(newReturnOrder)
 
-    for (let oi of orderInventories) {
-      let newOrderInv: OrderInventory = Object.assign({}, oi) as any
+    for (let moi of mergedOrderInventories) {
+      let newOrderInv: OrderInventory = Object.assign({}, moi) as any
       newOrderInv.domain = domain
       newOrderInv.bizplace = bizplace
       newOrderInv.status = ORDER_INVENTORY_STATUS.PENDING
       newOrderInv.name = OrderNoGenerator.orderInventory()
       newOrderInv.returnOrder = createdReturnOrder
-      newOrderInv.product = await tx.getRepository(Product).findOne(oi.product.id)
+      newOrderInv.product = await tx.getRepository(Product).findOne(moi.product.id)
       newOrderInv.creator = user
       newOrderInv.updater = user
 

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-type.ts

@@ -48,10 +48,10 @@ export class ReverseKittingOrderInventoryPatch {
   @Field(type => ID, { nullable: true })
   id?: string
 
-  @Field()
+  @Field({ nullable: true })
   name: string
 
-  @Field(type => Int)
+  @Field(type => Int, { nullable: true })
   set: number
 
   @Field({ nullable: true })
@@ -69,17 +69,20 @@ export class ReverseKittingOrderInventoryPatch {
   @Field(type => Float, { nullable: true })
   uomValue?: number
 
-  @Field(type => ObjectRef)
+  @Field(type => ObjectRef, { nullable: true })
   reverseKittingOrder: ObjectRef
 
-  @Field(type => ObjectRef)
+  @Field(type => ObjectRef, { nullable: true })
   inventory: ObjectRef
 
   @Field({ nullable: true })
   status: string
 
-  @Field()
+  @Field({ nullable: true })
   cuFlag: string
+
+  @Field({ nullable: true })
+  issue: string
 }
 
 @ObjectType()

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory.ts

@@ -12,12 +12,12 @@ import {
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { Product } from '@things-factory/product-base'
-import { Vas } from '../vas/vas'
 
 import { ReverseKittingOrder } from '../reverse-kitting-order/reverse-kitting-order'
+import { Vas } from '../vas/vas'
 
 @Entity()
 @Index(
@@ -115,6 +115,7 @@ export class ReverseKittingOrderInventory {
   @Field({ nullable: true })
   description?: string
 
+  @Column({ nullable: true })
   @Field({ nullable: true })
   issue?: string
 

package/server/utils/order-no-generator.ts

@@ -58,6 +58,10 @@ export class OrderNoGenerator {
     return `OP-${uuid()}`
   }
 
+  static invoiceProduct() {
+    return `IP-${uuid()}`
+  }
+
   static orderVas() {
     return `OV-${uuid()}`
   }
@@ -121,4 +125,11 @@ export class OrderNoGenerator {
       currentDate.getMonth() + 1
     }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
   }
+
+  static invoice() {
+    const currentDate = new Date()
+    return `INV-${currentDate.getFullYear()}${
+      currentDate.getMonth() + 1
+    }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
+  }
 }