@things-factory/sales-base 8.0.3 → 8.0.6

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

@@ -1,309 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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
-  }
-}