@things-factory/sales-base 4.3.186 → 4.3.187

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

@@ -13,7 +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, Location } from '@things-factory/warehouse-base'
 
@@ -25,6 +25,7 @@ import { OrderToteItem } from '../order-tote-item/order-tote-item'
 import { ReleaseGood } from '../release-good/release-good'
 import { ReturnOrder } from '../return-order/return-order'
 import { TransferOrder } from '../transfer-order/transfer-order'
+import { Replenishment } from '../replenishment/replenishment'
 
 @Entity()
 @Index('ix_order-inventory_0', (orderInventory: OrderInventory) => [orderInventory.domain, orderInventory.name], {
@@ -150,6 +151,13 @@ export class OrderInventory {
   @RelationId((orderInventory: OrderInventory) => orderInventory.releaseGood)
   releaseGoodId: string
 
+  @ManyToOne(type => Replenishment)
+  @Field(type => Replenishment, { nullable: true })
+  replenishment: Replenishment
+
+  @RelationId((orderInventory: OrderInventory) => orderInventory.replenishment)
+  replenishmentId: string
+
   @ManyToOne(type => InventoryCheck)
   @Field(type => InventoryCheck, { nullable: true })
   inventoryCheck: InventoryCheck
@@ -432,4 +440,7 @@ export class OrderInventory {
 
   @Field({ nullable: true })
   stopId: string
+
+  @Field({ nullable: true })
+  transferQty: number
 }

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

@@ -26,6 +26,7 @@ import { OrderPackageItem } from '../order-package-item/order-package-item'
 import { PurchaseOrder } from '../purchase-order/purchase-order'
 import { ReleaseGood } from '../release-good/release-good'
 import { RetailReplenishmentOrder } from '../retail-replenishment-order/retail-replenishment-order'
+import { Replenishment } from '../replenishment/replenishment'
 
 @Entity()
 @Index('ix_order-product_0', (orderProduct: OrderProduct) => [orderProduct.domain, orderProduct.name], {
@@ -107,6 +108,13 @@ export class OrderProduct {
   @RelationId((orderProduct: OrderProduct) => orderProduct.releaseGood)
   releaseGoodId: string
 
+  @ManyToOne(type => Replenishment)
+  @Field(type => Replenishment, { nullable: true })
+  replenishment: Replenishment
+
+  @RelationId((orderInventory: OrderInventory) => orderInventory.replenishment)
+  replenishmentId: string
+
   @ManyToOne(type => DraftReleaseGood)
   @Field(type => DraftReleaseGood, { nullable: true })
   draftReleaseGood: DraftReleaseGood

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

@@ -859,6 +859,9 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         AND i.domain_id = $1
         AND i.bizplace_id = $2
         WHERE l.type NOT IN ($3, $4)
+        AND i.obsolete = false
+        AND i.transfer_qty <= 0
+        AND i.transfer_uom_value <= 0
         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

package/server/service/replenishment/index.ts

@@ -0,0 +1,6 @@
+import { Replenishment } from './replenishment'
+import { ReplenishmentQuery } from './replenishment-query'
+import { ReplenishmentMutation } from './replenishment-mutation'
+
+export const entities = [Replenishment]
+export const resolvers = [ReplenishmentQuery, ReplenishmentMutation]

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

@@ -0,0 +1,309 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In, EntityManager, Repository } from 'typeorm'
+import { Replenishment } from './replenishment'
+import { NewReplenishment, ReplenishmentPatch, ReplenishmentInventoryPatch } from './replenishment-type'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderProduct } from '../order-product/order-product'
+import { Inventory } from '@things-factory/warehouse-base'
+import { Setting } from '@things-factory/setting-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  ORDER_TYPES
+} from '../../constants'
+import { generateId } from '@things-factory/id-rule-base'
+import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { Product, ProductDetail } from '@things-factory/product-base'
+
+@Resolver(Replenishment)
+export class ReplenishmentMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment, { description: 'To create new Replenishment' })
+  async createReplenishment(
+    @Arg('replenishInventories', type => [ReplenishmentInventoryPatch])
+    replenishmentInventories: ReplenishmentInventoryPatch,
+    @Ctx() context: any
+  ): Promise<Replenishment> {
+    const { tx } = context.state
+
+    const createdReplenishment: Replenishment = await generateReplenishmentFunction(
+      null,
+      replenishmentInventories,
+      context,
+      tx
+    )
+
+    return createdReplenishment
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment, { description: 'To modify Replenishment information' })
+  async updateReplenishment(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ReplenishmentPatch,
+    @Ctx() context: any
+  ): Promise<Replenishment> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Replenishment)
+    const replenishment = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...replenishment,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Replenishment], { description: "To modify multiple Replenishments' information" })
+  async updateMultipleReplenishment(
+    @Arg('patches', type => [ReplenishmentPatch]) patches: ReplenishmentPatch[],
+    @Ctx() context: any
+  ): Promise<Replenishment[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const replenishmentRepo = tx.getRepository(Replenishment)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await replenishmentRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const replenishment = await replenishmentRepo.findOne(newRecord.id)
+
+        const result = await replenishmentRepo.save({
+          ...replenishment,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Replenishment' })
+  async deleteReplenishment(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Replenishment).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple replenishments' })
+  async deleteReplenishments(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Replenishment).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Replenishment)
+  async confirmReplenishment(@Arg('name') name: string, @Ctx() context: any): Promise<Replenishment> {
+    const { tx }: { tx: EntityManager } = context.state
+    const replenishment: Replenishment = await confirmReplenishment(name, context, tx)
+
+    return replenishment
+  }
+}
+
+export async function generateReplenishmentFunction(
+  _: any,
+  replenishment: any,
+  context: any,
+  tx?: EntityManager
+): Promise<Replenishment> {
+  try {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    let orderInventories: OrderInventory[] = replenishment
+
+    let finalOrderInventories: OrderInventory[] = []
+
+    let newReplenishment: Replenishment = new Replenishment()
+
+    // find RO number rule setting
+    const rpNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RP_NUMBER_RULE
+      }
+    })
+
+    newReplenishment = {
+      ...newReplenishment,
+      name: rpNoSetting
+        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RP_NUMBER, seed: {} })
+        : OrderNoGenerator.replenishment(),
+      domain,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    }
+
+    newReplenishment = await tx.getRepository(Replenishment).save(newReplenishment)
+
+    for (let oi of orderInventories) {
+      let productDetail: any = await tx
+        .getRepository(ProductDetail)
+        .findOne(oi.productDetailId, { relations: ['product'] })
+
+      let bizplace = oi.bizplaceId
+
+      let newOrderInv: OrderInventory = Object.assign({}, oi)
+      newOrderInv = {
+        ...newOrderInv,
+        domain,
+        bizplace: { id: bizplace },
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        replenishment: newReplenishment,
+        product: productDetail.product,
+        productDetail,
+        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.ASSIGNED,
+        batchId: ''
+      }
+
+      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+
+      // Preassign Inventories
+      const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: { domain, name: 'rule-for-inventory-assignment' }
+      })
+
+      let locationSortingRules = []
+      if (inventoryAssignmentSetting) {
+        let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+        for (const key in locationSetting) {
+          locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+        }
+      }
+
+      let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+        oi,
+        productDetail.product,
+        productDetail,
+        locationSortingRules,
+        { id: bizplace },
+        domain,
+        tx,
+        oi.batchId,
+        'STORAGE'
+      )
+
+      assignedOrderInventories = assignedOrderInventories.map(aoi => {
+        return {
+          ...aoi,
+          orderProduct: newOrderProduct,
+          bizplace: { id: bizplace }
+        }
+      })
+
+      finalOrderInventories.push(...assignedOrderInventories)
+    }
+
+    for (let oi of finalOrderInventories) {
+      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
+      generatedOI = {
+        ...generatedOI,
+        domain,
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        replenishment: newReplenishment,
+        creator: user,
+        updater: user
+      }
+
+      await tx.getRepository(OrderInventory).save({ ...generatedOI })
+
+      await tx.getRepository(Inventory).update(oi.inventory.id, {
+        transferQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
+        transferUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
+        updater: user
+      })
+    }
+
+    return newReplenishment
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function confirmReplenishment(name: string, context: any, tx?: EntityManager): Promise<Replenishment> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  let foundReplenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+    where: { name, status: ORDER_STATUS.PENDING }
+  })
+
+  if (!foundReplenishment) throw new Error(`Replenisment doesn't exists.`)
+
+  let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, replenishment: foundReplenishment }
+  })
+
+  // 1. RO Status change (PENDING => PENDING_RECEIVE)
+  const replenishment: Replenishment = await tx.getRepository(Replenishment).save({
+    ...foundReplenishment,
+    status: ORDER_STATUS.PENDING_WORKSHEET,
+    updater: user
+  })
+
+  // 1. Update status of order inventories
+  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
+    return {
+      ...orderInventory,
+      status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET,
+      updater: user
+    }
+  })
+  await tx.getRepository(OrderInventory).save(foundOIs)
+
+  return replenishment
+}

package/server/service/replenishment/replenishment-query.ts

@@ -0,0 +1,76 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, EntityManager, SelectQueryBuilder } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Replenishment } from './replenishment'
+import { ReplenishmentList } from './replenishment-type'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ORDER_INVENTORY_STATUS } from 'server/constants'
+
+@Resolver(Replenishment)
+export class ReplenishmentQuery {
+  @Query(returns => Replenishment, { description: 'To fetch a Replenishment' })
+  async replenishment(@Arg('id') id: string, @Ctx() context: any): Promise<Replenishment> {
+    const { domain } = context.state
+
+    return await getRepository(Replenishment).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => ReplenishmentList, { description: 'To fetch multiple Replenishments' })
+  async replenishments(@Args() params: ListParam, @Ctx() context: any): Promise<ReplenishmentList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Replenishment).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @Query(returns => Replenishment)
+  async replenishmentDetail(
+    @Ctx() context: any,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<Replenishment> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+      let param: any
+
+      if (name) param = { domain, name }
+
+      let replenishment: Replenishment = await getRepository(Replenishment).findOne({
+        where: { ...param },
+        relations: ['domain', 'orderInventories', 'orderInventories.product', 'orderInventories.bizplace']
+      })
+
+      replenishment.orderInventories = replenishment.orderInventories.map((oi: OrderInventory) => {
+        return {
+          ...oi,
+          transferQty: oi.releaseQty,
+          productSKU: oi.product.sku
+        }
+      })
+
+      return replenishment
+    } catch (error) {
+      throw new Error(error)
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() replenishment: Replenishment): Promise<Domain> {
+    return await getRepository(Domain).findOne(replenishment.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() replenishment: Replenishment): Promise<User> {
+    return await getRepository(User).findOne(replenishment.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() replenishment: Replenishment): Promise<User> {
+    return await getRepository(User).findOne(replenishment.creatorId)
+  }
+}

package/server/service/replenishment/replenishment-type.ts

@@ -0,0 +1,78 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Replenishment, ReplenishmentStatus } from './replenishment'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { ProductPatch, ProductDetailPatch } from '@things-factory/product-base'
+
+@InputType()
+export class NewReplenishment {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ReplenishmentStatus, { nullable: true })
+  state?: ReplenishmentStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class ReplenishmentPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ReplenishmentStatus, { nullable: true })
+  state?: ReplenishmentStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@InputType()
+export class ReplenishmentInventoryPatch {
+  @Field({ nullable: true })
+  bizplaceId?: string
+
+  @Field({ nullable: true })
+  releaseQty?: number
+
+  @Field({ nullable: true })
+  releaseUomValue?: number
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field({ nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  productDetailId?: string
+}
+
+@ObjectType()
+export class ReplenishmentList {
+  @Field(type => [Replenishment])
+  items: Replenishment[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/replenishment/replenishment.ts

@@ -0,0 +1,87 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  OneToMany
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, OrderProduct } from '../'
+
+export enum ReplenishmentStatus {
+  STATUS_A = 'STATUS_A',
+  STATUS_B = 'STATUS_B'
+}
+
+registerEnumType(ReplenishmentStatus, {
+  name: 'ReplenishmentStatus',
+  description: 'state enumeration of a replenishment'
+})
+
+@Entity()
+@Index('ix_replenishment_0', (replenishment: Replenishment) => [replenishment.domain, replenishment.name], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for Replenishment' })
+export class Replenishment {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column()
+  @Field({ nullable: true })
+  name: string
+
+  @Column()
+  @Field({ nullable: true })
+  status: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((replenishment: Replenishment) => replenishment.domain)
+  domainId: string
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.replenishment)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => OrderProduct, orderProduct => orderProduct.replenishment)
+  @Field(type => [OrderProduct], { nullable: true })
+  orderProducts: OrderProduct[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((replenishment: Replenishment) => replenishment.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((replenishment: Replenishment) => replenishment.creator)
+  updaterId?: string
+}