@things-factory/sales-base 4.3.143 → 4.3.146

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

@@ -2,8 +2,9 @@ import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graph
 import { getRepository, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam, buildQuery, Sorting } from '@things-factory/shell'
+import { buildQuery, Domain, ListParam, Sorting } from '@things-factory/shell'
 
+import { OrderPackage } from '../order-package/order-package'
 import { ReleaseGood } from '../release-good/release-good'
 import { Manifest } from './manifest'
 import { ManifestList } from './manifest-type'
@@ -16,37 +17,26 @@ export class ManifestQuery {
     @Ctx() context: any,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<Manifest> {
-    const phoneSort = sortings.findIndex(sort => sort.name === 'phone')
-    if (phoneSort >= 0) {
-      sortings[phoneSort].name = 'phone1'
-    }
-
-    const deliveryAddressSort = sortings.findIndex(sort => sort.name === 'deliveryAddress')
-    if (deliveryAddressSort >= 0) {
-      sortings[deliveryAddressSort].name = 'deliveryAddress1'
-    }
-
-    const orderRemarkSort = sortings.findIndex(sort => sort.name === 'orderRemark')
-    if (orderRemarkSort >= 0) {
-      sortings[orderRemarkSort].name = 'remark'
-    }
-
-    const orderStatusSort = sortings.findIndex(sort => sort.name === 'orderStatus')
-    if (orderStatusSort >= 0) {
-      sortings[orderStatusSort].name = 'status'
-    }
-    const convertedParams = convertListParams({ sortings })
     const { domain, tx } = context.state
     const manifest: Manifest = await getRepository(Manifest).findOne({ where: { domain, name } })
 
-    const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
-      ...convertedParams,
-      where: { manifest }
-    })
+    let qb: any = getRepository(OrderPackage).createQueryBuilder('opk')
+    qb.innerJoinAndSelect('opk.releaseGood', 'rg').where('opk.manifest_id = :manifestId', { manifestId: manifest.id })
+    const sort = (sortings || []).reduce(
+      (acc, sort) => ({
+        ...acc,
+        [sort.name]: sort.desc ? 'DESC' : 'ASC'
+      }),
+      {}
+    )
+    qb.orderBy(sort)
+
+    const orderPackages: OrderPackage[] = await qb.getMany()
 
-    const trackingNos: any[] = releaseGoods.map(releaseGood => {
+    const trackingNos: any[] = orderPackages.map(opk => {
+      const releaseGood: ReleaseGood = opk.releaseGood
       return {
-        trackingNo: releaseGood.trackingNo,
+        trackingNo: opk.trackingNo,
         refNo: releaseGood.refNo,
         deliveryAddress: releaseGood.deliveryAddress1,
         attentionTo: releaseGood.attentionTo,
@@ -113,20 +103,22 @@ export class ManifestQuery {
 
     const qb: SelectQueryBuilder<Manifest> = getRepository(Manifest).createQueryBuilder('mf')
     buildQuery(qb, params, context)
-    qb.innerJoin('release_goods', 'rg', 'rg.manifest_id = mf.id')
+    qb.innerJoin('order_packages', 'op', 'op.manifest_id = mf.id')
+    qb.innerJoin('op.releaseGood', 'rg')
+    // qb.innerJoin('release_goods', 'rg', 'rg.manifest_id = mf.id')
     orderInfoFilter
       ? qb.andWhere(
           '(rg.name ~* :orderInfoFilter or rg.ref_no ~* :orderInfoFilter or rg.ref_no_2 ~* :orderInfoFilter or rg.ref_no_3 ~* :orderInfoFilter)',
           { orderInfoFilter }
         )
       : ''
-    trackingNoFilter ? qb.andWhere('rg.tracking_no ilike :trackingNo', { trackingNo: trackingNoFilter }) : ''
+    trackingNoFilter ? qb.andWhere('op.tracking_no ilike :trackingNo', { trackingNo: trackingNoFilter }) : ''
 
     const [items, total] = await qb.getManyAndCount()
 
     await Promise.all(
       items.map(async item => {
-        item.totalTrackingNo = await getRepository(ReleaseGood).count({ where: { manifest: item.id } })
+        item.totalTrackingNo = await getRepository(OrderPackage).count({ where: { manifest: item.id } })
       })
     )
     return { items, total }

package/server/service/order-package/index.ts

@@ -0,0 +1,6 @@
+import { OrderPackage } from './order-package'
+import { OrderPackageQuery } from './order-package-query'
+import { OrderPackageMutation } from './order-package-mutation'
+
+export const entities = [OrderPackage]
+export const resolvers = [OrderPackageQuery, OrderPackageMutation]

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

@@ -0,0 +1,113 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { OrderPackage } from './order-package'
+import { NewOrderPackage, OrderPackagePatch } from './order-package-types'
+
+@Resolver(OrderPackage)
+export class OrderPackageMutation {
+  @Directive('@transaction')
+  @Mutation(returns => OrderPackage, { description: 'To create new OrderPackage' })
+  async createOrderPackage(
+    @Arg('orderPackage') orderPackage: NewOrderPackage,
+    @Ctx() context: any
+  ): Promise<OrderPackage> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(OrderPackage).save({
+      ...orderPackage,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => OrderPackage, { description: 'To modify OrderPackage information' })
+  async updateOrderPackage(
+    @Arg('id') id: string,
+    @Arg('patch') patch: OrderPackagePatch,
+    @Ctx() context: any
+  ): Promise<OrderPackage> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(OrderPackage)
+    const orderPackage = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...orderPackage,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [OrderPackage], { description: "To modify multiple OrderPackages' information" })
+  async updateMultipleOrderPackage(
+    @Arg('patches', type => [OrderPackagePatch]) patches: OrderPackagePatch[],
+    @Ctx() context: any
+  ): Promise<OrderPackage[]> {
+    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 orderPackageRepo = tx.getRepository(OrderPackage)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await orderPackageRepo.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 orderPackage = await orderPackageRepo.findOne(newRecord.id)
+
+        const result = await orderPackageRepo.save({
+          ...orderPackage,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete OrderPackage' })
+  async deleteOrderPackage(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderPackage).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple orderPackages' })
+  async deleteOrderPackages(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderPackage).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,86 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
+import { OrderPackage } from './order-package'
+import { OrderPackageList } from './order-package-types'
+
+@Resolver(OrderPackage)
+export class OrderPackageQuery {
+  @Query(returns => OrderPackage, { description: 'To fetch a OrderPackage' })
+  async orderPackage(
+    @Ctx() context: any,
+    @Arg('id', { nullable: true }) id: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string
+  ): Promise<OrderPackage> {
+    const { domain, user } = context.state
+
+    if (id) {
+      return await getRepository(OrderPackage).findOne({
+        where: { domain, id }
+      })
+    } else if (trackingNo) {
+      let orderPackage = await getRepository(OrderPackage).findOne({
+        where: {
+          domain,
+          trackingNo,
+          bizplace: In(await getPermittedBizplaceIds(domain, user))
+        },
+        relations: ['bizplace', 'releaseGood']
+      })
+
+      if (!orderPackage) {
+        throw new Error('Tracking No not found in any orders')
+      } else {
+        return orderPackage
+      }
+    }
+  }
+
+  @Query(returns => OrderPackageList, { description: 'To fetch multiple OrderPackages' })
+  async orderPackages(
+    @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<OrderPackageList> {
+    const { domain } = context.state
+
+    const bizplaceIdParam = filters.find(item => item.name === 'bizplaceId')
+    const releaseGoodIdParam = filters.find(item => item.name === 'releaseGoodId')
+
+    let qb = getRepository(OrderPackage)
+      .createQueryBuilder('opk')
+      .where('opk.domain_id = :domainId', { domainId: domain.id })
+
+    if (bizplaceIdParam) {
+      qb.andWhere('opk.bizplace_id = :bizplaceId', { bizplaceId: bizplaceIdParam.value })
+    }
+
+    if (releaseGoodIdParam) {
+      qb.andWhere('opk.release_good_id = :releaseGoodId', { releaseGoodId: releaseGoodIdParam.value })
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() orderPackage: OrderPackage): Promise<Domain> {
+    return await getRepository(Domain).findOne(orderPackage.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() orderPackage: OrderPackage): Promise<User> {
+    return await getRepository(User).findOne(orderPackage.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() orderPackage: OrderPackage): Promise<User> {
+    return await getRepository(User).findOne(orderPackage.creatorId)
+  }
+}

package/server/service/order-package/order-package-types.ts

@@ -0,0 +1,66 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { OrderPackage } from './order-package'
+
+@InputType()
+export class NewOrderPackage {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  packageId: string
+
+  @Field({ nullable: true })
+  transporter: string
+
+  @Field({ nullable: true })
+  trackingNo: string
+
+  @Field({ nullable: true })
+  airwayBill: string
+
+  @Field({ nullable: true })
+  invoice: string
+
+  @Field({ nullable: true })
+  status?: string
+}
+
+@InputType()
+export class OrderPackagePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  packageId: string
+
+  @Field({ nullable: true })
+  transporter: string
+
+  @Field({ nullable: true })
+  trackingNo: string
+
+  @Field({ nullable: true })
+  airwayBill: string
+
+  @Field({ nullable: true })
+  invoice: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class OrderPackageList {
+  @Field(type => [OrderPackage])
+  items: OrderPackage[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,118 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Manifest, OrderPackageItem, ReleaseGood } from '../'
+
+@Entity()
+@Index('ix_order_package_0', (orderPackage: OrderPackage) => [orderPackage.domain, orderPackage.name], { unique: true })
+@ObjectType({ description: 'Entity for OrderPackage' })
+export class OrderPackage {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((orderPackage: OrderPackage) => orderPackage.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @RelationId((orderPackage: OrderPackage) => orderPackage.bizplace)
+  bizplaceId?: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood?: ReleaseGood
+
+  @ManyToOne(type => Manifest)
+  @Field(type => Manifest, { nullable: true })
+  manifest: Manifest
+
+  @OneToMany(type => OrderPackageItem, orderPackageItem => orderPackageItem.orderPackage)
+  @Field(type => [OrderPackageItem], { nullable: true })
+  orderPackageItems: OrderPackageItem[]
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packageId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  transporter: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  trackingNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  airwayBill: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  invoice: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  manifestedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  manifestedBy: User
+
+  @RelationId((orderPackage: OrderPackage) => orderPackage.manifestedBy)
+  manifestedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((orderPackage: OrderPackage) => orderPackage.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((orderPackage: OrderPackage) => orderPackage.creator)
+  updaterId?: string
+}

package/server/service/order-package-item/index.ts

@@ -0,0 +1,6 @@
+import { OrderPackageItem } from './order-package-item'
+import { OrderPackageItemQuery } from './order-package-item-query'
+import { OrderPackageItemMutation } from './order-package-item-mutation'
+
+export const entities = [OrderPackageItem]
+export const resolvers = [OrderPackageItemQuery, OrderPackageItemMutation]

package/server/service/order-package-item/order-package-item-mutation.ts

@@ -0,0 +1,113 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { OrderPackageItem } from './order-package-item'
+import { NewOrderPackageItem, OrderPackageItemPatch } from './order-package-item-types'
+
+@Resolver(OrderPackageItem)
+export class OrderPackageItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => OrderPackageItem, { description: 'To create new OrderPackageItem' })
+  async createOrderPackageItem(
+    @Arg('orderPackageItem') orderPackageItem: NewOrderPackageItem,
+    @Ctx() context: any
+  ): Promise<OrderPackageItem> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(OrderPackageItem).save({
+      ...orderPackageItem,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => OrderPackageItem, { description: 'To modify OrderPackageItem information' })
+  async updateOrderPackageItem(
+    @Arg('id') id: string,
+    @Arg('patch') patch: OrderPackageItemPatch,
+    @Ctx() context: any
+  ): Promise<OrderPackageItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(OrderPackageItem)
+    const orderPackageItem = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...orderPackageItem,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [OrderPackageItem], { description: "To modify multiple OrderPackageItems' information" })
+  async updateMultipleOrderPackageItem(
+    @Arg('patches', type => [OrderPackageItemPatch]) patches: OrderPackageItemPatch[],
+    @Ctx() context: any
+  ): Promise<OrderPackageItem[]> {
+    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 orderPackageItemRepo = tx.getRepository(OrderPackageItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await orderPackageItemRepo.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 orderPackageItem = await orderPackageItemRepo.findOne(newRecord.id)
+
+        const result = await orderPackageItemRepo.save({
+          ...orderPackageItem,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete OrderPackageItem' })
+  async deleteOrderPackageItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderPackageItem).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple orderPackageItems' })
+  async deleteOrderPackageItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderPackageItem).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,89 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, ListParam } from '@things-factory/shell'
+
+import { OrderPackageItem } from './order-package-item'
+import { OrderPackageItemList, TrackingInformation } from './order-package-item-types'
+
+@Resolver(OrderPackageItem)
+export class OrderPackageItemQuery {
+  @Query(returns => OrderPackageItem, { description: 'To fetch a OrderPackageItem' })
+  async orderPackageItem(@Arg('id') id: string, @Ctx() context: any): Promise<OrderPackageItem> {
+    const { domain } = context.state
+
+    return await getRepository(OrderPackageItem).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => OrderPackageItemList, { description: 'To fetch multiple OrderPackageItems' })
+  async orderPackageItems(@Args() params: ListParam, @Ctx() context: any): Promise<OrderPackageItemList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(OrderPackageItem).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @Query(returns => [TrackingInformation], { description: 'To fetch multiple OrderPackageItems' })
+  async orderPackageItemsGroup(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[]
+  ): Promise<TrackingInformation[]> {
+    const { domain } = context.state
+
+    const bizplaceIdParam = filters.find(item => item.name === 'bizplaceId')
+    const releaseGoodIdParam = filters.find(item => item.name === 'releaseGoodId')
+
+    let qb = getRepository(OrderPackageItem)
+      .createQueryBuilder('opki')
+      .select('opk.tracking_no', 'trackingNo')
+      .addSelect('prd.sku', 'sku')
+      .addSelect('SUM(opki.release_qty)', 'releaseQty')
+      .innerJoin('opki.orderPackage', 'opk')
+      .innerJoin('opki.orderProduct', 'op')
+      .innerJoin('op.product', 'prd')
+      .where('opk.domain_id = :domainId', { domainId: domain.id })
+
+    if (bizplaceIdParam) {
+      qb.andWhere('opk.bizplace_id = :bizplaceId', { bizplaceId: bizplaceIdParam.value })
+    }
+
+    if (releaseGoodIdParam) {
+      qb.andWhere('opk.release_good_id = :releaseGoodId', { releaseGoodId: releaseGoodIdParam.value })
+    }
+
+    qb.groupBy('opk.trackingNo')
+    qb.addGroupBy('prd.sku')
+
+    let qbResult: any[] = await qb.getRawMany()
+
+    let items: any = qbResult.map(itm => {
+      return {
+        trackingNo: itm.trackingNo,
+        sku: itm.sku,
+        releaseQty: itm.releaseQty
+      }
+    })
+
+    return items
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() orderPackageItem: OrderPackageItem): Promise<Domain> {
+    return await getRepository(Domain).findOne(orderPackageItem.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() orderPackageItem: OrderPackageItem): Promise<User> {
+    return await getRepository(User).findOne(orderPackageItem.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() orderPackageItem: OrderPackageItem): Promise<User> {
+    return await getRepository(User).findOne(orderPackageItem.creatorId)
+  }
+}