@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,226 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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'