@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/inventory-check/inventory-check-mutation.ts

@@ -1,8 +1,10 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+
 import { InventoryCheckPatch, NewInventoryCheck } from '../'
 import { ORDER_STATUS, ORDER_TYPES } from '../../constants'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
@@ -14,9 +16,9 @@ export class InventoryCheckMutation {
   @Directive('@transaction')
   async createInventoryCheck(
     @Arg('inventoryCheck', type => NewInventoryCheck) inventoryCheck: NewInventoryCheck,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryCheck> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     return await tx.getRepository(InventoryCheck).save({
       ...inventoryCheck,
       domain: context.state.domain,
@@ -30,13 +32,13 @@ export class InventoryCheckMutation {
   async updateInventoryCheck(
     @Arg('name') name: string,
     @Arg('patch', type => InventoryCheckPatch) patch: InventoryCheckPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryCheck> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
 
     const repository = tx.getRepository(InventoryCheck)
     const inventoryCheck = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     return await repository.save({
@@ -51,9 +53,9 @@ export class InventoryCheckMutation {
   async generateCycleCount(
     @Arg('executionDate') executionDate: string,
     @Arg('customerId') customerId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryCheck> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     return await generateCycleCount(tx, domain, user, executionDate, customerId)
   }
 
@@ -61,9 +63,9 @@ export class InventoryCheckMutation {
   @Directive('@transaction')
   async updateMultipleInventoryCheck(
     @Arg('patches', type => [InventoryCheckPatch]) patches: InventoryCheckPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryCheck[]> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
 
     let results: InventoryCheck[] = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -88,7 +90,7 @@ export class InventoryCheckMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const inventoryCheck = await inventoryCheckRepo.findOne(newRecord.id)
+        const inventoryCheck = await inventoryCheckRepo.findOneBy({ id: newRecord.id })
 
         const result = await inventoryCheckRepo.save({
           ...inventoryCheck,
@@ -105,18 +107,21 @@ export class InventoryCheckMutation {
 
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteInventoryCheck(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx }: { tx: EntityManager } = context.state
-    await tx.getRepository(InventoryCheck).delete({ domain: context.state.domain, name })
+  async deleteInventoryCheck(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
+    await tx.getRepository(InventoryCheck).delete({ domain: { id: context.state.domain.id }, name })
     return true
   }
 
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteInventoryChecks(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteInventoryChecks(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx } = context.state
     await tx.getRepository(InventoryCheck).delete({
-      domain: context.state.domain,
+      domain: { id: context.state.domain.id },
       name: In(names)
     })
     return true
@@ -130,7 +135,7 @@ export async function generateCycleCount(
   executionDate: string,
   customerId: string
 ): Promise<InventoryCheck> {
-  const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(customerId)
+  const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: customerId })
 
   return tx.getRepository(InventoryCheck).save({
     name: OrderNoGenerator.cycleCount(),

package/server/service/inventory-check/inventory-check-query.ts

@@ -1,7 +1,8 @@
-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 { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { InventoryCheckList } from '../'
 import { InventoryCheck } from './inventory-check'
 
@@ -9,7 +10,7 @@ import { InventoryCheck } from './inventory-check'
 export class InventoryCheckQuery {
   @Query(returns => InventoryCheckList)
   async inventoryChecks(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
@@ -23,25 +24,25 @@ export class InventoryCheckQuery {
   }
 
   @Query(returns => InventoryCheck)
-  async inventoryCheck(@Arg('name') name: string, @Ctx() context: any): Promise<InventoryCheck> {
+  async inventoryCheck(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<InventoryCheck> {
     return await getRepository(InventoryCheck).findOne({
-      where: { domain: context.state.domain, name },
+      where: { domain: { id: context.state.domain.id }, name },
       relations: ['domain', 'creator', 'updater']
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() inventoryCheck: InventoryCheck): Promise<Domain> {
-    return await getRepository(Domain).findOne(inventoryCheck.domainId)
+    return await getRepository(Domain).findOneBy({ id: inventoryCheck.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() inventoryCheck: InventoryCheck): Promise<User> {
-    return await getRepository(User).findOne(inventoryCheck.creatorId)
+    return await getRepository(User).findOneBy({ id: inventoryCheck.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() inventoryCheck: InventoryCheck): Promise<User> {
-    return await getRepository(User).findOne(inventoryCheck.updaterId)
+    return await getRepository(User).findOneBy({ id: inventoryCheck.updaterId })
   }
 }

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

@@ -1,8 +1,8 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, Repository } from 'typeorm'
+import { EntityManager, Repository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, getRepository } from '@things-factory/shell'
 
 import { InvoicePatch, NewInvoice } from '../'
 import { OrderNoGenerator } from '../../utils'
@@ -13,22 +13,25 @@ import { Invoice } from './invoice'
 export class InvoiceMutation {
   @Mutation(returns => Invoice)
   @Directive('@transaction')
-  async createInvoice(@Arg('invoice', type => NewInvoice) invoice: NewInvoice, @Ctx() context: any): Promise<Invoice> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async createInvoice(
+    @Arg('invoice', type => NewInvoice) invoice: NewInvoice,
+    @Ctx() context: ResolverContext
+  ): Promise<Invoice> {
+    const { tx, domain, user } = context.state
     let invoiceProducts: any[] = invoice.invoiceProducts
 
     let createdInvoice: Invoice = await tx.getRepository(Invoice).save({
       ...invoice,
       domain,
       name: OrderNoGenerator.invoice(),
-      // releaseGood: await tx.getRepository(ReleaseGood).findOne(invoice?.releaseGood.id),
+      // releaseGood: await tx.getRepository(ReleaseGood).findOneBy({ id: invoice?.releaseGood.id }),
       creator: user
     })
 
     await addInvoiceProducts(domain, createdInvoice, invoiceProducts, user, tx)
 
     createdInvoice = await tx.getRepository(Invoice).findOne({
-      where: { domain, id: createdInvoice.id },
+      where: { domain: { id: domain.id }, id: createdInvoice.id },
       relations: ['invoiceProducts']
     })
 
@@ -40,13 +43,13 @@ export class InvoiceMutation {
   async updateInvoice(
     @Arg('name') name: string,
     @Arg('patch', type => InvoicePatch) patch: InvoicePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Invoice> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const repository = tx.getRepository(Invoice)
     const invoice = await repository.findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await repository.save({
@@ -58,8 +61,8 @@ export class InvoiceMutation {
 
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteInvoice(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteInvoice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(Invoice).delete({ domain, name })
     return true

package/server/service/invoice/invoice-query.ts

@@ -1,8 +1,7 @@
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
 
 import { Invoice } from './invoice'
 import { InvoiceList } from './invoice-types'
@@ -11,7 +10,7 @@ import { InvoiceList } from './invoice-types'
 export class InvoiceQuery {
   @Query(returns => InvoiceList)
   async invoices(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
@@ -28,27 +27,27 @@ export class InvoiceQuery {
   }
 
   @Query(returns => Invoice)
-  async invoice(@Arg('name') name: string, @Ctx() context: any): Promise<Invoice> {
-    const { domain }: { domain: Domain } = context.state
+  async invoice(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Invoice> {
+    const { domain } = context.state
 
     return await getRepository(Invoice).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['domain', 'creator', 'updater']
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() invoice: Invoice): Promise<Domain> {
-    return await getRepository(Domain).findOne(invoice.domainId)
+    return await getRepository(Domain).findOneBy({ id: invoice.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() invoice: Invoice): Promise<User> {
-    return await getRepository(User).findOne(invoice.creatorId)
+    return await getRepository(User).findOneBy({ id: invoice.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() invoice: Invoice): Promise<User> {
-    return await getRepository(User).findOne(invoice.updaterId)
+    return await getRepository(User).findOneBy({ id: invoice.updaterId })
   }
 }

package/server/service/invoice-product/invoice-product-mutation.ts

@@ -9,7 +9,7 @@ export class InvoiceProductMutation {
   @Directive('@transaction')
   async createInvoiceProduct(
     @Arg('invoiceProduct', type => NewInvoiceProduct) invoiceProduct: NewInvoiceProduct,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InvoiceProduct> {
     const { domain, user, tx } = context.state
 
@@ -26,13 +26,13 @@ export class InvoiceProductMutation {
   async updateInvoiceProduct(
     @Arg('name') name: string,
     @Arg('patch', type => InvoiceProductPatch) patch: InvoiceProductPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InvoiceProduct> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(InvoiceProduct)
     const invoiceProduct = await repository.findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await repository.save({
@@ -44,7 +44,7 @@ export class InvoiceProductMutation {
 
   @Mutation(returns => Boolean)
   @Directive('@transaction')
-  async deleteInvoiceProduct(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+  async deleteInvoiceProduct(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(InvoiceProduct).delete({ domain, name })

package/server/service/invoice-product/invoice-product-query.ts

@@ -1,8 +1,7 @@
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
 
 import { InvoiceProduct } from './invoice-product'
 import { InvoiceProductList } from './invoice-product-types'
@@ -11,7 +10,7 @@ import { InvoiceProductList } from './invoice-product-types'
 export class InvoiceProductQuery {
   @Query(returns => InvoiceProductList)
   async invoiceProducts(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
@@ -29,27 +28,27 @@ export class InvoiceProductQuery {
   }
 
   @Query(returns => InvoiceProduct)
-  async invoiceProduct(@Arg('name') name: string, @Ctx() context: any): Promise<InvoiceProduct> {
-    const { domain }: { domain: Domain } = context.state
+  async invoiceProduct(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<InvoiceProduct> {
+    const { domain } = context.state
 
     return await getRepository(InvoiceProduct).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['domain', 'invoice', 'creator', 'updater']
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() invoiceProduct: InvoiceProduct): Promise<Domain> {
-    return await getRepository(Domain).findOne(invoiceProduct.domainId)
+    return await getRepository(Domain).findOneBy({ id: invoiceProduct.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() invoiceProduct: InvoiceProduct): Promise<User> {
-    return await getRepository(User).findOne(invoiceProduct.creatorId)
+    return await getRepository(User).findOneBy({ id: invoiceProduct.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() invoiceProduct: InvoiceProduct): Promise<User> {
-    return await getRepository(User).findOne(invoiceProduct.updaterId)
+    return await getRepository(User).findOneBy({ id: invoiceProduct.updaterId })
   }
 }

package/server/service/job-sheet/job-sheet-mutation.ts

@@ -1,7 +1,9 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, Repository } from 'typeorm'
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
 import { ArrivalNotice, ArrivalNoticePatch, JobSheetPatch } from '../'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
 import { JobSheet } from './job-sheet'
@@ -11,10 +13,10 @@ export class JobSheetMutation {
   @Directive('@transaction')
   @Mutation(returns => JobSheet)
   async generateJobSheet(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('arrivalNotice', type => ArrivalNoticePatch, { nullable: true }) arrivalNotice?: ArrivalNoticePatch
   ): Promise<JobSheet> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
     return await generateJobSheet(domain, user, arrivalNotice, tx)
   }
 
@@ -23,16 +25,16 @@ export class JobSheetMutation {
   async updateJobSheet(
     @Arg('name') name: string,
     @Arg('patch', type => JobSheetPatch) patch: JobSheetPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<JobSheet> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
-    const jobSheet = await tx.getRepository(JobSheet).findOne({ where: { domain, name } })
+    const jobSheet = await tx.getRepository(JobSheet).findOne({ where: { domain: { id: domain.id }, name } })
     if (!jobSheet) throw new Error('No job sheet is found')
 
     const foundGAN: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: jobSheet.arrivalNoticeRefNo
       }
     })
@@ -63,7 +65,7 @@ export async function generateJobSheet(
   let foundJS: JobSheet = null
   if (arrivalNotice?.refNo) {
     foundJS = await jobSheetRepo.findOne({
-      where: { domain, name: arrivalNotice.refNo, bizplace: arrivalNotice.bizplace }
+      where: { domain: { id: domain.id }, name: arrivalNotice.refNo, bizplace: arrivalNotice.bizplace }
     })
   }
 

package/server/service/job-sheet/job-sheet-query.ts

@@ -1,8 +1,10 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
-import { EntityManager, getRepository, SelectQueryBuilder } from 'typeorm'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { ArrivalNotice, JobSheetList } from '../'
 import { JobSheet } from './job-sheet'
 
@@ -11,12 +13,12 @@ export class JobSheetQuery {
   @Directive('@transaction')
   @Query(returns => JobSheetList)
   async jobSheets(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @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<JobSheetList> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
 
     const bizplaceFilter = filters.find(param => param.name === 'bizplaceId')
     const containerNoFilter = filters.find(param => param.name === 'containerNo')
@@ -68,11 +70,14 @@ export class JobSheetQuery {
 
   @Directive('transaction')
   @Query(returns => JobSheet)
-  async jobSheet(@Arg('arrivalNoticeRefNo') arrivalNoticeRefNo: string, @Ctx() context: any): Promise<JobSheet> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async jobSheet(
+    @Arg('arrivalNoticeRefNo') arrivalNoticeRefNo: string,
+    @Ctx() context: ResolverContext
+  ): Promise<JobSheet> {
+    const { domain, tx } = context.state
 
     const jobSheet: JobSheet = await tx.getRepository(JobSheet).findOne({
-      where: { domain, arrivalNoticeRefNo },
+      where: { domain: { id: domain.id }, arrivalNoticeRefNo },
       relations: ['domain', 'bizplace', 'creator', 'updater']
     })
 
@@ -92,16 +97,16 @@ export class JobSheetQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() jobSheet: JobSheet): Promise<Domain> {
-    return await getRepository(Domain).findOne(jobSheet.domainId)
+    return await getRepository(Domain).findOneBy({ id: jobSheet.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() jobSheet: JobSheet): Promise<User> {
-    return await getRepository(User).findOne(jobSheet.creatorId)
+    return await getRepository(User).findOneBy({ id: jobSheet.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() jobSheet: JobSheet): Promise<User> {
-    return await getRepository(User).findOne(jobSheet.updaterId)
+    return await getRepository(User).findOneBy({ id: jobSheet.updaterId })
   }
 }

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

@@ -1,6 +1,8 @@
+import i18next from 'i18next'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Not } from 'typeorm'
 
-import { DISPATCHMENT_STATUS } from '../../constants'
+import { DISPATCHMENT_STATUS, MANIFEST_STATUS } from '../../constants'
 import { OrderNoGenerator } from '../../utils'
 import { ReleaseGood } from '../release-good/release-good'
 import { Manifest, ManifestStatus } from './manifest'
@@ -8,9 +10,55 @@ import { ManifestPatch, NewManifest } from './manifest-type'
 
 @Resolver(Manifest)
 export class ManifestMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To update Manifest' })
+  async updateManifest(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('status', { nullable: true }) status: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Arg('removeOrders', type => [String], { nullable: true }) removeOrders: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    const ManifestRepo = tx.getRepository(Manifest)
+    //update status
+    if (status) {
+      if (status == MANIFEST_STATUS.OPEN) {
+        //check if there is only one manifest is open, if yes update it to in queue and update current to open
+
+        let foundOpenOrder = await ManifestRepo.find({
+          where: { domain: { id: domain.id }, shippingProvider, status: MANIFEST_STATUS.OPEN as any }
+        })
+
+        if (foundOpenOrder.length == 1) {
+          await ManifestRepo.update({ id: foundOpenOrder[0].id }, { status: MANIFEST_STATUS.IN_QUEUE as any })
+        } else if (foundOpenOrder.length > 1) {
+          let manifestNames = foundOpenOrder.map(itm => itm.name)
+          throw new Error(i18next.t('error.Manifest(s) (x) already in open status', { x: manifestNames.toString() }))
+        }
+      }
+
+      await ManifestRepo.update({ id: manifestId }, { status: status as any })
+    }
+
+    //remove orders from manifest
+    if (removeOrders?.length > 0) {
+      //check if user removing all tracking no, if yes then delete
+      let totalTrackingNo = await tx.getRepository(ReleaseGood).count({ where: { manifest: { id: manifestId } } })
+      await tx
+        .getRepository(ReleaseGood)
+        .update({ domain, refNo: In(removeOrders) }, { manifest: null, manifestedBy: null, manifestedAt: null })
+      if (removeOrders.length == totalTrackingNo) {
+        await tx.getRepository(Manifest).delete(manifestId)
+        return false
+      }
+    }
+    return true
+  }
+
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Manifest' })
-  async deleteManifest(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+  async deleteManifest(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Manifest).delete({ domain, name })
@@ -19,7 +67,7 @@ export class ManifestMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To generate new Manifest' })
-  async generateManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: any): Promise<boolean> {
+  async generateManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, user, tx } = context.state
     const manifestItems: any[] = manifest.manifestItems
 
@@ -34,7 +82,7 @@ export class ManifestMutation {
 
       const openManifest: Manifest = await tx
         .getRepository(Manifest)
-        .findOne({ domain, shippingProvider: transporter, status: ManifestStatus.OPEN })
+        .findOneBy({ domain: { id: domain.id }, shippingProvider: transporter, status: ManifestStatus.OPEN })
 
       let manifest: Manifest
 
@@ -53,9 +101,11 @@ export class ManifestMutation {
         items.map(async item => {
           let releaseOrder: ReleaseGood = await tx
             .getRepository(ReleaseGood)
-            .findOne({ domain, refNo: item.refNo, trackingNo: item.trackingNo })
+            .findOneBy({ domain: { id: domain.id }, refNo: item.refNo, trackingNo: item.trackingNo })
           releaseOrder.manifest = manifest
           releaseOrder.updater = user
+          releaseOrder.manifestedBy = user
+          releaseOrder.manifestedAt = new Date()
           await tx.getRepository(ReleaseGood).save(releaseOrder)
         })
       )
@@ -64,21 +114,56 @@ export class ManifestMutation {
     return true
   }
 
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To add tracking no into manifest' })
+  async addTrackingNo(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const releaseGoodRepo = tx.getRepository(ReleaseGood)
+    //check if order belongs to same shipping provider
+    let foundReleaseOrder = await releaseGoodRepo.findOne({ where: { trackingNo }, relations: ['manifest'] })
+
+    if (!foundReleaseOrder) {
+      throw new Error(i18next.t('error.release_order_not_found'))
+    }
+
+    if (foundReleaseOrder.manifest) {
+      throw new Error(i18next.t('error.tracking_no_already_scanned_before'))
+    }
+
+    if (foundReleaseOrder.transporter !== shippingProvider) {
+      throw new Error(i18next.t('error.tracking_no_belongs_to_x', { x: foundReleaseOrder.transporter }))
+    }
+
+    await releaseGoodRepo.update(
+      { id: foundReleaseOrder.id },
+      { manifest: { id: manifestId }, manifestedAt: new Date(), manifestedBy: user }
+    )
+
+    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
+    @Ctx() context: ResolverContext
   ): Promise<Manifest> {
     const { domain, user, tx } = context.state
 
     const manifest: Manifest = await tx.getRepository(Manifest).findOne({
-      where: { domain, name, status: ManifestStatus.OPEN }
+      where: { domain: { id: domain.id }, name, status: Not(MANIFEST_STATUS.CLOSED) as any }
     })
     if (!manifest) throw new Error(`Unable to find ${name}`)
 
-    let releaseGoods: any[] = await tx.getRepository(ReleaseGood).find({ where: { domain, manifest } })
+    let releaseGoods: any[] = await tx
+      .getRepository(ReleaseGood)
+      .find({ where: { domain: { id: domain.id }, manifest: { id: manifest.id } } })
 
     releaseGoods = await Promise.all(
       releaseGoods.map((releaseGood: ReleaseGood) => {