@things-factory/sales-base 4.2.12 → 4.3.0

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

@@ -0,0 +1,9 @@
+import { OrderTote } from './order-tote'
+import { OrderToteMutation } from './order-tote-mutation'
+import { OrderToteQuery } from './order-tote-query'
+
+export const entities = [OrderTote]
+export const resolvers = [OrderToteQuery, OrderToteMutation]
+
+export * from './order-tote-mutation'
+export * from './order-tote-query'

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

@@ -0,0 +1,30 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+import { OrderTote } from './order-tote'
+
+@Resolver(OrderTote)
+export class OrderToteMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderTote(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderTote).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderTote).delete({
+      domain,
+      id: In(ids)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,114 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In, IsNull } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ReleaseGood } from '../release-good/release-good'
+import { Tote } from '@things-factory/warehouse-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Bizplace } from '@things-factory/biz-base'
+
+import { OrderTote } from './order-tote'
+import { OrderToteList } from './order-tote-types'
+import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+
+@Resolver(OrderTote)
+export class OrderToteQuery {
+  @Query(returns => OrderToteList)
+  async orderTotes(
+    @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<OrderToteList> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+
+      const releaseGoodNoParam = filters.find(item => item.name === 'releaseGoodNo')
+
+      const queryBuilder = await getRepository(OrderTote).createQueryBuilder()
+      buildQuery(queryBuilder, { filters, pagination, sortings }, context)
+
+      queryBuilder
+        .leftJoinAndSelect('OrderTote.domain', 'Domain')
+        .leftJoinAndSelect('OrderTote.releaseGood', 'ReleaseGood')
+        .leftJoinAndSelect('OrderTote.tote', 'Tote')
+        .leftJoinAndSelect('OrderTote.updater', 'Updater')
+        .where('Domain.id = :domainId', { domainId: domain.id })
+
+      if (releaseGoodNoParam) {
+        filters.splice(
+          filters.findIndex(item => item.name == 'releaseGoodNo'),
+          1
+        )
+        queryBuilder.andWhere('ReleaseGood.name = :rgName', { rgName: releaseGoodNoParam.value })
+      }
+
+      let [items, total] = await queryBuilder.getManyAndCount()
+
+      let orderToteIds: string[] = items.map(itm => itm.id)
+
+      let orderToteSeals: OrderToteSeal[] = await getRepository(OrderToteSeal).find({
+        where: { orderTote: In(orderToteIds) }
+      })
+
+      items = items.map((itm: OrderTote) => {
+        return {
+          ...itm,
+          orderToteSeals: orderToteSeals.filter(seal => seal.orderToteId == itm.id)
+        }
+      })
+
+      return { items, total }
+    } catch (e) {
+      throw new Error(e)
+    }
+  }
+
+  @Query(returns => OrderTote)
+  async orderTote(@Arg('id') id: string, @Ctx() context: any): Promise<OrderTote> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderTote).findOne({
+      where: { domain, id },
+      relations: ['domain', 'releaseGood', 'tote', 'updater']
+    })
+  }
+
+  @Query(returns => Boolean)
+  async checkOrderTote(
+    @Arg('name') name: string,
+    @Arg('orderNo') orderNo: string,
+    @Ctx() context: any
+  ): Promise<Boolean> {
+    const { domain }: { domain: Domain } = context.state
+    let foundOrder = await getRepository(ReleaseGood).findOne({
+      where: { name: orderNo, domain },
+      relations: ['bizplace']
+    })
+    let scannedTote = await getRepository(Tote).findOne({ where: { name, bizplace: foundOrder.bizplace } })
+
+    let foundOrderTote = await getRepository(OrderTote).findOne({
+      where: { domain, releaseGood: foundOrder, name },
+      relations: ['domain', 'releaseGood', 'tote', 'updater']
+    })
+
+    if (!foundOrderTote && scannedTote) {
+      let executingOrderTote = await getRepository(OrderTote).find({
+        where: { tote: scannedTote },
+        relations: ['releaseGood']
+      })
+
+      executingOrderTote = executingOrderTote.filter(itm => itm.releaseGood.status !== 'DONE')
+
+      if (executingOrderTote && executingOrderTote.length > 0) {
+        throw new Error(`Current tote is used in another RO (${executingOrderTote[0].releaseGood.name})`)
+      }
+    }
+
+    if (foundOrderTote?.closedDate) {
+      return true
+    } else {
+      return false
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { OrderTote } from './order-tote'
+
+@ObjectType()
+export class OrderToteList {
+  @Field(type => [OrderTote], { nullable: true })
+  items: OrderTote[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewOrderTote {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  tote: ObjectRef
+}
+
+@InputType()
+export class OrderTotePatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  tote: ObjectRef
+}

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

@@ -0,0 +1,62 @@
+import { Field, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Tote } from '@things-factory/warehouse-base'
+import { ReleaseGood } from '../release-good/release-good'
+import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+
+@Entity()
+@Index('ix_order_tote_0', (orderTote: OrderTote) => [orderTote.id], { unique: true })
+@ObjectType()
+export class OrderTote {
+  @PrimaryGeneratedColumn('uuid')
+  @Field()
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field()
+  domain: Domain
+
+  @RelationId((orderTote: OrderTote) => orderTote.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood)
+  releaseGood?: ReleaseGood
+
+  @RelationId((orderTote: OrderTote) => orderTote.releaseGood)
+  releaseGoodId: string
+
+  @ManyToOne(type => Tote)
+  @Field(type => Tote, { nullable: true })
+  tote?: Tote
+
+  @RelationId((orderTote: OrderTote) => orderTote.tote)
+  toteId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  closedDate?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((orderTote: OrderTote) => orderTote.updater)
+  updaterId: string
+
+  @Field(type => [OrderToteSeal], { nullable: true })
+  orderToteSeals?: OrderToteSeal[]
+}

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

@@ -0,0 +1,9 @@
+import { OrderToteItem } from './order-tote-item'
+import { OrderToteItemMutation } from './order-tote-item-mutation'
+import { OrderToteItemQuery } from './order-tote-item-query'
+
+export const entities = [OrderToteItem]
+export const resolvers = [OrderToteItemQuery, OrderToteItemMutation]
+
+export * from './order-tote-item-mutation'
+export * from './order-tote-item-query'

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

@@ -0,0 +1,30 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+import { OrderToteItem } from './order-tote-item'
+
+@Resolver(OrderToteItem)
+export class OrderToteItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteItem(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderToteItem).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderToteItem).delete({
+      domain,
+      id: In(ids)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,88 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderProduct } from '../order-product/order-product'
+import { OrderTote } from '../order-tote/order-tote'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { OrderToteItem } from './order-tote-item'
+import { OrderToteItemList } from './order-tote-item-types'
+import { Tote } from '@things-factory/warehouse-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { ReleaseGood } from '../release-good/release-good'
+import { ProductInput } from '../invoice-product/invoice-product-types'
+
+@Resolver(OrderToteItem)
+export class OrderToteItemQuery {
+  @Query(returns => OrderToteItemList)
+  async orderToteItems(
+    @Ctx() context: any,
+    @Arg('toteNo', type => String) toteNo: String,
+    @Arg('orderNo', type => String) orderNo: String,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<OrderToteItemList> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+
+      const foundOrder: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        where: { name: orderNo, domain }
+      })
+
+      const queryBuilder = getRepository(OrderToteItem).createQueryBuilder()
+      buildQuery(queryBuilder, { sortings }, context)
+
+      queryBuilder
+        .select('OrderToteItem.id', 'id')
+        .addSelect('OrderToteItem.name', 'name')
+        .addSelect('OrderProduct.id', 'orderProductId')
+        .addSelect('OrderProduct.name', 'orderProductName')
+        .addSelect('Domain.id', 'domainId')
+        .addSelect('Domain.name', 'domainName')
+        .addSelect('SUM(OrderToteItem.qty)', 'pickedQty')
+        .addSelect('Product.id', 'productId')
+        .addSelect('Product.sku', 'productSku')
+        .addSelect('Product.packingType', 'packingType')
+        .leftJoin('OrderToteItem.domain', 'Domain')
+        .leftJoin('OrderToteItem.orderProduct', 'OrderProduct')
+        .leftJoin('OrderProduct.product', 'Product')
+        .leftJoin('OrderToteItem.orderTote', 'OrderTote')
+        .where('"OrderTote"."release_good_id" = :foundOrderId', { foundOrderId: foundOrder.id })
+        .andWhere('Domain.id = :domainId', { domainId: domain.id })
+        .andWhere('"OrderTote"."name" = :toteName', { toteName: toteNo })
+        .groupBy('Product.id')
+        .addGroupBy('OrderToteItem.id')
+        .addGroupBy('Domain.id')
+        .addGroupBy('OrderProduct.id')
+
+      const items = await queryBuilder.getRawMany()
+
+      return {
+        items: items.map(itm => {
+          return {
+            ...itm,
+            orderProduct: {
+              id: itm.orderProductId,
+              name: itm.orderProductName,
+              product: { id: itm.productId, sku: itm.productSku, packingType: itm.packingType }
+            },
+            domain: { id: itm.domainId, name: itm.domainName },
+            qty: itm.pickedQty
+          }
+        }),
+        total: items.length
+      }
+    } catch (e) {
+      throw new Error(e)
+    }
+  }
+
+  @Query(returns => OrderToteItem)
+  async orderToteItem(@Arg('id') id: string, @Ctx() context: any): Promise<OrderToteItem> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderToteItem).findOne({
+      where: { domain, id },
+      relations: ['domain', 'orderProduct', 'orderInventory', 'orderTote', 'updater']
+    })
+  }
+}

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

@@ -0,0 +1,56 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { OrderToteItem } from './order-tote-item'
+
+@ObjectType()
+export class OrderToteItemList {
+  @Field(type => [OrderToteItem], { nullable: true })
+  items: OrderToteItem[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewOrderToteItem {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderProduct: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderTote: ObjectRef
+
+  @Field(type => Int)
+  qty: number
+}
+
+@InputType()
+export class OrderToteItemPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderProduct: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderTote: ObjectRef
+
+  @Field(type => Int)
+  qty: number
+}

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

@@ -0,0 +1,72 @@
+import { Field, Int, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { OrderTote } from '../order-tote/order-tote'
+import { OrderProduct } from '../order-product/order-product'
+import { OrderInventory } from '../order-inventory/order-inventory'
+
+@Entity()
+@Index('ix_order_tote_item_0', (orderToteItem: OrderToteItem) => [orderToteItem.name], { unique: true })
+@ObjectType()
+export class OrderToteItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field()
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field()
+  domain: Domain
+
+  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => OrderInventory)
+  @Field(type => OrderInventory)
+  orderInventory?: OrderInventory
+
+  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderInventory)
+  orderInventoryId: string
+
+  @ManyToOne(type => OrderProduct)
+  @Field(type => OrderProduct)
+  orderProduct?: OrderProduct
+
+  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderProduct)
+  orderProductId: string
+
+  @ManyToOne(type => OrderTote)
+  @Field(type => OrderTote, { nullable: true })
+  orderTote?: OrderTote
+
+  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderTote)
+  orderToteId: string
+
+  @Column('int')
+  @Field({ nullable: true })
+  qty?: number
+
+  @Field({ nullable: true })
+  sku?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+
+  @RelationId((orderToteItem: OrderTote) => orderToteItem.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,9 @@
+import { OrderToteSeal } from './order-tote-seal'
+import { OrderToteSealMutation } from './order-tote-seal-mutation'
+import { OrderToteSealQuery } from './order-tote-seal-query'
+
+export const entities = [OrderToteSeal]
+export const resolvers = [OrderToteSealQuery, OrderToteSealMutation]
+
+export * from './order-tote-seal-mutation'
+export * from './order-tote-seal-query'

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

@@ -0,0 +1,30 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+import { OrderToteSeal } from './order-tote-seal'
+
+@Resolver(OrderToteSeal)
+export class OrderToteSealMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteSeal(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderToteSeal).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteSeals(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(OrderToteSeal).delete({
+      domain,
+      id: In(ids)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,60 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderTote } from '../order-tote/order-tote'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
+import { OrderToteSeal } from './order-tote-seal'
+import { OrderToteSealList } from './order-tote-seal-types'
+
+@Resolver(OrderToteSeal)
+export class OrderToteSealQuery {
+  @Query(returns => OrderToteSealList)
+  async orderToteSeals(
+    @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<OrderToteSealList> {
+    const { domain }: { domain: Domain } = context.state
+
+    const queryBuilder = getRepository(OrderToteSeal).createQueryBuilder()
+    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
+
+    queryBuilder
+      .leftJoinAndSelect('OrderToteSeal.domain', 'Domain')
+      .leftJoinAndSelect('OrderToteSeal.orderTote', 'OrderTote')
+      .leftJoinAndSelect('OrderToteSeal.updater', 'Updater')
+      .where('Domain.id = :domainId', { domainId: domain.id })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => OrderToteSeal)
+  async orderToteSeal(@Arg('name') name: string, @Ctx() context: any): Promise<OrderToteSeal> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderToteSeal).findOne({
+      where: { domain, name },
+      relations: ['domain', 'orderTote', 'updater']
+    })
+  }
+
+  @FieldResolver()
+  async domain(@Root() orderToteSeal: OrderToteSeal) {
+    return await getRepository(Domain).findOne(orderToteSeal.domainId)
+  }
+
+  @FieldResolver()
+  async updater(@Root() orderToteSeal: OrderToteSeal) {
+    return await getRepository(User).findOne(orderToteSeal.updaterId)
+  }
+
+  @FieldResolver()
+  async orderTote(@Root() orderToteSeal: OrderToteSeal) {
+    return await getRepository(OrderTote).findOne(orderToteSeal.orderToteId)
+  }
+}

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

@@ -0,0 +1,41 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { OrderToteSeal } from './order-tote-seal'
+
+@ObjectType()
+export class OrderToteSealList {
+  @Field(type => [OrderToteSeal], { nullable: true })
+  items: OrderToteSeal[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewOrderToteSeal {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderTote: ObjectRef
+}
+
+@InputType()
+export class OrderToteSealPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderTote: ObjectRef
+}