@things-factory/sales-base 8.0.0-beta.1 → 8.0.0-beta.2

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

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

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

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

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

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

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

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