@things-factory/sales-base 4.0.0-alpha.8 → 4.0.0-beta.2

package/server/graphql/resolvers/transfer-order/cancel-transfer-order.ts

@@ -1,42 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { OrderInventory, TransferOrder } from '../../../entities'
-
-export const cancelTransferOrderResolver = {
-  async cancelTransferOrder(_: any, { patch }, context: any) {
-    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
-    })
-  }
-}

package/server/graphql/resolvers/transfer-order/complete-transfer-order.ts

@@ -1,56 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../../constants'
-import { OrderInventory, TransferOrder } from '../../../entities'
-
-export const completeTransferOrderResolver = {
-  async completeTransferOrder(_: any, { patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-    let targetOIs: OrderInventory[] = 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: OrderInventory) => {
-        // #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
-    })
-  }
-}

package/server/graphql/resolvers/transfer-order/create-transfer-order.ts

@@ -1,50 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../../constants'
-import { OrderInventory, RetailReplenishmentOrder, TransferOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { addTransferOrderInventories } from './add-tranfer-order-inventories'
-
-export const createTransferOrder = {
-  async createTransferOrder(_: any, { transferOrder }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    let orderInventories: OrderInventory[] = 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,
-      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: OrderInventory) => {
-        return { ...oi, status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE }
-      }),
-      user,
-      tx
-    )
-
-    return createdTransferOrder
-  }
-}

package/server/graphql/resolvers/transfer-order/delete-transfer-order.ts

@@ -1,12 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { TransferOrder } from '../../../entities'
-
-export const deleteTransferOrder = {
-  async deleteTransferOrder(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(TransferOrder).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/transfer-order/delete-transfer-orders.ts

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { TransferOrder } from '../../../entities'
-
-export const deleteTransferOrders = {
-  async deleteTransferOrders(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    await tx.getRepository(TransferOrder).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/transfer-order/generate-transfer-order.ts

@@ -1,80 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from 'domain'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_STATUS
-} from '../../../constants'
-import { OrderInventory, OrderVas, RetailReplenishmentOrder, TransferOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { addTransferOrderInventories } from './add-tranfer-order-inventories'
-
-export const generateTransferOrderResolver = {
-  async generateTransferOrder(_: any, { transferOrder }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    return await generateTransferOrder(transferOrder, domain, user, tx)
-  }
-}
-
-export async function generateTransferOrder(
-  transferOrder: {
-    issuedDate: string
-    remark: string
-    refNo: string
-    type: string
-    ownTransport: string
-    orderInventories: OrderInventory[]
-    orderVass: OrderVas[]
-    bizplace: any
-    retailReplenishmentOrder: RetailReplenishmentOrder
-  },
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<TransferOrder> {
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-  let orderInventories: OrderInventory[] = 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: OrderInventory) => {
-      return { ...oi, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
-    }),
-    user,
-    tx
-  )
-
-  return createdTransferOrder
-}

package/server/graphql/resolvers/transfer-order/index.ts

@@ -1,25 +0,0 @@
-import { transferOrderResolver } from './transfer-order'
-import { transferOrdersResolver } from './transfer-orders'
-
-import { createTransferOrder } from './create-transfer-order'
-import { generateTransferOrderResolver } from './generate-transfer-order'
-import { deleteTransferOrder } from './delete-transfer-order'
-import { deleteTransferOrders } from './delete-transfer-orders'
-import { addTransferOrderInventoriesResolver } from './add-tranfer-order-inventories'
-import { cancelTransferOrderResolver } from './cancel-transfer-order'
-import { completeTransferOrderResolver } from './complete-transfer-order'
-
-export const Query = {
-  ...transferOrdersResolver,
-  ...transferOrderResolver
-}
-
-export const Mutation = {
-  ...addTransferOrderInventoriesResolver,
-  ...cancelTransferOrderResolver,
-  ...completeTransferOrderResolver,
-  ...createTransferOrder,
-  ...deleteTransferOrder,
-  ...deleteTransferOrders,
-  ...generateTransferOrderResolver
-}

package/server/graphql/resolvers/transfer-order/transfer-order.ts

@@ -1,23 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { TransferOrder } from '../../../entities'
-
-export const transferOrderResolver = {
-  async transferOrder(_: any, { name }, context: any) {
-    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'
-      ]
-    })
-  }
-}

package/server/graphql/resolvers/transfer-order/transfer-orders.ts

@@ -1,21 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { TransferOrder } from '../../../entities'
-
-export const transferOrdersResolver = {
-  async transferOrders(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(TransferOrder).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.product',
-        'creator',
-        'updater'
-      ]
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/vas/create-vas.ts

@@ -1,17 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Vas } from '../../../entities'
-
-export const createVas = {
-  async createVas(_: any, { vas }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    return await tx.getRepository(Vas).save({
-      ...vas,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/vas/delete-vas.ts

@@ -1,10 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Vas } from '../../../entities'
-
-export const deleteVas = {
-  async deleteVas(_: any, { id }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    await tx.getRepository(Vas).delete(id)
-  }
-}

package/server/graphql/resolvers/vas/delete-vass.ts

@@ -1,9 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Vas } from '../../../entities'
-
-export const deleteVass = {
-  async deleteVass(_: any, { ids }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    await tx.getRepository(Vas).delete(ids)
-  }
-}

package/server/graphql/resolvers/vas/index.ts

@@ -1,20 +0,0 @@
-import { createVas } from './create-vas'
-import { deleteVas } from './delete-vas'
-import { deleteVass } from './delete-vass'
-import { updateMultipleVas } from './update-multiple-vas'
-import { updateVas } from './update-vas'
-import { vasResolver } from './vas'
-import { vassResolver } from './vass'
-
-export const Query = {
-  ...vasResolver,
-  ...vassResolver
-}
-
-export const Mutation = {
-  ...updateVas,
-  ...updateMultipleVas,
-  ...createVas,
-  ...deleteVas,
-  ...deleteVass
-}

package/server/graphql/resolvers/vas/update-multiple-vas.ts

@@ -1,47 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Vas } from '../../../entities'
-
-export const updateMultipleVas = {
-  async updateMultipleVas(_: any, { patches }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    let results = []
-    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.findOne(newRecord.id)
-
-        const result = await vasRepo.save({
-          ...vas,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/vas/update-vas.ts

@@ -1,18 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { Vas } from '../../../entities'
-
-export const updateVas = {
-  async updateVas(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const vas = await tx.getRepository(Vas).findOne({ domain, name })
-
-    return await tx.getRepository(Vas).save({
-      ...vas,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/vas/vas.ts

@@ -1,17 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Vas } from '../../../entities'
-
-export const vasResolver = {
-  async vas(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(Vas).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/vas/vass.ts

@@ -1,18 +0,0 @@
-import { buildQuery, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { Vas } from '../../../entities'
-
-export const vassResolver = {
-  async vass(_: any, params: ListParam, context: any) {
-    const qb: SelectQueryBuilder<Vas> = getRepository(Vas).createQueryBuilder()
-    buildQuery(qb, params, context)
-
-    const [items, total] = await qb
-      .leftJoinAndSelect('Vas.domain', 'Domain')
-      .leftJoinAndSelect('Vas.creator', 'Creator')
-      .leftJoinAndSelect('Vas.updater', 'Updater')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/vas-order/confirm-vas-order.ts

@@ -1,77 +0,0 @@
-import { Role, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { VasOrder, OrderVas } from '../../../entities'
-
-export const confirmVasOrder = {
-  async confirmVasOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-      where: { domain, name },
-      relations: ['bizplace', 'orderVass', 'orderVass.vas', 'creator', 'updater']
-    })
-
-    let vasOrder: VasOrder
-    let customerBizplace: Bizplace = foundVasOrder.bizplace
-    const foundOrderVass: OrderVas[] = foundVasOrder.orderVass
-
-    if (!foundVasOrder) throw new Error(`Vas order doesn't exists.`)
-    if (foundVasOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
-    if (!foundOrderVass) throw new Error(`Order Vas doesn't exist`)
-
-    // 1. Update status of Order Vas (PENDING => PENDING_RECEIVE)
-    foundOrderVass.forEach(async orderVas => {
-      await tx.getRepository(OrderVas).save({
-        ...orderVas,
-        status: ORDER_VAS_STATUS.PENDING_RECEIVE,
-        updater: user
-      })
-    })
-
-    // 2. Vas Order Status change (PENDING => PENDING_RECEIVE)
-    vasOrder = await tx.getRepository(VasOrder).save({
-      ...foundVasOrder,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-
-    // notification logics
-    // get Office Admin Users
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: context.state.domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New VAS Order from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundVasOrder.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-
-    return vasOrder
-  }
-}

package/server/graphql/resolvers/vas-order/delete-vas-order.ts

@@ -1,26 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { VasOrder, OrderVas } from '../../../entities'
-
-export const deleteVasOrder = {
-  async deleteVasOrder(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    let foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-      where: { domain, name },
-      relations: ['orderVass', 'creator', 'updater']
-    })
-
-    if (!foundVasOrder) throw new Error(`Vas order doesn't exists.`)
-    const foundOVs: OrderVas[] = foundVasOrder.orderVass
-
-    // 1. delete order vass
-    const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-    if (vasIds.length) {
-      await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-    }
-
-    await tx.getRepository(VasOrder).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/vas-order/delete-vas-orders.ts

@@ -1,15 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { VasOrder } from '../../../entities'
-
-export const deleteVasOrders = {
-  async deleteVasOrders(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(VasOrder).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}