@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/graphql/resolvers/release-good/generate-release-good.ts

@@ -1,355 +0,0 @@
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { Partner, User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, getOutletBizplace, getPermittedBizplaces } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product, ProductBundleSetting } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { FileUpload } from 'graphql-upload'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ORDER_STATUS, PRODUCT_GROUP_TYPE } from '../../../constants'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_TYPES,
-  ORDER_VAS_STATUS
-} from '../../../constants/order'
-import {
-  ArrivalNotice,
-  OrderInventory,
-  OrderProduct,
-  OrderVas,
-  ReleaseGood,
-  ShippingOrder,
-  Vas
-} from '../../../entities'
-import { InventoryUtil } from '../../../utils'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { confirmReleaseGood } from '../release-good/confirm-release-good'
-import { receiveReleaseGood } from '../release-good/receive-release-good'
-
-export const generateReleaseGood = {
-  async generateReleaseGood(_: any, { releaseGood, shippingOrder, attachments }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const createdReleaseGood: ReleaseGood = await generateReleaseGoodFunction(
-      _,
-      releaseGood,
-      shippingOrder,
-      attachments,
-      context,
-      tx
-    )
-
-    return createdReleaseGood
-  }
-}
-
-export async function generateReleaseGoodFunction(
-  _: any,
-  releaseGood: any,
-  shippingOrder: any,
-  attachments: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<ReleaseGood> {
-  try {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    // let orderInventories: OrderInventory[] = releaseGood.orderInventories
-    // let orderVass: OrderVas[] = releaseGood.orderVass
-
-    let { orderInventories, orderVass }: { orderInventories: OrderInventory[]; orderVass: OrderVas[] } = releaseGood
-
-    let bizplace: Bizplace
-    let warehouseDomain: Domain = domain
-
-    /** Validate user permitted Bizplace */
-    if (releaseGood.warehouseId) {
-      bizplace = await getOutletBizplace(releaseGood.warehouseId)
-    } else if (releaseGood.customerBizplaceId) {
-      const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-      let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == releaseGood.customerBizplaceId)
-
-      if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-      bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          id: releaseGood.customerBizplaceId
-        },
-        relations: ['domain']
-      })
-      const customerPartner: Partner = await tx
-        .getRepository(Partner)
-        .findOne({ where: { partnerDomain: bizplace.domain }, relations: ['domain'] })
-      warehouseDomain = customerPartner.domain
-    } else if (releaseGood.partnerBizplaceId) {
-      const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-      let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == releaseGood.partnerBizplaceId)
-
-      if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-      bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          id: releaseGood.partnerBizplaceId
-        },
-        relations: ['domain']
-      })
-      warehouseDomain = domain
-    } else {
-      bizplace = await getMyBizplace(domain, user)
-    }
-    /** End Validate user permitted Bizplace Section */
-
-    /** Validate Release Order Product Quantity */
-    await InventoryUtil.validateWarehousePartnersProductsQuantity(domain, bizplace, orderInventories, context, tx)
-    /** End Validate Release Order Product Quantity Section */
-
-    let newReleaseGood: ReleaseGood = new ReleaseGood()
-
-    /** Generate Shipping Order */
-    if (shippingOrder) {
-      const createdSO: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-        ...shippingOrder,
-        name: OrderNoGenerator.shippingOrder(),
-        domain,
-        bizplace,
-        status: ORDER_STATUS.PENDING,
-        creator: user,
-        updater: user
-      })
-
-      newReleaseGood.shippingOrder = createdSO
-    }
-    /** End Generate Shipping Order Section */
-
-    // find RO number rule setting
-    const roNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain,
-        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-      }
-    })
-
-    newReleaseGood = {
-      ...newReleaseGood,
-      name: roNoSetting
-        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
-        : OrderNoGenerator.releaseGood(),
-      domain: warehouseDomain,
-      bizplace: bizplace,
-      collectionOrderNo: releaseGood.collectionOrderNo,
-      courierOption: releaseGood.courierOption,
-      exportOption: releaseGood.exportOption,
-      ownTransport: releaseGood.ownTransport,
-      packingOption: releaseGood.packingOption,
-      marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
-      billingAddress: releaseGood?.billingAddress || null,
-      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
-      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
-      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
-      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
-      deliveryAddress5: releaseGood?.deliveryAddress5 || null,
-      attentionTo: releaseGood?.attentionTo || null,
-      attentionCompany: releaseGood?.attentionCompany || null,
-      city: releaseGood?.city || null,
-      state: releaseGood?.state || null,
-      postalCode: releaseGood?.postalCode || null,
-      country: releaseGood?.country || null,
-      phone1: releaseGood?.phone1 || null,
-      phone2: releaseGood?.phone2 || null,
-      email: releaseGood?.email || null,
-      transporter: releaseGood?.transporter,
-      trackingNo: releaseGood?.trackingNo,
-      airwayBill: releaseGood?.airwayBill,
-      invoice: releaseGood?.invoice,
-      refNo: releaseGood.refNo,
-      refNo2: releaseGood.refNo2,
-      refNo3: releaseGood.refNo3,
-      releaseDate: releaseGood.releaseDate,
-      truckNo: releaseGood.truckNo,
-      orderInventories: releaseGood.orderInventories,
-      type: releaseGood?.type ? releaseGood.type : 'b2b',
-      status: ORDER_STATUS.PENDING,
-      creator: user,
-      updater: user
-    }
-
-    // Make relation with GAN for cross docking
-    let crossDockingGAN: ArrivalNotice = undefined
-    if (releaseGood.crossDocking && releaseGood.ganNo) {
-      crossDockingGAN = await tx.getRepository(ArrivalNotice).findOne({
-        where: { domain, bizplace, name: releaseGood.ganNo, status: ORDER_STATUS.PENDING }
-      })
-      if (!crossDockingGAN) throw new Error(`Failed to find GAN (${releaseGood.ganNo}) for cross docking`)
-
-      newReleaseGood.arrivalNotice = crossDockingGAN
-    }
-
-    let createdReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-
-    // Make relation with RO for cross docking
-    if (createdReleaseGood.crossDocking) {
-      crossDockingGAN.releaseGood = createdReleaseGood
-      await tx.getRepository(ArrivalNotice).save(crossDockingGAN)
-    }
-
-    // Check if there is bundle item in orderInventories
-    const bundledOIs: OrderInventory[] = orderInventories.filter(
-      oi => oi.product.groupType === PRODUCT_GROUP_TYPE.BUNDLE
-    )
-
-    const singleProductOIs: OrderInventory[] = orderInventories.filter(
-      oi => oi.product.groupType !== PRODUCT_GROUP_TYPE.BUNDLE
-    )
-
-    const splitBundleOIs: OrderInventory[] = []
-
-    // If there is bundle item, split each item in that bundle into into each product
-    if (bundledOIs && bundledOIs.length > 0) {
-      await Promise.all(
-        bundledOIs.map(async (oi: OrderInventory) => {
-          let splitOI: OrderInventory = null
-
-          const pbSettings: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
-            where: { productBundle: oi.product.id },
-            relations: ['product', 'productBundle']
-          })
-
-          pbSettings.forEach(pbs => {
-            splitOI = {
-              ...oi,
-              releaseQty: oi.releaseQty * pbs.bundleQty,
-              releaseUomValue: oi.releaseUomValue * pbs.bundleQty * pbs.product.primaryValue,
-              packingType: pbs.product.packingType,
-              batchId: '',
-              product: {
-                id: pbs.product.id,
-                name: pbs.product.name,
-                groupType: PRODUCT_GROUP_TYPE.SINGLE
-              }
-            }
-            splitBundleOIs.push(splitOI)
-          })
-        })
-      )
-    }
-
-    orderInventories = [...singleProductOIs, ...splitBundleOIs]
-
-    let orderProducts: OrderProduct[] = []
-
-    for (let oi of orderInventories) {
-      let newOrderInv: OrderInventory = Object.assign({}, oi)
-      newOrderInv = {
-        ...newOrderInv,
-        domain: warehouseDomain,
-        bizplace: bizplace,
-        status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
-        releaseGood: createdReleaseGood,
-        product: await tx.getRepository(Product).findOne(oi.product.id),
-        creator: user,
-        updater: user
-      }
-
-      if (newOrderInv.inventory?.id) {
-        const foundInv: Inventory = await tx.getRepository(Inventory).findOne(newOrderInv.inventory.id)
-        newOrderInv.inventory = foundInv
-
-        foundInv.lockedQty = Number(foundInv.lockedQty) + newOrderInv.releaseQty
-        foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + newOrderInv.releaseUomValue
-        foundInv.updater = user
-
-        await tx.getRepository(Inventory).save(foundInv)
-      }
-
-      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
-      newOrderProduct = {
-        ...newOrderProduct,
-        packQty: 0,
-        actualPackQty: 0,
-        palletQty: 0,
-        actualPalletQty: 0,
-        status: newOrderInv.inventory?.id ? ORDER_PRODUCT_STATUS.ASSIGNED : ORDER_PRODUCT_STATUS.PENDING_ASSIGN
-      }
-
-      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
-
-      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
-    }
-
-    if (orderVass?.length) {
-      orderVass = await Promise.all(
-        orderVass.map(async orderVas => {
-          if (orderVas?.targetProduct?.id) {
-            orderVas.targetProduct = await tx.getRepository(Product).findOne(orderVas.targetProduct.id)
-          }
-
-          let newOrderVas: OrderVas = {
-            ...orderVas,
-            domain: warehouseDomain,
-            bizplace,
-            name: OrderNoGenerator.releaseVas(),
-            vas: await tx.getRepository(Vas).findOne(orderVas.vas.id),
-            type: ORDER_TYPES.RELEASE_OF_GOODS,
-            releaseGood: createdReleaseGood,
-            status: ORDER_VAS_STATUS.PENDING,
-            creator: user,
-            updater: user
-          }
-
-          if (orderVas?.inventory?.id) {
-            newOrderVas.inventory = await tx.getRepository(Inventory).findOne(orderVas.inventory.id)
-          }
-
-          return newOrderVas
-        })
-      )
-
-      await tx.getRepository(OrderVas).save(orderVass)
-    }
-
-    if (attachments?.length > 0) {
-      const files: Attachment[] = attachments.map(attachment => {
-        return {
-          file: attachment,
-          refBy: createdReleaseGood.id,
-          category: ATTACHMENT_TYPE.DELIVERY_ORDER
-        }
-      })
-      await createAttachments(_, { attachments: files }, context)
-    }
-
-    const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
-    })
-
-    const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-      where: { setting: directReceiveSetting, domain, partnerDomain: bizplace?.domain }
-    })
-
-    // If status of create RO is PENDING then directly CONFIRM -> RECEIVE
-    if (
-      !isNaN(partnerDirectReceiveSetting?.value) &&
-      !isNaN(parseFloat(partnerDirectReceiveSetting?.value)) &&
-      createdReleaseGood.status === ORDER_STATUS.PENDING
-    ) {
-      let partnerDirectReceiveSettingValue = parseFloat(partnerDirectReceiveSetting.value)
-
-      // CONFIRM if setting value is > 0
-      if (partnerDirectReceiveSettingValue > 0) await confirmReleaseGood(createdReleaseGood.name, context, tx)
-
-      // RECEIVE if setting value is > 1
-      if (partnerDirectReceiveSettingValue > 1) await receiveReleaseGood(createdReleaseGood.name, context, tx)
-    }
-
-    return createdReleaseGood
-  } catch (error) {
-    throw error
-  }
-}

package/server/graphql/resolvers/release-good/index.ts

@@ -1,30 +0,0 @@
-import { confirmReleaseGoodResolver } from './confirm-release-good'
-import { addReleaseGood } from './add-release-good'
-import { deleteReleaseGoodResolver } from './delete-release-good'
-import { deleteReleaseGoods } from './delete-release-goods'
-import { generateReleaseGood } from './generate-release-good'
-import { receiveReleaseGoodResolver } from './receive-release-good'
-import { rejectReleaseGoodResolver } from './reject-release-good'
-import { releasableInventoriesResolver } from './releasable-inventories'
-import { releaseGoodResolver } from './release-good'
-import { releaseGoodDetailResolver } from './release-good-detail'
-import { releaseGoodRequestsResolver } from './release-good-requests'
-import { releaseGoodsResolver } from './release-goods'
-
-export const Query = {
-  ...releaseGoodsResolver,
-  ...releaseGoodResolver,
-  ...releaseGoodRequestsResolver,
-  ...releaseGoodDetailResolver,
-  ...releasableInventoriesResolver
-}
-
-export const Mutation = {
-  ...deleteReleaseGoodResolver,
-  ...deleteReleaseGoods,
-  ...confirmReleaseGoodResolver,
-  ...generateReleaseGood,
-  ...receiveReleaseGoodResolver,
-  ...rejectReleaseGoodResolver,
-  ...addReleaseGood
-}

package/server/graphql/resolvers/release-good/receive-release-good.ts

@@ -1,98 +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_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReleaseGood } from '../../../entities'
-
-export const receiveReleaseGoodResolver = {
-  async receiveReleaseGood(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const releaseGood: ReleaseGood = await receiveReleaseGood(name, context, tx)
-    return releaseGood
-  }
-}
-
-export async function receiveReleaseGood(name: string, context: any, tx: EntityManager): Promise<ReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderVass']
-  })
-
-  if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
-  let foundOIs: OrderInventory[] = foundReleaseGood.orderInventories
-  let foundOVs: OrderVas[] = foundReleaseGood.orderVass
-  let customerBizplace: Bizplace = foundReleaseGood.bizplace
-
-  // 1. RO Status change (PENDING_RECEIVE => PENDING_WORKSHEET)
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save({
-    ...foundReleaseGood,
-    status: ORDER_STATUS.PENDING_WORKSHEET,
-    acceptedBy: user,
-    acceptedAt: new Date(),
-    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)
-
-  // 2. Update status of order vass
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.READY_TO_PROCESS,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    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: 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 Release Order from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundReleaseGood.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-  }
-
-  return releaseGood
-}

package/server/graphql/resolvers/release-good/reject-release-good.ts

@@ -1,105 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReleaseGood, ShippingOrder } from '../../../entities'
-
-export const rejectReleaseGoodResolver = {
-  async rejectReleaseGood(_: any, { name, patch: { remark } }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    return await rejectReleaseGood(tx, context, name, remark)
-  }
-}
-export async function rejectReleaseGood(
-  tx: EntityManager,
-  context: any,
-  name: string,
-  remark: string
-): Promise<ReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderInventories.inventory', 'orderVass', 'shippingOrder']
-  })
-
-  if (!releaseGood) throw new Error(`Release good doesn't exists.`)
-  if (!remark) throw new Error('Remark is not exist.')
-
-  let foundOIs: OrderInventory[] = releaseGood.orderInventories
-  let foundOVs: OrderVas[] = releaseGood.orderVass
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  if (foundOIs && foundOIs.length) {
-    await tx.getRepository(OrderInventory).save(
-      await Promise.all(
-        foundOIs.map(async (oi: OrderInventory) => {
-          if (oi?.inventory?.id) {
-            oi.inventory = await tx.getRepository(Inventory).findOne(oi.inventory.id)
-
-            await tx.getRepository(Inventory).save({
-              ...oi.inventory,
-              lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-              lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
-              updater: user
-            })
-          }
-
-          oi.status = ORDER_INVENTORY_STATUS.REJECTED
-          oi.updater = user
-          return oi
-        })
-      )
-    )
-  }
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  if (releaseGood.shippingOrder) {
-    // 2. 1) if it's yes update status of collection order
-    const shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: { domain, name: releaseGood.shippingOrder.name }
-    })
-
-    shippingOrder.status = ORDER_STATUS.REJECTED
-    shippingOrder.updater = user
-    await tx.getRepository(ShippingOrder).save(shippingOrder)
-  }
-
-  releaseGood.remark = remark
-  releaseGood.status = ORDER_STATUS.REJECTED
-  releaseGood.updater = user
-  await tx.getRepository(ReleaseGood).save(releaseGood)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(releaseGood?.bizplace, tx)
-
-  if (users?.length) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${releaseGood.name}`,
-      body: `Your RO has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return releaseGood
-}