@things-factory/sales-base 4.0.0-alpha.7 → 4.0.0-beta.1

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

@@ -0,0 +1,59 @@
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { ShippingOrderList } from '../'
+import { ShippingOrder } from './shipping-order'
+
+@Resolver(ShippingOrder)
+export class ShippingOrderQuery {
+  @Query(returns => ShippingOrderList)
+  async shippingOrders(
+    @Ctx() context: any,
+    @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<ShippingOrderList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(ShippingOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => ShippingOrder)
+  async shippingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ShippingOrder> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    return await getRepository(ShippingOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() shippingOrder: ShippingOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(shippingOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() shippingOrder: ShippingOrder): Promise<User> {
+    return await getRepository(User).findOne(shippingOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() shippingOrder: ShippingOrder): Promise<User> {
+    return await getRepository(User).findOne(shippingOrder.updaterId)
+  }
+}

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

@@ -0,0 +1,74 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { ShippingOrder } from './shipping-order'
+
+@ObjectType()
+export class ShippingOrderList {
+  @Field(type => [ShippingOrder], { nullable: true })
+  items: ShippingOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewShippingOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field()
+  shipName: string
+
+  @Field()
+  containerNo: string
+
+  @Field({ nullable: true })
+  containerArrivalDate: string
+
+  @Field({ nullable: true })
+  containerLeavingDate: string
+
+  @Field({ nullable: true })
+  containerArrivalDateTime: string
+
+  @Field({ nullable: true })
+  containerLeavingDateTime: string
+
+  @Field()
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+}
+
+@InputType()
+export class ShippingOrderPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  shipName: string
+
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Field({ nullable: true })
+  containerArrivalDate: string
+
+  @Field({ nullable: true })
+  containerLeavingDate: string
+
+  @Field({ nullable: true })
+  containerArrivalDateTime: string
+
+  @Field({ nullable: true })
+  containerLeavingDateTime: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  status: string
+}

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

@@ -0,0 +1,113 @@
+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,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+@Entity()
+@Index('ix_shipping-order_0', (shippingOrder: ShippingOrder) => [shippingOrder.domain, shippingOrder.name], {
+  unique: true
+})
+@ObjectType()
+export class ShippingOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column()
+  @Field()
+  shipName: string
+
+  @Column()
+  @Field()
+  containerNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerArrivalDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerArrivalDateTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerLeavingDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerLeavingDateTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  from: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  to: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  loadType: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,6 @@
+import { TransferOrder } from './transfer-order'
+import { TransferOrderMutation } from './transfer-order-mutation'
+import { TransferOrderQuery } from './transfer-order-query'
+
+export const entities = [TransferOrder]
+export const resolvers = [TransferOrderQuery, TransferOrderMutation]

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

@@ -0,0 +1,300 @@
+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 } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+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: any
+  ): Promise<boolean> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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: any
+  ): Promise<TransferOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
+
+    const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
+      where: { domain, bizplace, 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: any
+  ): Promise<TransferOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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, bizplace: myBizplace, 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: any
+  ): Promise<boolean> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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: any
+  ): Promise<TransferOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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, name: patch.name, bizplace: myBizplace },
+      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, transferOrder: foundTO }
+    })
+
+    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: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(TransferOrder).delete({ domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteTransferOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(TransferOrder).delete({
+      domain,
+      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: { ...transferOrder },
+      relations: ['bizplace', 'orderInventories']
+    })
+  }
+
+  orderInventories = await Promise.all(
+    orderInventories.map(async (oi: OrderInventory) => {
+      const foundProduct: Product = await productRepo.findOne({ domain, 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)
+}
+
+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,
+      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
+  })
+
+  // #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,65 @@
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { TransferOrderList } from '../'
+import { TransferOrder } from './transfer-order'
+
+@Resolver(TransferOrder)
+export class TransferOrderQuery {
+  @Query(returns => TransferOrderList)
+  async transferOrders(
+    @Ctx() context: any,
+    @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: any): Promise<TransferOrder> {
+    const { domain }: { domain: Domain } = context.state
+
+    const repository = getRepository(TransferOrder)
+
+    return await repository.findOne({
+      where: { domain, name },
+      relations: [
+        'domain',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() transferOrder: TransferOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(transferOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() transferOrder: TransferOrder): Promise<User> {
+    return await getRepository(User).findOne(transferOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() transferOrder: TransferOrder): Promise<User> {
+    return await getRepository(User).findOne(transferOrder.updaterId)
+  }
+}