@things-factory/sales-base 4.0.0-alpha.9 → 4.0.0-beta.0

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -0,0 +1,300 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { ArrivalNoticeList } from '../'
+import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
+import { ArrivalNotice } from './arrival-notice'
+
+@Resolver(ArrivalNotice)
+export class ArrivalNoticeQuery {
+  @Directive('@privilege(category: "order", privilege: "query")')
+  @Query(returns => ArrivalNotice)
+  async arrivalNotice(
+    @Ctx() context: any,
+    @Arg('name', { nullable: true }) name?: string,
+    @Arg('refNo', { nullable: true }) refNo?: string
+  ): Promise<ArrivalNotice> {
+    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
+
+    let foundGAN: ArrivalNotice
+
+    if (context?.state?.bizplace) {
+      let param: any
+
+      if (name) param = { domain, name, bizplace }
+      else param = { domain, refNo, bizplace }
+
+      foundGAN = await getRepository(ArrivalNotice).findOne({
+        where: { ...param },
+        relations: [
+          'domain',
+          'bizplace',
+          'releaseGood',
+          'purchaseOrder',
+          'purchaseOrder.bufferLocation',
+          'orderProducts',
+          'orderProducts.product',
+          'orderInventories',
+          'orderInventories.inventory',
+          'orderInventories.inventory.product',
+          'orderInventories.inventory.location',
+          'orderVass',
+          'orderVass.vas',
+          'orderVass.targetProduct',
+          'supplier',
+          'creator',
+          'updater'
+        ]
+      })
+    } else {
+      let param: any
+
+      if (name) param = { domain, name, bizplace: In(await getPermittedBizplaceIds(domain, user)) }
+      else param = { domain, refNo, bizplace: In(await getPermittedBizplaceIds(domain, user)) }
+
+      foundGAN = await getRepository(ArrivalNotice).findOne({
+        where: { ...param },
+        relations: [
+          'domain',
+          'bizplace',
+          'releaseGood',
+          'purchaseOrder',
+          'purchaseOrder.bufferLocation',
+          'orderProducts',
+          'orderProducts.product',
+          'orderInventories',
+          'orderInventories.inventory',
+          'orderInventories.inventory.product',
+          'orderInventories.inventory.location',
+          'orderVass',
+          'orderVass.vas',
+          'orderVass.targetProduct',
+          'creator',
+          'updater'
+        ]
+      })
+    }
+
+    if (name && !foundGAN) throw new Error(`Failed to find arrival notice with ${name}`)
+
+    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
+      where: {
+        domain,
+        refBy: foundGAN?.id,
+        category: ATTACHMENT_TYPE.GAN
+      }
+    })
+
+    const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id
+      ? await getRepository(Attachment).find({
+          where: {
+            domain,
+            refBy: foundGAN.purchaseOrder?.id,
+            category: ATTACHMENT_TYPE.PO
+          }
+        })
+      : []
+
+    return {
+      ...foundGAN,
+      attachment: [...foundPOAttachments, ...foundAttachments]
+    }
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "query")')
+  @Query(returns => ArrivalNoticeList)
+  async arrivalNotices(@Ctx() context: any, @Args() params: ListParam): Promise<ArrivalNoticeList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
+      params.filters.push({
+        name: 'bizplaceId',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: false
+      })
+    }
+
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    const qb: SelectQueryBuilder<ArrivalNotice> = getRepository(ArrivalNotice).createQueryBuilder('an')
+    buildQuery(qb, params, context)
+    qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
+    qb.leftJoinAndSelect('an.domain', 'domain')
+    qb.leftJoinAndSelect('an.bizplace', 'bizplace')
+    qb.leftJoinAndSelect('an.releaseGood', 'ro')
+    qb.leftJoinAndSelect('an.creator', 'creator')
+    qb.leftJoinAndSelect('an.updater', 'updater')
+    qb.leftJoinAndSelect('an.acceptedBy', 'accepter')
+    qb.leftJoin(
+      subQuery => {
+        return subQuery
+          .select(`ccd.rank`, 'rank')
+          .addSelect(`ccd.name`, 'status')
+          .from(`common_code_details`, 'ccd')
+          .innerJoin(`ccd.commonCode`, 'cc')
+          .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+          .andWhere(`cc.name = 'ORDER_STATUS'`)
+      },
+      'cc',
+      'cc.status = an.status'
+    )
+
+    const arrChildSortData = ['bizplace']
+    const sort = (params.sortings || []).reduce(
+      (acc, sort) => ({
+        ...acc,
+        [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+      }),
+      !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+    )
+
+    qb.orderBy(sort)
+
+    const [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "query")')
+  @Query(returns => ArrivalNoticeList)
+  async arrivalNoticeRequests(@Args() params: ListParam, @Ctx() context: any): Promise<ArrivalNoticeList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+      const statusFilter = params.filters.some(e => e.name === 'status')
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+
+      if (!statusFilter) {
+        params.filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+      if (fromDateParamIdx >= 0) {
+        let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+        params.filters.splice(fromDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'gte',
+          value: fromDateVal.toISOString(),
+          relation: false
+        })
+      }
+
+      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+      if (toDateParamIdx >= 0) {
+        let toDateVal = new Date(params.filters[toDateParamIdx].value)
+        params.filters.splice(toDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'lt',
+          value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+          relation: false
+        })
+      }
+
+      const qb: SelectQueryBuilder<ArrivalNotice> = getRepository(ArrivalNotice).createQueryBuilder('an')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
+      qb.leftJoinAndSelect('an.domain', 'domain')
+      qb.leftJoinAndSelect('an.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('an.releaseGood', 'ro')
+      qb.leftJoinAndSelect('an.creator', 'creator')
+      qb.leftJoinAndSelect('an.updater', 'updater')
+      qb.leftJoinAndSelect('an.acceptedBy', 'accepter')
+      qb.leftJoin(
+        subQuery => {
+          return subQuery
+            .select(`ccd.rank`, 'rank')
+            .addSelect(`ccd.name`, 'status')
+            .from(`common_code_details`, 'ccd')
+            .innerJoin(`ccd.commonCode`, 'cc')
+            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`cc.name = 'ORDER_STATUS'`)
+        },
+        'cc',
+        'cc.status = an.status'
+      )
+
+      const arrChildSortData = ['bizplace']
+      const sort = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() arrivalNotice: ArrivalNotice): Promise<Domain> {
+    return await getRepository(Domain).findOne(arrivalNotice.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
+    return await getRepository(User).findOne(arrivalNotice.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
+    return await getRepository(User).findOne(arrivalNotice.updaterId)
+  }
+}

package/server/service/arrival-notice/arrival-notice-types.ts

@@ -0,0 +1,173 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { NewOrderProduct } from '../order-product/order-product-types'
+import { NewOrderVas } from '../order-vas/order-vas-types'
+import { ArrivalNotice } from './arrival-notice'
+
+@ObjectType()
+export class ArrivalNoticeList {
+  @Field(type => [ArrivalNotice])
+  items: ArrivalNotice[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@InputType()
+export class NewArrivalNotice {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Field({ nullable: true })
+  container: boolean
+
+  @Field()
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @Field({ nullable: true })
+  importCargo: boolean
+
+  @Field({ nullable: true })
+  looseItem: boolean
+
+  @Field({ nullable: true })
+  ata: string
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field(type => [NewOrderProduct], { nullable: true })
+  orderProducts: NewOrderProduct[]
+
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: NewOrderVas[]
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Field({ nullable: true })
+  containerSize: string
+
+  @Field({ nullable: true })
+  warehouseId: string // outletID
+
+  @Field({ nullable: true })
+  supplier: string
+
+  @Field({ nullable: true })
+  customerBizplaceId: string // customerID
+
+  @Field({ nullable: true })
+  partnerBizplaceId: string
+}
+
+@InputType()
+export class ArrivalNoticePatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Field({ nullable: true })
+  container: boolean
+
+  @Field({ nullable: true })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @Field({ nullable: true })
+  importCargo: boolean
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  ata: string
+
+  @Field({ nullable: true })
+  containerSize: string
+
+  @Field({ nullable: true })
+  looseItem: boolean
+
+  @Field({ nullable: true })
+  fromDate: string
+
+  @Field({ nullable: true })
+  toDate: string
+
+  @Field({ nullable: true })
+  mtDate: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderProducts: ObjectRef[]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVass: ObjectRef[]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  collectionOrders: ObjectRef[]
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+}

package/server/service/arrival-notice/arrival-notice.ts

@@ -0,0 +1,192 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { CollectionOrder, OrderInventory, OrderProduct, OrderVas, PurchaseOrder, ReleaseGood } from '../'
+
+@Entity()
+@Index('ix_arrival-notice_0', (arrivalNotice: ArrivalNotice) => [arrivalNotice.domain, arrivalNotice.name], {
+  unique: true
+})
+@ObjectType()
+export class ArrivalNotice {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain, { nullable: false })
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace, { nullable: false })
+  @Field(type => Bizplace)
+  bizplace: Bizplace
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerSize: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  container: boolean
+
+  @Column()
+  @Field()
+  ownTransport: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @ManyToOne(type => ReleaseGood, { nullable: true })
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood: ReleaseGood
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.releaseGood)
+  releaseGoodId: string
+
+  @Column()
+  @Field()
+  importCargo: boolean
+
+  @OneToMany(type => OrderProduct, orderProduct => orderProduct.arrivalNotice)
+  @Field(type => [OrderProduct], { nullable: true })
+  orderProducts: OrderProduct[]
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.arrivalNotice)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.arrivalNotice)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @OneToMany(type => CollectionOrder, collectionOrder => collectionOrder.arrivalNotice)
+  @Field(type => [CollectionOrder], { nullable: true })
+  collectionOrders: CollectionOrder[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  looseItem: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  eta: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  ata: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Column({ nullable: true })
+  description: string
+
+  @OneToOne(type => PurchaseOrder, { nullable: true })
+  @JoinColumn()
+  @Field(type => [PurchaseOrder], { nullable: true })
+  purchaseOrder: PurchaseOrder
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  acceptedBy: User
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.acceptedBy)
+  acceptedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  acceptedAt: Date
+
+  @ManyToOne(type => ContactPoint, { nullable: true })
+  @Field(type => ContactPoint, { nullable: true })
+  supplier: ContactPoint
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.supplier)
+  supplierId: string
+
+  @Field(type => Attachment, { nullable: true })
+  attachment: Attachment
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((arrivalNotice: ArrivalNotice) => arrivalNotice.updater)
+  updaterId: string
+}

package/server/service/arrival-notice/index.ts

@@ -0,0 +1,6 @@
+import { ArrivalNotice } from './arrival-notice'
+import { ArrivalNoticeMutation } from './arrival-notice-mutation'
+import { ArrivalNoticeQuery } from './arrival-notice-query'
+
+export const entities = [ArrivalNotice]
+export const resolvers = [ArrivalNoticeQuery, ArrivalNoticeMutation]