@things-factory/sales-base 4.0.7 → 4.0.12

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")')

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,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { Manifest } from './manifest'
+import { NewManifest, ManifestPatch } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Manifest, { description: 'To create new Manifest' })
+  async createManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: any): Promise<Manifest> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Manifest).save({
+      ...manifest,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Manifest, { description: 'To modify Manifest information' })
+  async updateManifest(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ManifestPatch,
+    @Ctx() context: any
+  ): Promise<Manifest> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Manifest)
+    const manifest = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...manifest,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Manifest], { description: "To modify multiple Manifests' information" })
+  async updateMultipleManifest(
+    @Arg('patches', type => [ManifestPatch]) patches: ManifestPatch[],
+    @Ctx() context: any
+  ): Promise<Manifest[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const manifestRepo = tx.getRepository(Manifest)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await manifestRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const manifest = await manifestRepo.findOne(newRecord.id)
+
+        const result = await manifestRepo.save({
+          ...manifest,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Manifest' })
+  async deleteManifest(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Manifest).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple manifests' })
+  async deleteManifests(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Manifest).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Manifest } from './manifest'
+import { ManifestList } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestQuery {
+  @Query(returns => Manifest, { description: 'To fetch a Manifest' })
+  async manifest(@Arg('id') id: string, @Ctx() context: any): Promise<Manifest> {
+    const { domain } = context.state
+
+    return await getRepository(Manifest).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => ManifestList, { description: 'To fetch multiple Manifests' })
+  async manifests(@Args() params: ListParam, @Ctx() context: any): Promise<ManifestList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Manifest).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() manifest: Manifest): Promise<Domain> {
+    return await getRepository(Domain).findOne(manifest.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOne(manifest.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOne(manifest.creatorId)
+  }
+}