@things-factory/sales-base 4.3.144 → 4.3.151

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,123 @@
+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 })
+@Index('ix_order_package_1', (orderPackage: OrderPackage) => [orderPackage.releaseGood, orderPackage.packageId], { 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
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  marketRtsCallSuccess: Date
+}

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)
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { OrderPackageItem } from './order-package-item'
+
+@InputType()
+export class NewOrderPackageItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  status?: string
+}
+
+@InputType()
+export class OrderPackageItemPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  releaseQty?: number
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class OrderPackageItemList {
+  @Field(type => [OrderPackageItem])
+  items: OrderPackageItem[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class TrackingInformation {
+  @Field(type => String)
+  trackingNo: string
+
+  @Field(type => String)
+  sku: string
+
+  @Field(type => String)
+  releaseQty: number
+}

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

@@ -0,0 +1,102 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  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 { OrderPackage, OrderProduct } from '../'
+
+@Entity()
+@Index(
+  'ix_order_package_item_0',
+  (orderPackageItem: OrderPackageItem) => [orderPackageItem.domain, orderPackageItem.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for OrderPackageItem' })
+export class OrderPackageItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace?: Bizplace
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.bizplace)
+  bizplaceId?: string
+
+  @ManyToOne(type => OrderPackage)
+  @Field(type => OrderPackage, { nullable: true })
+  orderPackage?: OrderPackage
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.orderPackage)
+  orderPackageId?: string
+
+  @ManyToOne(type => OrderProduct)
+  @Field(type => OrderProduct, { nullable: true })
+  orderProduct?: OrderProduct
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.orderProduct)
+  orderProductId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  status?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  releaseQty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packedQty: number
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((orderPackageItem: OrderPackageItem) => orderPackageItem.creator)
+  updaterId?: string
+}

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

@@ -22,6 +22,7 @@ import { CollectionOrder } from '../collection-order/collection-order'
 import { DeliveryOrder } from '../delivery-order/delivery-order'
 import { DraftReleaseGood } from '../draft-release-good/draft-release-good'
 import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderPackageItem } from '../order-package-item/order-package-item'
 import { PurchaseOrder } from '../purchase-order/purchase-order'
 import { ReleaseGood } from '../release-good/release-good'
 import { RetailReplenishmentOrder } from '../retail-replenishment-order/retail-replenishment-order'
@@ -131,6 +132,10 @@ export class OrderProduct {
   @Field(type => [OrderInventory], { nullable: true })
   orderInventories: OrderInventory
 
+  @OneToMany(type => OrderPackageItem, orderPackageItem => orderPackageItem.orderProduct)
+  @Field(type => [OrderPackageItem], { nullable: true })
+  orderPackageItems: OrderPackageItem[]
+
   @ManyToOne(type => RetailReplenishmentOrder)
   @Field(type => RetailReplenishmentOrder, { nullable: true })
   retailReplenishmentOrder: RetailReplenishmentOrder