@things-factory/sales-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,309 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Product } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { NewOrderInventory, NewTransferOrder, OrderInventory, RetailReplenishmentOrder, TransferOrderPatch } from '../'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_STATUS,
+  ORDER_TYPES
+} from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { TransferOrder } from './transfer-order'
+
+@Resolver(TransferOrder)
+export class TransferOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async addTransferOrderInventories(
+    @Arg('toNo') toNo: string,
+    @Arg('orderInventories', type => [NewOrderInventory]) orderInventories: NewOrderInventory[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain, user } = context.state
+
+    const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
+      where: { name: toNo },
+      relations: ['bizplace', 'orderInventory']
+    })
+
+    await addTransferOrderInventories(domain, transferOrder, orderInventories, user, tx)
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => TransferOrder)
+  async cancelTransferOrder(
+    @Arg('patch', type => TransferOrderPatch) patch: TransferOrderPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<TransferOrder> {
+    const { tx, domain, user } = context.state
+
+    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
+
+    const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
+      where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, name: patch.name },
+      relations: ['bizplace', 'orderInventories']
+    })
+
+    if (!transferOrder) throw new Error(`Transfer order does not exist.`)
+    if (!patch.status) throw new Error('Status was not specified.')
+    // if (patch.status && (patch.status !== ORDER_STATUS.PENDING_CANCEL || patch.status !== ORDER_STATUS.CANCELLED))
+    // throw new Error(`Status provided was invalid.`)
+
+    let foundOIs: OrderInventory[] = transferOrder.orderInventories
+
+    // 1. Update status of order inventories based on status (to PENDING_CANCEL or CANCELLED)
+    if (foundOIs && foundOIs.length) {
+      foundOIs = foundOIs.map((oi: OrderInventory) => {
+        ;(oi.status = patch.status), (oi.updater = user)
+        return oi
+      })
+    }
+    await tx.getRepository(OrderInventory).save(foundOIs)
+
+    // 2. Update transfer order status
+    return await tx.getRepository(TransferOrder).save({
+      ...transferOrder,
+      remark: patch.remark, //think another way if warehouse confirm cancellation > no need to overwrite remark
+      status: patch.status,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => TransferOrder)
+  async createTransferOrder(
+    @Arg('transferOrder', type => NewTransferOrder) transferOrder: NewTransferOrder,
+    @Ctx() context: ResolverContext
+  ): Promise<TransferOrder> {
+    const { tx, domain, user } = context.state
+
+    let orderInventories: NewOrderInventory[] = transferOrder.orderInventories
+    const myBizplace: Bizplace = await getOutletBizplace(transferOrder.warehouseId)
+
+    // #1 Find the related retail replenishment order
+    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
+      .getRepository(RetailReplenishmentOrder)
+      .findOne({
+        where: { domain: { id: domain.id }, bizplace: { id: myBizplace.id }, refNo: transferOrder.refNo },
+        relations: ['domain', 'bizplace']
+      })
+
+    // #2 Create Transfer Order
+    const createdTransferOrder: TransferOrder = await tx.getRepository(TransferOrder).save({
+      ...(transferOrder as any),
+      name: OrderNoGenerator.transferOrder(),
+      bizplace: myBizplace,
+      retailReplenishmentOrder: retailReplenishmentOrder ? retailReplenishmentOrder.id : null,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    // #3 Create Transfer Order inventories
+    await addTransferOrderInventories(
+      domain,
+      createdTransferOrder,
+      orderInventories.map((oi: NewOrderInventory) => {
+        return { ...oi, status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE }
+      }),
+      user,
+      tx
+    )
+
+    return createdTransferOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async generateTransferOrder(
+    @Arg('transferOrder', type => NewTransferOrder) transferOrder: NewTransferOrder,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain, user } = context.state
+
+    await generateTransferOrder(transferOrder, domain, user, tx)
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => TransferOrder)
+  async completeTransferOrder(
+    @Arg('patch', type => TransferOrderPatch) patch: TransferOrderPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<TransferOrder> {
+    const { tx, domain, user } = context.state
+
+    const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
+    let targetOIs: NewOrderInventory[] = patch.orderInventories
+    let partialReceived = false
+
+    // #1 Find Transfer Order
+    const foundTO: TransferOrder = await tx.getRepository(TransferOrder).findOne({
+      where: { domain: { id: domain.id }, name: patch.name, bizplace: { id: myBizplace.id } },
+      relations: ['bizplace', 'orderInventories']
+    })
+
+    if (!foundTO) throw new Error(`Transfer order does not exist.`)
+    if (foundTO && foundTO.status && foundTO.status === ORDER_STATUS.RECEIVED)
+      throw new Error(`Transfer order is already completed.`)
+
+    // #2 Find related order inventories
+    let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+      where: { domain: { id: domain.id }, transferOrder: { id: foundTO.id } }
+    })
+
+    if (!foundOIs) throw new Error(`Order inventories were not found.`)
+
+    foundOIs = foundOIs.map((oi: OrderInventory) => {
+      targetOIs.forEach((toi: NewOrderInventory) => {
+        // #2.1 Update the status of order inventories accordingly
+        if (oi.name === toi.name && oi.batchId === toi.batchId) {
+          //need to add appropriate condition in future
+          oi.status = toi.status
+          if (toi.remark) oi.remark = toi.remark
+        }
+        // #2.2 Check the status of order inventories if there is unreceived item
+        if (toi.status.includes(ORDER_INVENTORY_STATUS.NOT_RECEIVED)) partialReceived = true
+      })
+      oi.updater = user
+      return oi
+    })
+    await tx.getRepository(OrderInventory).save(foundOIs)
+
+    // #3 Update status of stock replenishment order (RECEIVED / PARTIALLY_RECEIVED)
+    return await getRepository(TransferOrder).save({
+      ...foundTO,
+      status: partialReceived ? ORDER_STATUS.PARTIAL_RECEIVED : ORDER_STATUS.RECEIVED,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteTransferOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    await tx.getRepository(TransferOrder).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteTransferOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
+    await tx.getRepository(TransferOrder).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}
+
+export async function addTransferOrderInventories(
+  domain: Domain,
+  transferOrder: TransferOrder,
+  orderInventories: (OrderInventory | NewOrderInventory)[],
+  user: User,
+  tx?: EntityManager
+): Promise<void> {
+  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
+  const orderInventoryRepo: Repository<OrderInventory> =
+    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
+
+  if (!transferOrder?.bizplace || !transferOrder?.orderInventories?.length) {
+    transferOrder = await tx.getRepository(TransferOrder).findOne({
+      where: { id: transferOrder.id } /* CONFIRMME regarding TYPEORM */,
+      relations: ['bizplace', 'orderInventories']
+    })
+  }
+
+  orderInventories = await Promise.all(
+    orderInventories.map(async (oi: OrderInventory) => {
+      const foundProduct: Product = await productRepo.findOneBy({
+        domain: { id: domain.id },
+        sku: oi.product.sku,
+        name: oi.product.name
+      })
+      return {
+        ...oi,
+        domain,
+        bizplace: transferOrder.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        product: foundProduct,
+        productName: foundProduct.name,
+        releaseWeight: foundProduct.weight * oi.releaseQty,
+        packingType: foundProduct.packingType,
+        type: ORDER_TYPES.TRANSFER_ORDER,
+        transferOrder,
+        creator: user,
+        updater: user
+      }
+    })
+  )
+
+  //add lock qty
+
+  await orderInventoryRepo.save(orderInventories as any)
+}
+
+export async function generateTransferOrder(
+  transferOrder: NewTransferOrder,
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<TransferOrder> {
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+  let orderInventories: NewOrderInventory[] = transferOrder.orderInventories
+  let orderNo: string = ''
+
+  // find TO number rule setting
+  const toNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain: { id: domain.id },
+      name: ORDER_NUMBER_SETTING_KEY.TO_NUMBER_RULE
+    }
+  })
+
+  if (toNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.TO_NUMBER, seed: {} })
+  } else {
+    orderNo = OrderNoGenerator.transferOrder()
+  }
+
+  // #1 Create Transfer Order
+  const createdTransferOrder: TransferOrder = (await tx.getRepository(TransferOrder).save({
+    ...transferOrder,
+    name: orderNo,
+    status: ORDER_STATUS.PENDING_RECEIVE,
+    domain: domain,
+    creator: user,
+    updater: user
+  } as any)) as any
+
+  // #2 Create Transfer Order inventories
+  await addTransferOrderInventories(
+    domain,
+    createdTransferOrder,
+    orderInventories.map((oi: NewOrderInventory) => {
+      return { ...oi, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
+    }),
+    user,
+    tx
+  )
+
+  return createdTransferOrder
+}

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

@@ -0,0 +1,66 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
+import { TransferOrderList } from '../'
+import { TransferOrder } from './transfer-order'
+
+@Resolver(TransferOrder)
+export class TransferOrderQuery {
+  @Query(returns => TransferOrderList)
+  async transferOrders(
+    @Ctx() context: ResolverContext,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<TransferOrderList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    const [items, total] = await getRepository(TransferOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'creator',
+        'updater'
+      ]
+    })
+    return { items, total }
+  }
+
+  @Query(returns => TransferOrder)
+  async transferOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<TransferOrder> {
+    const { domain } = context.state
+
+    const repository = getRepository(TransferOrder)
+
+    return await repository.findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: [
+        'domain',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() transferOrder: TransferOrder): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: transferOrder.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() transferOrder: TransferOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: transferOrder.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() transferOrder: TransferOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: transferOrder.updaterId })
+  }
+}

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

@@ -0,0 +1,97 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { NewOrderInventory } from '../order-inventory/order-inventory-types'
+import { TransferOrder } from './transfer-order'
+
+@ObjectType()
+export class TransferOrderList {
+  @Field(type => [TransferOrder], { nullable: true })
+  items: TransferOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewTransferOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVas: [ObjectRef]
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: [NewOrderInventory]
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field({ nullable: true })
+  issuedDate: string
+
+  @Field({ nullable: true })
+  warehouseId: string // outletID
+}
+
+@InputType()
+export class TransferOrderPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  warehouseId: string // outletID
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVas: [ObjectRef]
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: [NewOrderInventory]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  deliveryOrder: [ObjectRef]
+
+  @Field({ nullable: true })
+  issuedDate: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

@@ -0,0 +1,117 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { DeliveryOrder, OrderInventory, OrderVas, RetailReplenishmentOrder } from '../'
+
+@Entity()
+@Index('ix_transfer_order_0', (transferOrder: TransferOrder) => [transferOrder.domain, transferOrder.name], {
+  unique: true
+})
+@ObjectType()
+export class TransferOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column()
+  @Field()
+  ownTransport: Boolean
+
+  @Column()
+  @Field()
+  type: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.transferOrder)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.transferOrder)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => DeliveryOrder, deliveryOrder => deliveryOrder.transferOrder)
+  @Field(type => [DeliveryOrder], { nullable: true })
+  deliveryOrders: DeliveryOrder[]
+
+  @OneToOne(type => RetailReplenishmentOrder)
+  @JoinColumn()
+  @Field(type => RetailReplenishmentOrder, { nullable: true })
+  retailReplenishmentOrder: RetailReplenishmentOrder
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.retailReplenishmentOrder)
+  retailReplenishmentOrderId: string
+
+  @Column({ type: 'date' })
+  @Field()
+  issuedDate: Date
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.updater)
+  updaterId: string
+}

package/server/service/vas/index.ts

@@ -0,0 +1,9 @@
+import { Vas } from './vas'
+import { VasMutation } from './vas-mutation'
+import { VasQuery } from './vas-query'
+
+export const entities = [Vas]
+export const resolvers = [VasQuery, VasMutation]
+
+export * from './vas-mutation'
+export * from './vas-query'

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

@@ -0,0 +1,106 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { NewVas, VasPatch } from '../'
+import { Vas } from './vas'
+
+@Resolver(Vas)
+export class VasMutation {
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Vas)
+  async createVas(@Arg('vas', type => NewVas) vas: NewVas, @Ctx() context: ResolverContext): Promise<Vas> {
+    const { tx, domain, user } = context.state
+
+    return await tx.getRepository(Vas).save({
+      ...vas,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Vas)
+  async updateVas(
+    @Arg('name') name: string,
+    @Arg('patch', type => VasPatch) patch: VasPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Vas> {
+    const { tx, domain, user } = context.state
+
+    const vas = await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, name })
+
+    return await tx.getRepository(Vas).save({
+      ...vas,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Vas])
+  async updateMultipleVas(
+    @Arg('patches', type => [VasPatch]) patches: VasPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Vas[]> {
+    const { tx, domain, user } = context.state
+
+    let results: Vas[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const vasRepo = tx.getRepository(Vas)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await vasRepo.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 vas = await vasRepo.findOneBy({ id: newRecord.id })
+
+        const result = await vasRepo.save({
+          ...vas,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVas(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(Vas).delete(id)
+    return true
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVass(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
+    await tx.getRepository(Vas).delete(ids)
+    return true
+  }
+}