@things-factory/sales-base 4.0.0-y.0 → 4.0.4

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

@@ -0,0 +1,247 @@
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { sendNotification } from '@things-factory/notification'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+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: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    let foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+      where: { domain, 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, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVasOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(VasOrder).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => VasOrder)
+  async generateVasOrder(
+    @Arg('vasOrder', type => NewVasOrder) vasOrder: NewVasOrder,
+    @Ctx() context: any
+  ): Promise<VasOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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).findOne(ov.targetProduct.id)
+        }
+        return {
+          ...ov,
+          domain,
+          name: OrderNoGenerator.orderVas(),
+          vas: await tx.getRepository(Vas).findOne({ domain, 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: any): Promise<VasOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+      where: { domain, 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) {
+      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 }
+      }
+      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: any
+  ): Promise<VasOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      if (!patch.remark) throw new Error('Remark is not exist.')
+
+      const vasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+        where: { domain, 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) {
+        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 }
+        }
+
+        await sendNotification({
+          receivers,
+          message: { ...msg }
+        })
+      }
+
+      return vasOrder
+    } catch (e) {
+      throw e
+    }
+  }
+}

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

@@ -0,0 +1,117 @@
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+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: 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<VasOrderList> {
+    const { domain, user }: { domain: Domain; user: 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: any): Promise<VasOrder> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    return await getRepository(VasOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: 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: 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<VasOrderList> {
+    const { domain, user }: { domain: Domain; user: 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).findOne(vasOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() vasOrder: VasOrder): Promise<User> {
+    return await getRepository(User).findOne(vasOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() vasOrder: VasOrder): Promise<User> {
+    return await getRepository(User).findOne(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
+}

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

@@ -0,0 +1,81 @@
+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,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { OrderVas } from '../'
+
+@Entity()
+@Index('ix_vas-order_0', (vasOrder: VasOrder) => [vasOrder.domain, vasOrder.name], { unique: true })
+@ObjectType()
+export class VasOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((vasOrder: VasOrder) => vasOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((vasOrder: VasOrder) => vasOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.vasOrder)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: String
+
+  @Column()
+  @Field()
+  status: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((vasOrder: VasOrder) => vasOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((vasOrder: VasOrder) => vasOrder.updater)
+  updaterId: string
+}