@things-factory/sales-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,226 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { OrderByCondition, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { OrderInventory, ReturnOrderDetail, ReturnOrderList } from '../'
+import { ATTACHMENT_TYPE, ORDER_INVENTORY_TYPE, ORDER_STATUS } from '../../constants'
+import { ReturnOrder } from './return-order'
+
+@Resolver(ReturnOrder)
+export class ReturnOrderQuery {
+  @Query(returns => ReturnOrderList)
+  async returnOrders(
+    @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<ReturnOrderList> {
+    try {
+      const { domain, user } = context.state
+
+      filters.push({
+        name: 'bizplaceId',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: false
+      })
+
+      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
+      buildQuery(qb, { filters, pagination, sortings }, context)
+      qb.addSelect(subQuery => {
+        return subQuery
+          .select('COALESCE("ccd".rank, 99999)', 'rank')
+          .from('common_code_details', 'ccd')
+          .innerJoin('ccd.commonCode', 'cc')
+          .where('"ccd"."name" = "ro"."status"')
+          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
+          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
+      }, 'rank')
+      qb.leftJoinAndSelect('ro.domain', 'domain')
+      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('ro.creator', 'creator')
+      qb.leftJoinAndSelect('ro.updater', 'updater')
+      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
+
+      const arrChildSortData = ['bizplace']
+      const sort: OrderByCondition = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Query(returns => ReturnOrder)
+  async returnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { domain } = context.state
+
+    const repository = getRepository(ReturnOrder)
+
+    return await repository.findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => ReturnOrderDetail)
+  async returnOrderDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrderDetail> {
+    const { domain, user } = context.state
+
+    const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
+      where: {
+        domain: { id: domain.id },
+        name
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'orderInventories.inventory.product',
+        'orderInventories.inventory.location',
+        'orderVass',
+        'orderVass.vas',
+        'orderVass.targetProduct',
+        'orderVass.inventory',
+        'creator',
+        'updater'
+      ]
+    })
+
+    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
+      where: {
+        domain: { id: domain.id },
+        refBy: returnOrder.id,
+        category: ATTACHMENT_TYPE.RETURN_ORDER
+      }
+    })
+
+    return {
+      ...(returnOrder as any),
+      attachment: foundAttachments,
+      inventoryInfos: returnOrder.orderInventories
+        .filter(orderInv => orderInv.type === ORDER_INVENTORY_TYPE.RETURN_ORDER)
+        .map((orderInv: OrderInventory) => {
+          const inventory: Inventory = orderInv.inventory
+          return {
+            id: inventory.id,
+            name: inventory.name,
+            batchId: inventory.batchId,
+            palletId: inventory.palletId,
+            product: inventory.product,
+            productName: `${inventory.product.name} (${inventory.product.description})`,
+            packingType: inventory.packingType,
+            packingSize: inventory.packingSize,
+            returnQty: orderInv.returnQty,
+            returnUomValue: orderInv.returnUomValue,
+            status: orderInv.status,
+            remark: orderInv.remark
+          }
+        })
+    }
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ReturnOrderList)
+  async returnOrderRequests(
+    @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<ReturnOrderList> {
+    try {
+      const { domain, user } = context.state
+
+      const statusFilter = filters.some(e => e.name === 'status')
+      const bizplaceFilter = filters.find(param => param.name === 'bizplaceId')
+
+      if (!statusFilter) {
+        filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+
+      if (!bizplaceFilter) {
+        filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
+      buildQuery(qb, { filters, pagination, sortings }, context)
+      qb.addSelect(subQuery => {
+        return subQuery
+          .select('COALESCE("ccd".rank, 99999)', 'rank')
+          .from('common_code_details', 'ccd')
+          .innerJoin('ccd.commonCode', 'cc')
+          .where('"ccd"."name" = "ro"."status"')
+          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
+          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
+      }, 'rank')
+      qb.leftJoinAndSelect('ro.domain', 'domain')
+      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('ro.creator', 'creator')
+      qb.leftJoinAndSelect('ro.updater', 'updater')
+      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
+
+      const arrChildSortData = ['bizplace']
+      const sort: OrderByCondition = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() returnOrder: ReturnOrder): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: returnOrder.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() returnOrder: ReturnOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: returnOrder.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() returnOrder: ReturnOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: returnOrder.updaterId })
+  }
+}

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

@@ -0,0 +1,196 @@
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, BizplacePatch } from '@things-factory/biz-base'
+import { DomainPatch, Domain, ObjectRef } from '@things-factory/shell'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { NewOrderInventory } from '../order-inventory/order-inventory-types'
+import { OrderVas } from '../order-vas/order-vas'
+import { NewOrderVas } from '../order-vas/order-vas-types'
+import { InventoryInfos } from '../release-good/release-good-types'
+import { ReturnOrder } from './return-order'
+
+@ObjectType()
+export class ReturnOrderList {
+  @Field(type => [ReturnOrder], { nullable: true })
+  items: ReturnOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@ObjectType()
+export class ReturnOrderDetail {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  etaDateTime: string
+
+  @Field({ nullable: true })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachment: Attachment[]
+
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @Field({ nullable: true })
+  updatedAt: string
+
+  @Field({ nullable: true })
+  createdAt: string
+
+  @Field(type => [InventoryInfos], { nullable: true })
+  inventoryInfos: InventoryInfos[]
+}
+
+@InputType()
+export class NewReturnOrder {
+  @Field(type => DomainPatch, { nullable: true })
+  domain: DomainPatch
+
+  @Field(type => BizplacePatch, { nullable: true })
+  bizplace: BizplacePatch
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field()
+  @Field({ nullable: false })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Field({ nullable: true })
+  jobSheetNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: NewOrderInventory[]
+
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: NewOrderVas[]
+
+  @Field({ nullable: true })
+  bizplaceName: string
+
+  @Field({ nullable: true })
+  customerBizplaceId: string
+
+  creator?: User
+
+  updater?: User
+}
+
+@InputType()
+export class ReturnOrderPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  jobSheet: ObjectRef
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderInventories: ObjectRef[]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVass: ObjectRef[]
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  status: string
+}

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

@@ -0,0 +1,127 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { JobSheet, OrderInventory, OrderVas } from '../'
+
+@Entity()
+@Index('ix_return-order_0', (returnOrder: ReturnOrder) => [returnOrder.domain, returnOrder.name], { unique: true })
+@ObjectType()
+export class ReturnOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  ownTransport: boolean
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.returnOrder)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.returnOrder)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  eta: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @OneToOne(type => JobSheet)
+  @JoinColumn()
+  @Field(type => JobSheet, { nullable: true })
+  jobSheet: JobSheet
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  acceptedBy: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.acceptedBy)
+  acceptedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  acceptedAt: Date
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,9 @@
+import { ReverseKittingOrder } from './reverse-kitting-order'
+import { ReverseKittingOrderQuery } from './reverse-kitting-order-query'
+import { ReverseKittingOrderMutation } from './reverse-kitting-order-mutation'
+
+export const entities = [ReverseKittingOrder]
+export const resolvers = [ReverseKittingOrderQuery, ReverseKittingOrderMutation]
+
+export * from './reverse-kitting-order-mutation'
+export * from './reverse-kitting-order-query'