@things-factory/sales-base 4.3.323 → 4.3.327

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

@@ -8,8 +8,8 @@ import {
   OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
-  UpdateDateColumn
-} from 'typeorm'
+  UpdateDateColumn 
+} from 'typeorm'  
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -69,6 +69,7 @@ import { Replenishment } from '../replenishment/replenishment'
 @Index('ix_order-inventory_6', (orderInventory: OrderInventory) => [orderInventory.id], {
   unique: true
 })
+@Index('ix_order-inventory_7', (orderInventory: OrderInventory) => [orderInventory.arrivalNotice])
 @ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')
@@ -136,6 +137,26 @@ export class OrderInventory {
   @Field({ nullable: true })
   packingType: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  unloadedAt: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  putawayAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  unloadedBy: User
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  putawayBy: User
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  actualPackUomValue: number
+
   @Column('float', { default: 1 })
   @Field({ nullable: true })
   packingSize?: number

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

@@ -62,8 +62,9 @@ import { Replenishment } from '../replenishment/replenishment'
   { unique: true }
 )
 @Index('ix_order-product_4', (orderProduct: OrderProduct) => [orderProduct.draftReleaseGood], { unique: false })
+@Index('ix_order-product_5', (orderProduct: OrderProduct) => [orderProduct.arrivalNotice])
 @ObjectType()
-export class OrderProduct {
+export class OrderProduct { 
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
   id: string

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

@@ -1,34 +1,9 @@
-import {
-  FileUpload,
-  GraphQLUpload
-} from 'graphql-upload'
-import {
-  Arg,
-  Ctx,
-  Directive,
-  Mutation,
-  Resolver
-} from 'type-graphql'
-import {
-  EntityManager,
-  getConnection,
-  getRepository,
-  In,
-  Not,
-  Repository
-} from 'typeorm'
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getConnection, getRepository, In, Not, Repository } from 'typeorm'
 
-import {
-  Attachment,
-  createAttachments
-} from '@things-factory/attachment-base'
-import {
-  Application,
-  ApplicationType,
-  Partner,
-  Role,
-  User
-} from '@things-factory/auth-base'
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { Application, ApplicationType, Partner, Role, User } from '@things-factory/auth-base'
 import {
   Bizplace,
   getCompanyBizplace,
@@ -40,26 +15,14 @@ import {
 import { GeoCountry } from '@things-factory/geography'
 import { generateId } from '@things-factory/id-rule-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import {
-  Sellercraft,
-  SellercraftStatus
-} from '@things-factory/integration-sellercraft'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder } from '@things-factory/marketplace-base'
 // import { sendNotification } from '@things-factory/notification'
-import {
-  Product,
-  ProductBundleSetting,
-  ProductDetail
-} from '@things-factory/product-base'
-import {
-  PartnerSetting,
-  Setting
-} from '@things-factory/setting-base'
+import { Product, ProductBundleSetting, ProductDetail } from '@things-factory/product-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import {
-  Inventory,
-  ProductDetailStock
-} from '@things-factory/warehouse-base'
+import { Inventory, ProductDetailStock } from '@things-factory/warehouse-base'
+import { editVas } from '../vas'
 
 // import { NewOrderProduct } from '../order-product/order-product-types'
 import {
@@ -74,36 +37,23 @@ import {
   ORDER_VAS_STATUS,
   PRODUCT_GROUP_TYPE
 } from '../../constants'
-import {
-  EcommerceController,
-  PowrupController,
-  SellercraftController
-} from '../../controllers'
+import { EcommerceController, PowrupController, SellercraftController } from '../../controllers'
 import { ValidationError } from '../../errors'
-import {
-  InventoryUtil,
-  OrderNoGenerator
-} from '../../utils'
+import { InventoryUtil, OrderNoGenerator } from '../../utils'
 import { ArrivalNotice } from '../arrival-notice/arrival-notice'
-import {
-  confirmArrivalNoticeFunction,
-  deleteArrivalNotice
-} from '../arrival-notice/arrival-notice-mutation'
+import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
 import { OrderInventory } from '../order-inventory/order-inventory'
 import { OrderPackage } from '../order-package/order-package'
 import { OrderProduct } from '../order-product/order-product'
 import { OrderVasItem } from '../order-vas-item/order-vas-item'
 import { OrderVas } from '../order-vas/order-vas'
-import {
-  NewReleaseGood,
-  ReleaseGoodPatch,
-  ShippingOrderInfoPatch
-} from '../release-good/release-good-types'
+import { NewReleaseGood, ReleaseGoodPatch, ShippingOrderInfoPatch } 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'
+import { OrderVasPatch } from '../order-vas/order-vas-types'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodMutation {
@@ -254,6 +204,7 @@ export class ReleaseGoodMutation {
     @Ctx() context: any,
     @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments?: FileUpload[],
     @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood?: NewReleaseGood,
+    @Arg('orderVasPatch', type => [OrderVasPatch], { nullable: true }) orderVasPatch?: OrderVasPatch[],
     @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch,
     @Arg('shippingOrderInfo', type => ShippingOrderInfoPatch, { nullable: true })
     shippingOrderInfo?: ShippingOrderInfoPatch
@@ -266,7 +217,8 @@ export class ReleaseGoodMutation {
       shippingOrderInfo,
       attachments,
       context,
-      tx
+      tx,
+      orderVasPatch
     )
 
     return createdReleaseGood
@@ -396,7 +348,8 @@ export class ReleaseGoodMutation {
       shippingOrder,
       file,
       context,
-      tx
+      tx,
+      null
     )
 
     const confirmedRO: ReleaseGood = await confirmReleaseGood(createdRO.name, context, tx)
@@ -547,7 +500,8 @@ export async function generateReleaseGoodFunction(
   shippingOrderInfo: any,
   attachments: FileUpload[],
   context: any,
-  tx?: EntityManager
+  tx?: EntityManager,
+  orderVasPatch?: OrderVasPatch[]
 ): Promise<ReleaseGood> {
   try {
     const { domain, user }: { domain: Domain; user: User } = context.state
@@ -938,36 +892,40 @@ export async function generateReleaseGoodFunction(
     }
 
     // VAS
-    if (orderVass?.length) {
-      orderVass = await Promise.all(
-        orderVass.map(async orderVas => {
-          if (orderVas?.targetProduct?.id) {
-            orderVas.targetProduct = await tx.getRepository(Product).findOne(orderVas.targetProduct.id)
-          }
-
-          let newOrderVas: OrderVas = {
-            ...orderVas,
-            domain: warehouseDomain,
-            bizplace,
-            name: OrderNoGenerator.releaseVas(),
-            vas: await tx.getRepository(Vas).findOne(orderVas.vas.id),
-            type: ORDER_TYPES.RELEASE_OF_GOODS,
-            releaseGood: newReleaseGood,
-            status: ORDER_VAS_STATUS.PENDING,
-            creator: user,
-            updater: user
-          }
-
-          if (orderVas?.inventory?.id) {
-            newOrderVas.inventory = await tx.getRepository(Inventory).findOne(orderVas.inventory.id)
-          }
-
-          return newOrderVas
-        })
-      )
-
-      await tx.getRepository(OrderVas).save(orderVass)
-    }
+    orderVasPatch = orderVasPatch.map(itm => {
+      return { ...itm, releaseGood: newReleaseGood }
+    })
+    await editVas(orderVasPatch, null, context)
+    // if (orderVass?.length) {
+    //   orderVass = await Promise.all(
+    //     orderVass.map(async orderVas => {
+    //       if (orderVas?.targetProduct?.id) {
+    //         orderVas.targetProduct = await tx.getRepository(Product).findOne(orderVas.targetProduct.id)
+    //       }
+
+    //       let newOrderVas: OrderVas = {
+    //         ...orderVas,
+    //         domain: warehouseDomain,
+    //         bizplace,
+    //         name: OrderNoGenerator.releaseVas(),
+    //         vas: await tx.getRepository(Vas).findOne(orderVas.vas.id),
+    //         type: ORDER_TYPES.RELEASE_OF_GOODS,
+    //         releaseGood: newReleaseGood,
+    //         status: ORDER_VAS_STATUS.PENDING,
+    //         creator: user,
+    //         updater: user
+    //       }
+
+    //       if (orderVas?.inventory?.id) {
+    //         newOrderVas.inventory = await tx.getRepository(Inventory).findOne(orderVas.inventory.id)
+    //       }
+
+    //       return newOrderVas
+    //     })
+    //   )
+
+    //   await tx.getRepository(OrderVas).save(orderVass)
+    // }
 
     if (attachments?.length > 0) {
       const files: Attachment[] = attachments.map(attachment => {
@@ -1157,7 +1115,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
     if (application) {
       const powrupController: PowrupController = new PowrupController()
-      await powrupController.updateStock(foundOPs, customerDomain, user, tx)
+      powrupController.updateStock(foundOPs, customerDomain, user, tx)
     }
   }
 
@@ -1403,7 +1361,7 @@ export async function rejectReleaseGood(
 
       if (application) {
         const powrupController: PowrupController = new PowrupController()
-        await powrupController.updateStock(foundOPs, customerDomain, user, tx)
+        powrupController.updateStock(foundOPs, customerDomain, user, tx)
       }
     }
 

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

@@ -2,8 +2,9 @@ import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager } from 'typeorm'
-import { NewVas, VasPatch } from '../'
+import { NewVas, VasPatch, OrderVasPatch, OrderVasItemPatch, ReleaseGood, OrderVas, OrderVasItem } from '../'
 import { Vas } from './vas'
+import { v4 as uuidv4 } from 'uuid'
 
 @Resolver(Vas)
 export class VasMutation {
@@ -105,4 +106,155 @@ export class VasMutation {
     await tx.getRepository(Vas).delete(ids)
     return true
   }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async editVas(
+    @Arg('orderVasItemPatch', type => [OrderVasItemPatch], { nullable: true }) orderVasItemPatch: OrderVasItemPatch[],
+    @Arg('orderVasPatch', type => [OrderVasPatch]) orderVasPatch: OrderVasPatch[],
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const response = await editVas(orderVasPatch, orderVasItemPatch, context)
+
+    return response
+  }
+}
+
+export async function editVas(
+  orderVasPatch: OrderVasPatch[],
+  orderVasItemPatch?: OrderVasItemPatch[],
+  context?: any
+): Promise<Boolean> {
+  const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  let results = []
+  const orderVasRepo = tx.getRepository(OrderVas)
+  const orderVasItemRepo = tx.getRepository(OrderVasItem)
+  // Order Vas
+  if (orderVasPatch.length > 0) {
+    const _deleteRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '-')
+    const _createRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = orderVasPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_deleteRecords.length > 0) {
+      for (let i = 0; i < _deleteRecords.length; i++) {
+        const deleteRecord = _deleteRecords[i]
+        await orderVasItemRepo.delete({ orderVas: { id: deleteRecord.id } })
+        await orderVasRepo.delete(deleteRecord.id)
+      }
+    }
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await orderVasRepo.save({
+          ...newRecord,
+          id: uuidv4(),
+          name: `${_createRecords[i].product.name} - ${new Date()}`,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+
+        // create new ovi
+        for (let ii = 0; ii < newRecord.orderVasItemsPatch.length; ii++) {
+          await orderVasItemRepo.save({
+            orderVas: result.id,
+            name: `${newRecord.orderVasItemsPatch[ii].vas.name} (${newRecord.orderVasItemsPatch[ii].vas.description})- ${result.id}`,
+            vas: newRecord.orderVasItemsPatch[ii].vas,
+            vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
+            domain: domain,
+            creator: user,
+            createdAt: new Date()
+          })
+        }
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const orderVas: OrderVas = await orderVasRepo.findOne({
+          where: { domain, id: newRecord.id },
+          relations: ['product', 'productDetail', 'newProduct', 'newProductDetail', 'releaseGood', 'orderVasItems']
+        })
+
+        const result = await orderVasRepo.save({
+          ...orderVas,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+
+        for (let ii = 0; ii < newRecord.orderVasItemsPatch.length; ii++) {
+          await orderVasItemRepo.update(
+            { id: newRecord.orderVasItemsPatch[ii].id },
+            {
+              orderVas: { id: result.id },
+              name: `${newRecord.orderVasItemsPatch[ii].vas.name}- ${result.id}`,
+              vas: newRecord.orderVasItemsPatch[ii].vas,
+              vasQty: newRecord.orderVasItemsPatch[ii].vasQty,
+              domain: domain,
+              creator: user,
+              createdAt: new Date()
+            }
+          )
+        }
+      }
+    }
+  }
+
+  // order Vas Item
+  if (orderVasItemPatch?.length > 0) {
+    const _deleteRecords = orderVasItemPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '-')
+    const _createRecords = orderVasItemPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = orderVasItemPatch.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_deleteRecords.length > 0) {
+      for (let i = 0; i < _deleteRecords.length; i++) {
+        const deleteRecord = _deleteRecords[i]
+        if (deleteRecord.id) {
+          await orderVasItemRepo.delete(deleteRecord.id)
+        }
+      }
+    }
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+        const result = await orderVasItemRepo.save({
+          id: uuidv4(),
+          orderVas: newRecord.orderVas.id,
+          name: `${newRecord.vas.name}- ${newRecord.orderVas.id}`,
+          vas: newRecord.vas,
+          vasQty: newRecord.vasQty,
+          domain: domain,
+          creator: user,
+          createdAt: new Date()
+        })
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+
+        const result = await tx.getRepository(OrderVasItem).update(
+          {
+            id: newRecord.id
+          },
+          { vasQty: newRecord.vasQty, updater: user.id, updatedAt: new Date() }
+        )
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+  }
+
+  return results ? true : false
 }