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

package/server/graphql/resolvers/purchase-order/update-purchase-order.ts

@@ -1,121 +0,0 @@
-import { Attachment, createAttachments, deleteAttachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, ContactPoint, getPermittedBizplaces } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ATTACHMENT_TYPE } from '../../../constants'
-import { OrderProduct, PurchaseOrder, PurchaseOrderOtherCharge } from '../../../entities'
-import { getPurchaseOrderFunction, upsertPurchaseOrderProducts } from './index'
-
-export const updatePurchaseOrder = {
-  async updatePurchaseOrder(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const repository = tx.getRepository(PurchaseOrder)
-    const purchaseOrder = await repository.findOne({
-      where: { domain, name }
-    })
-
-    return await repository.save({
-      ...purchaseOrder,
-      ...patch,
-      updater: user
-    })
-  }
-}
-
-export async function updatePurchaseOrderFunction(
-  _: any,
-  purchaseOrder: any,
-  file: Attachment,
-  context: any,
-  tx?: EntityManager
-): Promise<PurchaseOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  let existingPurchaseOrder: any = await getPurchaseOrderFunction(_, purchaseOrder.name, context, tx)
-
-  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
-  let otherCharges: PurchaseOrderOtherCharge[] = purchaseOrder.otherCharges
-
-  if (purchaseOrder?.bizplace?.id) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == purchaseOrder.bizplace.id)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    purchaseOrder.bizplace = foundPermittedBizplace
-  }
-
-  if (purchaseOrder?.supplier?.id) {
-    purchaseOrder.supplier = await getRepository(ContactPoint).findOne({ id: purchaseOrder.supplier.id })
-  }
-
-  if (purchaseOrder?.bufferLocation?.id) {
-    purchaseOrder.bufferLocation = await getRepository(Location).findOne({ id: purchaseOrder.bufferLocation.id })
-  }
-
-  // // 1. Update purchase order
-  const updatePurchaseOrder: PurchaseOrder = await tx.getRepository(PurchaseOrder).save({
-    ...existingPurchaseOrder,
-    ...purchaseOrder,
-    domain,
-    creator: user,
-    updater: user
-  })
-
-  // // 2. Update purchase order product
-  await upsertPurchaseOrderProducts(domain, purchaseOrder.bizplace, purchaseOrder, orderProducts, user, tx)
-
-  // // 3. Delete Removed Other Charges
-  const otherChargesRepo: Repository<PurchaseOrderOtherCharge> =
-    tx?.getRepository(PurchaseOrderOtherCharge) || getRepository(PurchaseOrderOtherCharge)
-  let removeOC = existingPurchaseOrder.otherCharges.filter(
-    existingOC => (otherCharges.filter(inOC => inOC.id == existingOC.id).length = 0)
-  )
-  removeOC.forEach(async oc => {
-    await otherChargesRepo.delete(oc)
-  })
-
-  // // 4. Process Purchase Other Other Charges Data and Insert/ Update data
-  for await (let oc of otherCharges) {
-    if (!oc?.id) delete oc.id
-    await otherChargesRepo.save({
-      ...oc,
-      domain,
-      purchaseOrder: existingPurchaseOrder,
-      creator: oc?.id ? oc.creator : user,
-      updater: user
-    })
-  }
-
-  // // 5. Remove Purchase Order Products
-  const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-    where: {
-      domain,
-      refBy: purchaseOrder.id,
-      category: ATTACHMENT_TYPE.PO
-    }
-  })
-
-  // // 6. Remove All Attachment
-  for await (const file of foundAttachments.filter(attachment => !file.find(file => file.id == attachment.id))) {
-    await deleteAttachment(_, { id: file.id }, context)
-  }
-
-  // // 7. Add New Attachment
-  const newAttachments = file.filter(attachment => !attachment.id)
-  if (newAttachments.length > 0) {
-    const attachments: Attachment[] = newAttachments.map(attachment => {
-      return {
-        file: attachment,
-        refBy: updatePurchaseOrder.id,
-        category: ATTACHMENT_TYPE.PO
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return existingPurchaseOrder
-}

package/server/graphql/resolvers/purchase-order/upsert-purchase-order.ts

@@ -1,51 +0,0 @@
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, ContactPoint, getMyBizplace, getOutletBizplace, getPermittedBizplaces } 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 { Location } from '@things-factory/warehouse-base'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import {
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  PURCHASE_ORDER_STATUS,
-  ATTACHMENT_TYPE
-} from '../../../constants'
-import { ArrivalNotice, PurchaseOrder, OrderProduct } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import {  updatePurchaseOrderFunction, createPurchaseOrderFunction} from './index'
-import { generateArrivalNoticeFunction, confirmArrivalNoticeFunction } from '../arrival-notice/index'
-
-export const upsertPurchaseOrder = {
-  async upsertPurchaseOrder(_: any, { purchaseOrder, file }, context: any) {
-    try {
-      const { tx }: { tx: EntityManager } = context.state
-      const createdPurchaseOrder: PurchaseOrder = await upsertPurchaseOrderFunction(_, purchaseOrder, file, context, tx)
-  
-      return createdPurchaseOrder      
-    } catch (error) {
-      throw error
-    }
-  }
-}
-
-export async function upsertPurchaseOrderFunction(
-  _: any,
-  purchaseOrder: any,
-  file: Attachment,
-  context: any,
-  tx?: EntityManager
-): Promise<PurchaseOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-  let orderProducts: OrderProduct[] = purchaseOrder.orderProducts
-
-  if(!purchaseOrder.id){
-    purchaseOrder = await createPurchaseOrderFunction(_, purchaseOrder, file, context, tx) 
-  }else{
-    purchaseOrder = await updatePurchaseOrderFunction(_, purchaseOrder, file, context, tx) 
-  }
-  
-  return purchaseOrder
-}

package/server/graphql/resolvers/purchase-order-other-charge/delete-purchase-order-charge.ts

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

package/server/graphql/resolvers/purchase-order-other-charge/delete-purchase-order-charges.ts

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

package/server/graphql/resolvers/purchase-order-other-charge/index.ts

@@ -1,14 +0,0 @@
-import { deletePurchaseOrderOtherCharge } from './delete-purchase-order-charge'
-import { deletePurchaseOrderOtherCharges } from './delete-purchase-order-charges'
-import { purchaseOrderOtherChargeResolver } from './purchase-order-other-charge'
-import { purchaseOrderOtherChargesResolver } from './purchase-order-other-charges'
-
-export const Query = {
-  ...purchaseOrderOtherChargeResolver,
-  ...purchaseOrderOtherChargesResolver
-}
-
-export const Mutation = {
-  ...deletePurchaseOrderOtherCharge,
-  ...deletePurchaseOrderOtherCharges
-}

package/server/graphql/resolvers/purchase-order-other-charge/purchase-order-other-charge.ts

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

package/server/graphql/resolvers/purchase-order-other-charge/purchase-order-other-charges.ts

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

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

@@ -1,18 +0,0 @@
-import { ReleaseGood } from '../../../entities'
-import { confirmReleaseGood } from './confirm-release-good'
-import { generateReleaseGoodFunction } from './generate-release-good'
-import { EntityManager } from 'typeorm'
-import { receiveReleaseGood } from './receive-release-good'
-
-export const addReleaseGood = {
-  async addReleaseGood(_: any, { releaseGood, shippingOrder, file }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const createdRO: ReleaseGood = await generateReleaseGoodFunction(_, releaseGood, shippingOrder, file, context, tx)
-
-    const confirmedRO: ReleaseGood = await confirmReleaseGood(createdRO.name, context, tx)
-
-    const receivedRO: ReleaseGood = await receiveReleaseGood(confirmedRO.name, context, tx)
-
-    return receivedRO
-  }
-}

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

@@ -1,131 +0,0 @@
-import { Role, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-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 { EcommerceController } from '../../../controllers'
-import { OrderInventory, OrderVas, ReleaseGood } from '../../../entities'
-import { confirmArrivalNoticeFunction } from '../arrival-notice/confirm-arrival-notice'
-
-export const confirmReleaseGoodResolver = {
-  async confirmReleaseGood(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const releaseGood: ReleaseGood = await confirmReleaseGood(name, context, tx)
-
-    // If current RO has cross docking
-    if (releaseGood.crossDocking) {
-      const { arrivalNotice } = await tx.getRepository(ReleaseGood).findOne(releaseGood.id, {
-        relations: ['arrivalNotice']
-      })
-
-      // If status of related GAN is not equal to PENDING_RECEIVE (i.e. Wasn't confirmed yet.)
-      if (arrivalNotice.status !== ORDER_STATUS.PENDING_RECEIVE) {
-        await confirmArrivalNoticeFunction(arrivalNotice.name, context, tx)
-      }
-    }
-
-    return releaseGood
-  }
-}
-
-export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
-
-  const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { name, status: ORDER_STATUS.PENDING },
-    relations: [
-      'bizplace',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'orderInventories',
-      'orderInventories.product',
-      '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
-  const companyDomain: Domain = customerBizplace?.company.domain
-
-  // find for any existing marketplace store connections
-  const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true }
-  })
-
-  if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-    let productIds: string[] = foundOIs.map(oi => oi.product.id)
-    productIds = Array.from(new Set([...productIds]))
-    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-    await ecommerceCtrl.updateProductVariationStock(marketplaceStores, productIds, companyDomain)
-  }
-
-  // 1. RO Status change (PENDING => PENDING_RECEIVE)
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save({
-    ...foundReleaseGood,
-    status: ORDER_STATUS.PENDING_RECEIVE,
-    updater: user
-  })
-
-  // 1. Update status of order inventories
-  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
-    return {
-      ...orderInventory,
-      status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE,
-      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.PENDING_RECEIVE,
-        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/delete-release-good.ts

@@ -1,97 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager, In } from 'typeorm'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { ArrivalNotice, OrderProduct, OrderInventory, OrderVas, ReleaseGood, ShippingOrder } from '../../../entities'
-import { deleteArrivalNotice } from '../arrival-notice/delete-arrival-notice'
-
-export const deleteReleaseGoodResolver = {
-  async deleteReleaseGood(_: any, { name }, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-    return await deleteReleaseGood(tx, name, user, domain)
-  }
-}
-export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
-  let foundReleaseOrder: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name },
-    relations: [
-      'arrivalNotice',
-      'orderInventories',
-      'orderInventories.orderProduct',
-      'orderInventories.inventory',
-      'orderVass',
-      'shippingOrder',
-      'creator',
-      'updater'
-    ]
-  })
-
-  if (!foundReleaseOrder) throw new Error(`Arrival notice doesn't exists.`)
-  const foundOIs: OrderInventory[] = foundReleaseOrder.orderInventories
-  const foundOVs: OrderVas[] = foundReleaseOrder.orderVass
-  const foundSO: ShippingOrder = foundReleaseOrder.shippingOrder
-
-  let foundAttachment: Attachment
-  if (foundReleaseOrder?.ownTransport) {
-    foundAttachment = await tx.getRepository(Attachment).findOne({
-      where: {
-        domain,
-        refBy: foundReleaseOrder.id,
-        category: ATTACHMENT_TYPE.DELIVERY_ORDER
-      }
-    })
-  }
-
-  // Delete order inventories by ids
-  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
-        })
-      }
-
-      await tx.getRepository(OrderInventory).delete({ id: oi.id })
-
-      if(oi?.orderProduct?.id){
-        await tx.getRepository(OrderProduct).delete({ id: oi.orderProduct.id })
-      }
-
-      return oi
-    })
-  )
-
-  // 2. delete order vass
-  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-  if (vasIds.length) {
-    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-  }
-
-  // 4. if there is SO, delete SO
-  if (foundSO) {
-    await tx.getRepository(ShippingOrder).delete({ domain, id: foundSO.id })
-  }
-
-  if (foundAttachment) {
-    await tx.getRepository(Attachment).delete({ domain, id: foundAttachment.id })
-  }
-
-  // 5. Remove relation with GAN if it's cross docking
-  if (foundReleaseOrder.crossDocking && foundReleaseOrder.arrivalNotice?.id) {
-    let arrivalNotice: ArrivalNotice = foundReleaseOrder.arrivalNotice
-    arrivalNotice.releaseGood = null
-    arrivalNotice = await tx.getRepository(ArrivalNotice).save(arrivalNotice)
-
-    await tx.getRepository(ReleaseGood).delete({ domain, name })
-    await deleteArrivalNotice(tx, arrivalNotice.name, user, domain)
-  } else {
-    await tx.getRepository(ReleaseGood).delete({ domain, name })
-  }
-  return true
-}

package/server/graphql/resolvers/release-good/delete-release-goods.ts

@@ -1,13 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { ReleaseGood } from '../../../entities'
-
-export const deleteReleaseGoods = {
-  async deleteReleaseGoods(_: any, { names }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    await tx.getRepository(ReleaseGood).delete({
-      domain: context.state.domain,
-      name: In(names)
-    })
-    return true
-  }
-}