@things-factory/sales-base 4.0.11 → 4.0.16

package/server/constants/order.ts

@@ -38,6 +38,16 @@ export const ORDER_STATUS = {
   PARTIAL_RECEIVED: 'PARTIAL_RECEIVED'
 }
 
+export const DISPATCHMENT_STATUS = {
+  READY_TO_DISPATCH: 'READY_TO_DISPATCH',
+  DISPATCHED: 'DISPATCHED'
+}
+
+export const MANIFEST_STATUS = {
+  OPEN: 'OPEN',
+  CLOSED: 'CLOSED'
+}
+
 export const ORDER_INVENTORY_TYPE = {
   RELEASE_OF_GOODS: 'RELEASE_OF_GOODS',
   ARRIVAL_NOTICE: 'ARRIVAL_NOTICE',

package/server/constants/validation-error-code.ts

@@ -1,2 +1,3 @@
-export const INVALID_DATA_FOUND = { errorCode: 'ivd1', message:'invalid data found'}
-export const RELEASE_QTY_OVER_LIMIT = { errorCode: 'rol1', message:'release qty over limit'}
+export const INVALID_DATA_FOUND = { errorCode: 'ivd1', message: 'invalid data found' }
+export const RELEASE_QTY_OVER_LIMIT = { errorCode: 'rol1', message: 'release qty over limit' }
+export const INSUFFICIENT_STOCK = { errorCode: 'ins1', message: 'insufficient stock' }

package/server/controllers/ecommerce/sellercraft-controller.ts

@@ -1,5 +1,6 @@
 import { Sellercraft, SellercraftAPI } from '@things-factory/integration-sellercraft'
 import { Product } from '@things-factory/product-base'
+
 import { OrderProduct, ReleaseGood } from '../../service'
 import { OrderController } from '../order-controller'
 
@@ -20,7 +21,7 @@ export class SellercraftController extends OrderController {
 
     const orderInformation: any = {
       accountId: sellercraft.accountId,
-      orderId: releaseGood.collectionOrderNo,
+      orderId: releaseGood.refNo2,
       sellercraftOPs
     }
     const packageId: string = await SellercraftAPI.packMarketplaceOrder(sellercraft, { ...orderInformation })
@@ -31,9 +32,9 @@ export class SellercraftController extends OrderController {
   }
 
   async checkExistingReleaseGood(sellercraft: Sellercraft, releaseGood: ReleaseGood): Promise<void> {
-    const { refNo, collectionOrderNo } = releaseGood
+    const { refNo, refNo2 } = releaseGood
     const foundReleaseGood: ReleaseGood = await this.trxMgr.getRepository(ReleaseGood).findOne({
-      where: { domain: sellercraft.domain, refNo, collectionOrderNo }
+      where: { domain: sellercraft.domain, refNo, refNo2 }
     })
 
     if (foundReleaseGood)

package/server/service/arrival-notice/arrival-notice-mutation.ts

@@ -210,6 +210,26 @@ export class ArrivalNoticeMutation {
 
     return confirmedGAN
   }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ArrivalNotice)
+  async updateArrivalNoticeDetails(
+    @Ctx() context: any,
+    @Arg('arrivalNotice', type => ArrivalNoticePatch) arrivalNotice: ArrivalNoticePatch
+  ): Promise<ArrivalNotice> {
+    const { domain, tx } = context.state
+    let existingArrivalNotice = await tx
+      .getRepository(ArrivalNotice)
+      .findOne({ where: { name: arrivalNotice.name, domain } })
+
+    if (!existingArrivalNotice) {
+      throw new Error('Existing Arrival Notice not found.')
+    }
+
+    await tx.getRepository(ArrivalNotice).update(existingArrivalNotice.id, arrivalNotice)
+    return await tx.getRepository(ArrivalNotice).findOne(existingArrivalNotice.id)
+  }
 }
 
 export async function deleteArrivalNotice(

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -4,10 +4,12 @@ import { getRepository, In, SelectQueryBuilder } from 'typeorm'
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { ProductDetail } from '@things-factory/product-base'
 import { buildQuery, Domain, ListParam } from '@things-factory/shell'
 
 import { ArrivalNoticeList } from '../'
 import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
+import { OrderInventory, OrderProduct } from '../../service'
 import { ArrivalNotice } from './arrival-notice'
 
 @Resolver(ArrivalNotice)
@@ -21,89 +23,93 @@ export class ArrivalNoticeQuery {
   ): Promise<ArrivalNotice> {
     const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
 
-    let foundGAN: ArrivalNotice
-
-    if (context?.state?.bizplace) {
-      let param: any
-
-      if (name) param = { domain, name, bizplace }
-      else param = { domain, refNo, bizplace }
-
-      foundGAN = await getRepository(ArrivalNotice).findOne({
-        where: { ...param },
-        relations: [
-          'domain',
-          'bizplace',
-          'releaseGood',
-          'purchaseOrder',
-          'purchaseOrder.bufferLocation',
-          'orderProducts',
-          'orderProducts.product',
-          'orderInventories',
-          'orderInventories.inventory',
-          'orderInventories.inventory.product',
-          'orderInventories.inventory.location',
-          'orderVass',
-          'orderVass.vas',
-          'orderVass.targetProduct',
-          'supplier',
-          'creator',
-          'updater'
-        ]
-      })
-    } else {
-      let param: any
-
-      if (name) param = { domain, name, bizplace: In(await getPermittedBizplaceIds(domain, user)) }
-      else param = { domain, refNo, bizplace: In(await getPermittedBizplaceIds(domain, user)) }
-
-      foundGAN = await getRepository(ArrivalNotice).findOne({
-        where: { ...param },
-        relations: [
-          'domain',
-          'bizplace',
-          'releaseGood',
-          'purchaseOrder',
-          'purchaseOrder.bufferLocation',
-          'orderProducts',
-          'orderProducts.product',
-          'orderInventories',
-          'orderInventories.inventory',
-          'orderInventories.inventory.product',
-          'orderInventories.inventory.location',
-          'orderVass',
-          'orderVass.vas',
-          'orderVass.targetProduct',
-          'creator',
-          'updater'
-        ]
-      })
-    }
+    let param: any = { domain, bizplace: bizplace ? bizplace : In(await getPermittedBizplaceIds(domain, user)) }
+
+    if (name) param = { ...param, name }
+    else if (refNo) param = { ...param, refNo }
+    else return
+
+    let foundGAN: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
+      where: { ...param },
+      relations: [
+        'domain',
+        'bizplace',
+        'releaseGood',
+        'purchaseOrder',
+        'purchaseOrder.bufferLocation',
+        'orderProducts',
+        'orderProducts.product',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.inventory.product',
+        'orderInventories.inventory.location',
+        'orderVass',
+        'orderVass.vas',
+        'orderVass.targetProduct',
+        'supplier',
+        'creator',
+        'updater'
+      ]
+    })
 
     if (name && !foundGAN) throw new Error(`Failed to find arrival notice with ${name}`)
 
-    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-      where: {
-        domain,
-        refBy: foundGAN?.id,
-        category: ATTACHMENT_TYPE.GAN
-      }
-    })
+    if (foundGAN) {
+      const foundAttachments: Attachment[] = await getRepository(Attachment).find({
+        where: {
+          domain,
+          refBy: foundGAN?.id,
+          category: ATTACHMENT_TYPE.GAN
+        }
+      })
 
-    const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id
-      ? await getRepository(Attachment).find({
-          where: {
-            domain,
-            refBy: foundGAN.purchaseOrder?.id,
-            category: ATTACHMENT_TYPE.PO
-          }
+      const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id
+        ? await getRepository(Attachment).find({
+            where: {
+              domain,
+              refBy: foundGAN.purchaseOrder?.id,
+              category: ATTACHMENT_TYPE.PO
+            }
+          })
+        : []
+
+      // add productDetails data to orderProduct.product
+      foundGAN.orderProducts = await Promise.all(
+        foundGAN.orderProducts.map(async (orderProduct: OrderProduct) => {
+          orderProduct.product['productDetails'] = await getRepository(ProductDetail).find({
+            where: {
+              product: orderProduct.product.id,
+              packingType: orderProduct.packingType,
+              packingSize: orderProduct.packingSize
+            }
+          })
+          return orderProduct
         })
-      : []
+      )
 
-    const attachments: Attachment[] = [...foundPOAttachments, ...foundAttachments]
-    if (attachments.length) foundGAN.attachment = attachments
+      // add productDetails data to orderInventory.inventory.product if orderInventory is exist
+      if (foundGAN.orderInventories && foundGAN.orderInventories.length) {
+        foundGAN.orderInventories = await Promise.all(
+          foundGAN.orderInventories.map(async (orderInventory: OrderInventory) => {
+            orderInventory.inventory.product['productDetails'] = await getRepository(ProductDetail).find({
+              where: {
+                product: orderInventory.inventory.product.id,
+                packingType: orderInventory.inventory.packingType,
+                packingSize: orderInventory.inventory.packingSize
+              }
+            })
+            return orderInventory
+          })
+        )
+      }
 
-    return foundGAN
+      return {
+        ...foundGAN,
+        attachment: [...foundPOAttachments, ...foundAttachments]
+      }
+    } else {
+      return
+    }
   }
 
   @Directive('@privilege(category: "order_customer", privilege: "query")')
@@ -276,8 +282,6 @@ export class ArrivalNoticeQuery {
       const [items, total] = await qb.getManyAndCount()
 
       return { items, total }
-
-      return { items, total }
     } catch (error) {
       throw error
     }

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

@@ -86,12 +86,18 @@ export class DeliveryOrderQuery {
         })
       }
 
+      let refNoFilter = params.filters.find(x => x.name == 'refNo')
+      let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
+      let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
+
+      params.filters = params.filters.filter(x => x.name != 'refNo' && x.name != 'refNo2' && x.name != 'refNo3')
+
       const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
       qb.leftJoinAndSelect('do.domain', 'domain')
       qb.leftJoinAndSelect('do.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('do.releaseGood', 'rg')
+      qb.leftJoinAndSelect('do.releaseGood', 'releaseGood')
       qb.leftJoinAndSelect('do.transportDriver', 'td')
       qb.leftJoinAndSelect('do.transportVehicle', 'th')
       qb.leftJoinAndSelect('do.orderInventories', 'oi')
@@ -113,20 +119,33 @@ export class DeliveryOrderQuery {
         'cc.status = do.status'
       )
 
-      const arrChildSortData = ['bizplace', 'releaseGood']
+      if (refNoFilter?.value) {
+        qb.andWhere('releaseGood.ref_no ilike :refNo', { refNo: refNoFilter.value })
+      }
+      if (refNo2Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+      }
+      if (refNo3Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+      }
+
+      const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+      const arrNameSortData = ['bizplace', 'releaseGood', 'updater']
       const sort = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'do.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
+          [arrChildSortData.indexOf(sort.name) >= 0
+            ? 'releaseGood.' + sort.name
+            : arrNameSortData.indexOf(sort.name) >= 0
+            ? sort.name + '.name'
+            : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
         }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+        params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
       )
 
       qb.orderBy(sort)
-      const [items, total] = await qb.getManyAndCount()
 
+      const [items, total] = await qb.getManyAndCount()
       return { items, total }
     } catch (error) {
       debug('deliveryOrders', error.toString())

package/server/service/goods-receival-note/goods-receival-note-query.ts

@@ -1,73 +1,136 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { Bizplace, 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, IsNull } from 'typeorm'
-import { ArrivalNotice, GoodsReceivalNoteList } from '../'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { GoodsReceivalNoteList } from '../'
 import { GoodsReceivalNote } from './goods-receival-note'
 
 @Resolver(GoodsReceivalNote)
 export class GoodsReceivalNoteQuery {
   @Query(returns => GoodsReceivalNoteList)
-  async goodsReceivalNotes(
-    @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<GoodsReceivalNoteList> {
+  async goodsReceivalNotes(@Ctx() context: any, @Args() params: ListParam): Promise<GoodsReceivalNoteList> {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-
-    const arrivalNoticeParam: any = filters.find((param: any) => param.name === 'arrivalNoticeNo')
-    const arrivalNoticeRefNoParam = filters.find(param => param.name === 'arrivalNoticeRefNo')
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
 
-    const bizplaceParam = filters.find(param => param.name === 'bizplaceName')
-    if (bizplaceParam) {
-      const foundBizplaces: Bizplace[] = await getRepository(Bizplace).find({
-        where: {
-          ...convertListParams({ filters: [{ ...bizplaceParam, name: 'name' }] }).where
-        }
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
       })
-
-      // remove non-column params
-      delete convertedParams.where.bizplaceName
-
-      if (foundBizplaces && foundBizplaces.length) {
-        convertedParams.where.bizplace = In(foundBizplaces.map((foundBizplace: Bizplace) => foundBizplace.id))
-      } else {
-        convertedParams.where.bizplace = IsNull()
-      }
-    } else {
-      convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-      convertedParams.where.domain = domain
     }
 
-    if (arrivalNoticeParam || arrivalNoticeRefNoParam) {
-      let arrFilters = []
-      if (arrivalNoticeParam) {
-        arrFilters.push({ ...arrivalNoticeParam, name: 'name' })
-      }
-      if (arrivalNoticeRefNoParam) arrFilters.push({ ...arrivalNoticeRefNoParam, name: 'refNo' })
-      const foundArrivalNotices: ArrivalNotice[] = await getRepository(ArrivalNotice).find({
-        ...convertListParams({ filters: arrFilters })
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
       })
+    }
+
+    let refNoFilter = params.filters.find(x => x.name == 'refNo')
+    let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
+    let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
+    let ganNameFilter = params.filters.find(x => x.name == 'arrivalNoticeNo')
+    let bizplaceFilter = params.filters.find(x => x.name == 'bizplaceName')
+    let ganStatusFilter = params.filters.find(x => x.name == 'ganStatus')
+    let grnStatusFilter = params.filters.find(x => x.name == 'grnStatus')
+
+    params.filters = params.filters.filter(
+      x =>
+        x.name != 'refNo' &&
+        x.name != 'refNo2' &&
+        x.name != 'refNo3' &&
+        x.name != 'arrivalNoticeNo' &&
+        x.name != 'bizplaceName' &&
+        x.name != 'ganStatus' &&
+        x.name != 'grnStatus'
+    )
 
-      // remove non-column params
-      delete convertedParams.where.arrivalNoticeNo
-      delete convertedParams.where.arrivalNoticeRefNo
+    const qb: SelectQueryBuilder<GoodsReceivalNote> = getRepository(GoodsReceivalNote).createQueryBuilder('grn')
+    buildQuery(qb, params, context)
+    qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
+    qb.leftJoinAndSelect('grn.domain', 'domain')
+    qb.leftJoinAndSelect('grn.bizplace', 'bizplace')
+    qb.leftJoinAndSelect('grn.creator', 'creator')
+    qb.leftJoinAndSelect('grn.updater', 'updater')
+    qb.innerJoinAndSelect('grn.arrivalNotice', 'arrivalNotice')
+    qb.leftJoin(
+      subQuery => {
+        return subQuery
+          .select(`ccd.rank`, 'rank')
+          .addSelect(`ccd.name`, 'status')
+          .from(`common_code_details`, 'ccd')
+          .innerJoin(`ccd.commonCode`, 'cc')
+          .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+          .andWhere(`cc.name = 'GRN_STATUS'`)
+          .andWhere(`cc.name = 'GAN_REQUESTS_STATUS'`)
+      },
+      'cc',
+      'cc.status = arrivalNotice.status'
+    )
 
-      if (foundArrivalNotices && foundArrivalNotices.length) {
-        convertedParams.where.arrivalNotice = In(foundArrivalNotices.map((foundAN: ArrivalNotice) => foundAN.id))
-      } else {
-        convertListParams.where.arrivalNotice = IsNull()
-      }
+    let permittedBizplaceIds = await getPermittedBizplaceIds(domain, user)
+    qb.andWhere('grn.bizplace_id IN (:...bizplaceIds)', { bizplaceIds: permittedBizplaceIds })
+
+    if (refNoFilter?.value) {
+      qb.andWhere('arrivalNotice.ref_no ilike :refNo', { refNo: refNoFilter.value })
+    }
+    if (refNo2Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+    }
+    if (refNo3Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+    }
+    if (ganNameFilter?.value) {
+      qb.andWhere('arrivalNotice.name ilike :ganName', { ganName: ganNameFilter.value })
+    }
+    if (bizplaceFilter?.value) {
+      qb.andWhere('bizplace.name ilike :bizName', { bizName: bizplaceFilter.value })
     }
 
-    let [items, total] = await getRepository(GoodsReceivalNote).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'arrivalNotice', 'bizplace', 'creator', 'updater']
-    })
+    if (ganStatusFilter?.value) {
+      qb.andWhere('arrivalNotice.status ilike :ganStatus', { ganStatus: ganStatusFilter.value })
+    }
+    if (grnStatusFilter?.value) {
+      qb.andWhere('grn.status ilike :grnStatus', { grnStatus: grnStatusFilter.value })
+    }
+
+    const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+    const arrNameSortData = ['bizplace', 'arrivalNotice', 'updater']
+    const arrGanStatusSortData = ['ganStatus']
+    const arrGrnStatuSortData = ['status']
+    const sort = (params.sortings || []).reduce(
+      (acc, sort) => ({
+        ...acc,
+        [arrChildSortData.indexOf(sort.name) >= 0
+          ? 'arrivalNotice.' + sort.name
+          : arrNameSortData.indexOf(sort.name) >= 0
+          ? sort.name + '.name'
+          : arrGanStatusSortData.indexOf(sort.name) >= 0
+          ? 'arrivalNotice.status'
+          : arrGrnStatuSortData.indexOf(sort.name) >= 0
+          ? 'grn.status'
+          : 'grn.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+      }),
+      !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+    )
+
+    qb.orderBy(sort)
+
+    const [items, total] = await qb.getManyAndCount()
 
     return { items, total }
   }

package/server/service/index.ts

@@ -1,4 +1,5 @@
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as ManifestEntities, resolvers as ManifestResolvers } from './manifest'
 import {
   entities as ReverseKittingOrderInventoryEntities,
   resolvers as ReverseKittingOrderInventoryResolvers
@@ -38,6 +39,7 @@ import { entities as VasEntity, resolvers as VasResolvers } from './vas'
 import { entities as VasOrderEntity, resolvers as VasOrderResolvers } from './vas-order'
 
 /* EXPORT ENTITY TYPES */
+export * from './manifest/manifest'
 export * from './reverse-kitting-order-inventory/reverse-kitting-order-inventory'
 export * from './reverse-kitting-order/reverse-kitting-order'
 export * from './arrival-notice/arrival-notice'
@@ -139,6 +141,7 @@ export * from './vas/vas-query'
 
 export const entities = [
   /* ENTITIES */
+	...ManifestEntities,
   ...ReverseKittingOrderInventoryEntities,
   ...ReverseKittingOrderEntities,
   ...ArrivalNoticeEntity,
@@ -168,6 +171,7 @@ export const entities = [
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+		...ManifestResolvers,
     ...ReverseKittingOrderInventoryResolvers,
     ...ReverseKittingOrderResolvers,
     ...ArrivalNoticeResolvers,

package/server/service/manifest/index.ts

@@ -0,0 +1,6 @@
+import { Manifest } from './manifest'
+import { ManifestQuery } from './manifest-query'
+import { ManifestMutation } from './manifest-mutation'
+
+export const entities = [Manifest]
+export const resolvers = [ManifestQuery, ManifestMutation]

package/server/service/manifest/manifest-mutation.ts

@@ -0,0 +1,102 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { DISPATCHMENT_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { ReleaseGood } from '../release-good/release-good'
+import { Manifest, ManifestStatus } from './manifest'
+import { ManifestPatch, NewManifest } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Manifest' })
+  async deleteManifest(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Manifest).delete({ domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To generate new Manifest' })
+  async generateManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: any): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const manifestItems: any[] = manifest.manifestItems
+
+    // regroup array of object by transporter
+    let shippingProviderGrouping: any = manifestItems.reduce((a, b) => {
+      a[b.transporter] = [...(a[b.transporter] || []), b]
+      return a
+    }, {})
+
+    for (const transporter in shippingProviderGrouping) {
+      const items: any[] = shippingProviderGrouping[transporter]
+
+      const openManifest: Manifest = await tx
+        .getRepository(Manifest)
+        .findOne({ domain, shippingProvider: transporter, status: ManifestStatus.OPEN })
+
+      let manifest: Manifest
+
+      if (openManifest) {
+        manifest = openManifest
+      } else {
+        manifest = new Manifest()
+        manifest.domain = domain
+        manifest.shippingProvider = transporter
+        manifest.name = OrderNoGenerator.manifest()
+        manifest.creator = user
+        manifest = await tx.getRepository(Manifest).save(manifest)
+      }
+
+      await Promise.all(
+        items.map(async item => {
+          let releaseOrder: ReleaseGood = await tx
+            .getRepository(ReleaseGood)
+            .findOne({ domain, refNo: item.refNo, trackingNo: item.trackingNo })
+          releaseOrder.manifest = manifest
+          releaseOrder.updater = user
+          await tx.getRepository(ReleaseGood).save(releaseOrder)
+        })
+      )
+    }
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Manifest, { description: 'To dispatch Manifest when courier service collect packages' })
+  async dispatchManifest(
+    @Arg('name') name: string,
+    @Arg('patch') patch: ManifestPatch,
+    @Ctx() context: any
+  ): Promise<Manifest> {
+    const { domain, user, tx } = context.state
+
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({
+      where: { domain, name, status: ManifestStatus.OPEN }
+    })
+    if (!manifest) throw new Error(`Unable to find ${name}`)
+
+    let releaseGoods: any[] = await tx.getRepository(ReleaseGood).find({ where: { domain, manifest } })
+
+    releaseGoods = await Promise.all(
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          dispatchmentStatus: DISPATCHMENT_STATUS.DISPATCHED,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(ReleaseGood).save(releaseGoods)
+
+    return await tx.getRepository(Manifest).save({
+      ...manifest,
+      ...patch,
+      status: ManifestStatus.CLOSED,
+      dispatchedAt: new Date(),
+      updater: user
+    })
+  }
+}