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

package/server/service/vas/vas-query.ts

@@ -0,0 +1,60 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
+import { VasList } from '../'
+import { Vas } from './vas'
+
+@Resolver(Vas)
+export class VasQuery {
+  @Directive('@privilege(category: "vas", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => VasList)
+  async vass(
+    @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<VasList> {
+    const qb: SelectQueryBuilder<Vas> = getRepository(Vas).createQueryBuilder()
+    buildQuery(qb, { filters, pagination, sortings }, context)
+
+    const [items, total] = await qb
+      .leftJoinAndSelect('Vas.domain', 'Domain')
+      .leftJoinAndSelect('Vas.creator', 'Creator')
+      .leftJoinAndSelect('Vas.updater', 'Updater')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "query") ')
+  @Query(returns => Vas)
+  async vas(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Vas> {
+    const { domain } = context.state
+
+    return await getRepository(Vas).findOne({
+      where: {
+        domain: { id: domain.id },
+        name
+      },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() vas: Vas): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: vas.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() vas: Vas): Promise<User> {
+    return await getRepository(User).findOneBy({ id: vas.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() vas: Vas): Promise<User> {
+    return await getRepository(User).findOneBy({ id: vas.updaterId })
+  }
+}

package/server/service/vas/vas-types.ts

@@ -0,0 +1,71 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { Vas } from './vas'
+
+@ObjectType()
+export class VasList {
+  @Field(type => [Vas], { nullable: true })
+  items: Vas[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewVas {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => Float)
+  defaultPrice: number
+
+  @Field({ nullable: true })
+  currency: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Field({ nullable: true })
+  operationGuide: string
+}
+
+@InputType()
+export class VasPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  currency: string
+
+  @Field(type => Float, { nullable: true })
+  defaultPrice: number
+
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Field({ nullable: true })
+  operationGuide: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/vas/vas.ts

@@ -0,0 +1,77 @@
+import { User } from '@things-factory/auth-base'
+import { Domain, roundTransformer } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+
+@Entity('vass')
+@Index('ix_vas_0', (vas: Vas) => [vas.domain, vas.name], { unique: true })
+@ObjectType()
+export class Vas {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((vas: Vas) => vas.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  currency: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type: string
+
+  @Column('float', { transformer: roundTransformer })
+  @Field()
+  defaultPrice: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuide: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((vas: Vas) => vas.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((vas: Vas) => vas.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

@@ -0,0 +1,9 @@
+import { VasOrder } from './vas-order'
+import { VasOrderMutation } from './vas-order-mutation'
+import { VasOrderQuery } from './vas-order-query'
+
+export const entities = [VasOrder]
+export const resolvers = [VasOrderQuery, VasOrderMutation]
+
+export * from './vas-order-mutation'
+export * from './vas-order-query'

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

@@ -0,0 +1,259 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Role } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+
+import { NewOrderVas, NewVasOrder, OrderVas, Vas, VasOrderPatch } from '../'
+import { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { VasOrder } from './vas-order'
+
+@Resolver(VasOrder)
+export class VasOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    let foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['orderVass', 'creator', 'updater']
+    })
+
+    if (!foundVasOrder) throw new Error(`Vas order doesn't exists.`)
+    const foundOVs: OrderVas[] = foundVasOrder.orderVass
+
+    // 1. delete order vass
+    const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
+    if (vasIds.length) {
+      await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
+    }
+
+    await tx.getRepository(VasOrder).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVasOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    await tx.getRepository(VasOrder).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => VasOrder)
+  async generateVasOrder(
+    @Arg('vasOrder', type => NewVasOrder) vasOrder: NewVasOrder,
+    @Ctx() context: ResolverContext
+  ): Promise<VasOrder> {
+    const { tx, domain, user } = context.state
+
+    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+      where: {
+        id: vasOrder.customerBizplaceId
+      }
+    })
+
+    if (!customerBizplace) throw new Error('company is not found')
+
+    let orderVass: NewOrderVas[] = vasOrder.orderVass
+
+    // 1. Create vas order
+    const createdVasOrder: VasOrder = await tx.getRepository(VasOrder).save({
+      ...vasOrder,
+      name: OrderNoGenerator.vasOrder(),
+      domain,
+      bizplace: customerBizplace,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    })
+
+    // 2. Create VasOrder vas
+    orderVass = await Promise.all(
+      orderVass.map(async (ov: OrderVas) => {
+        if (ov?.targetProduct?.id) {
+          ov.targetProduct = await tx.getRepository(Product).findOneBy({ id: ov.targetProduct.id })
+        }
+        return {
+          ...ov,
+          domain,
+          name: OrderNoGenerator.orderVas(),
+          vas: await tx.getRepository(Vas).findOneBy({ domain: { id: domain.id }, id: ov.vas.id }),
+          vasOrder: createdVasOrder,
+          bizplace: customerBizplace,
+          type: ORDER_TYPES.VAS_ORDER,
+          status: ORDER_VAS_STATUS.PENDING,
+          creator: user,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(OrderVas).save(orderVass)
+
+    return createdVasOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => VasOrder)
+  async confirmVasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<VasOrder> {
+    const { tx, domain, user } = context.state
+
+    const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['bizplace', 'orderVass', 'orderVass.vas', 'creator', 'updater']
+    })
+
+    let vasOrder: VasOrder
+    let customerBizplace: Bizplace = foundVasOrder.bizplace
+    const foundOrderVass: OrderVas[] = foundVasOrder.orderVass
+
+    if (!foundVasOrder) throw new Error(`Vas order doesn't exists.`)
+    if (foundVasOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
+    if (!foundOrderVass) throw new Error(`Order Vas doesn't exist`)
+
+    // 1. Update status of Order Vas (PENDING => PENDING_RECEIVE)
+    foundOrderVass.forEach(async orderVas => {
+      await tx.getRepository(OrderVas).save({
+        ...orderVas,
+        status: ORDER_VAS_STATUS.PENDING_RECEIVE,
+        updater: user
+      })
+    })
+
+    // 2. Vas Order Status change (PENDING => PENDING_RECEIVE)
+    vasOrder = await tx.getRepository(VasOrder).save({
+      ...foundVasOrder,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+
+    // notification logics
+    // get Office Admin Users
+    const users: any[] = await tx
+      .getRepository('users_roles')
+      .createQueryBuilder('ur')
+      .select('ur.users_id', 'id')
+      .where(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select('role.id')
+          .from(Role, 'role')
+          .where("role.name = 'Office Admin'")
+          .andWhere('role.domain_id = :domain', { domain: context.state.domain.id })
+          .getQuery()
+        return 'ur.roles_id IN ' + subQuery
+      })
+      .getRawMany()
+
+    // send notification to Office Admin Users
+    if (users?.length && context.header?.referer) {
+      const receivers: any[] = users.map(user => user.id)
+      const msg = {
+        title: `New VAS Order from ${customerBizplace.name}`,
+        body: `New incoming order, ${foundVasOrder.name} is pending for receiving`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      }
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
+    }
+
+    return vasOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => VasOrder)
+  async rejectVasOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => VasOrderPatch) patch: VasOrderPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<VasOrder> {
+    try {
+      const { tx, domain, user } = context.state
+      if (!patch.remark) throw new Error('Remark is not exist.')
+
+      const vasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+        where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
+        relations: ['bizplace', 'orderVass']
+      })
+      if (!vasOrder) throw new Error(`Vas order doesn't exists.`)
+
+      // 1. Update status of order vass (PENDING_RECEIVE => REJECTED)
+      const orderVass: OrderVas[] = vasOrder.orderVass.map((orderVas: OrderVas) => {
+        return {
+          ...orderVas,
+          status: ORDER_VAS_STATUS.REJECTED,
+          updater: user
+        }
+      })
+      await tx.getRepository(OrderVas).save(orderVass)
+
+      await tx.getRepository(VasOrder).save({
+        ...vasOrder,
+        ...patch,
+        status: ORDER_STATUS.REJECTED,
+        updater: user
+      })
+
+      // notification logics
+      // get Office Admin Users
+      const users: any[] = await tx
+        .getRepository('users_roles')
+        .createQueryBuilder('ur')
+        .select('ur.users_id', 'id')
+        .where(qb => {
+          const subQuery = qb
+            .subQuery()
+            .select('role.id')
+            .from(Role, 'role')
+            .where("role.name = 'Office Admin'")
+            .andWhere('role.domain_id = :domain', { domain: domain.id })
+            .getQuery()
+          return 'ur.roles_id IN ' + subQuery
+        })
+        .getRawMany()
+
+      // send notification to Customer Users
+      if (users?.length && context.header?.referer) {
+        const receivers: any[] = users.map(user => user.id)
+        const msg = {
+          title: `Latest status for ${vasOrder.name}`,
+          body: `Your VAS order has been rejected.`,
+          url: context.header.referer,
+          data: { url: context.header.referer }
+        }
+
+        /**
+         * @notes Temporary off sendNotification due to suspect of causing wms down
+         */
+
+        // await sendNotification({
+        //   receivers,
+        //   message: { ...msg }
+        // })
+      }
+
+      return vasOrder
+    } catch (e) {
+      throw e
+    }
+  }
+}

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

@@ -0,0 +1,119 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
+import { VasOrderList } from '../'
+import { ORDER_STATUS } from '../../constants'
+import { VasOrder } from './vas-order'
+
+@Resolver(VasOrder)
+export class VasOrderQuery {
+  @Query(returns => VasOrderList)
+  async vasOrders(
+    @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<VasOrderList> {
+    const { domain, user } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(VasOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'bizplace',
+        'orderVass',
+        'orderVass.inventory',
+        'orderVass.inventory.product',
+        'creator',
+        'updater'
+      ]
+    })
+    return { items, total }
+  }
+
+  @Query(returns => VasOrder)
+  async vasOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<VasOrder> {
+    const { domain, user } = context.state
+
+    return await getRepository(VasOrder).findOne({
+      where: {
+        domain: { id: domain.id },
+        name,
+        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'orderVass',
+        'orderVass.vas',
+        'orderVass.inventory',
+        'orderVass.inventory.product',
+        'orderVass.inventory.location',
+        'orderVass.inventory.warehouse',
+        'orderVass.targetProduct',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+
+  @Query(returns => VasOrderList)
+  async vasOrderRequests(
+    @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<VasOrderList> {
+    const { domain, user } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+
+    if (!convertedParams.where || !convertedParams.where.status) {
+      convertedParams.where.status = In([
+        ORDER_STATUS.PENDING_RECEIVE,
+        ORDER_STATUS.READY_TO_EXECUTE,
+        ORDER_STATUS.DONE,
+        ORDER_STATUS.EXECUTING,
+        ORDER_STATUS.REJECTED
+      ])
+    }
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(VasOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'bizplace',
+        'orderVass',
+        'orderVass.inventory',
+        'orderVass.inventory.product',
+        'creator',
+        'updater'
+      ]
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() vasOrder: VasOrder): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: vasOrder.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() vasOrder: VasOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: vasOrder.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() vasOrder: VasOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: vasOrder.updaterId })
+  }
+}

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

@@ -0,0 +1,49 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { NewOrderVas } from '../order-vas/order-vas-types'
+import { VasOrder } from './vas-order'
+
+@ObjectType()
+export class VasOrderList {
+  @Field(type => [VasOrder], { nullable: true })
+  items: VasOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewVasOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  customerBizplaceId: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: [NewOrderVas]
+
+  @Field({ nullable: true })
+  status: string
+}
+
+@InputType()
+export class VasOrderPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  orderVass: [ObjectRef]
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  remark: string
+}