@things-factory/product-base 8.0.0 → 9.0.0-beta.3

package/server/service/product-bundle/product-bundle-mutation.ts

@@ -1,140 +0,0 @@
-import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
-import { In, Repository } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { getRepository } from '@things-factory/shell'
-
-import { PRODUCT_BUNDLE_STATUS } from '../../constants'
-import { ProductBundle } from './product-bundle'
-import { NewProductBundle, ProductBundlePatch } from './product-bundle-types'
-
-@Resolver(ProductBundle)
-export class ProductBundleMutation {
-  @Mutation(returns => ProductBundle)
-  async createProductBundle(
-    @Arg('productBundle') productBundle: NewProductBundle,
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundle> {
-    const { domain, user } = context.state
-
-    return await getRepository(ProductBundle).save({
-      ...productBundle,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Mutation(returns => ProductBundle)
-  async updateProductBundle(
-    @Arg('name') name: string,
-    @Arg('patch') patch: ProductBundlePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundle> {
-    const { domain, user } = context.state
-
-    const repository = getRepository(ProductBundle)
-    const productBundle = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...productBundle,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Mutation(returns => [ProductBundle])
-  async updateMultipleProductBundle(
-    @Arg('patches', type => [ProductBundlePatch]) patches: ProductBundlePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundle[]> {
-    const { domain, user } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const productBundleRepo = getRepository(ProductBundle)
-    const bizplaceRepo = getRepository(Bizplace)
-
-    let bizplace: Bizplace
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        let newRecord = _createRecords[i]
-        let status = newRecord.status || ''
-
-        bizplace = await bizplaceRepo.findOne({ where: { name: domain.name } })
-
-        if (!newRecord.status || newRecord.status === '') {
-          newRecord.status = PRODUCT_BUNDLE_STATUS.INACTIVE
-        }
-
-        const result = await productBundleRepo.save({
-          ...newRecord,
-          domain,
-          bizplace,
-          status: newRecord.status.toUpperCase(),
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const productBundle = await productBundleRepo.findOneBy({ domain: { id: domain.id }, id: newRecord.id })
-
-        if (newRecord.status) {
-          newRecord.status = newRecord.status.toUpperCase()
-        }
-
-        const result = await productBundleRepo.save({
-          ...productBundle,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteProductBundle(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user } = context.state
-
-    await getRepository(ProductBundle).delete({ domain: { id: domain.id }, name })
-
-    return true
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteProductBundles(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { tx, user } = context.state
-    const productBundleRepo: Repository<ProductBundle> = getRepository(ProductBundle) || tx.getRepository(ProductBundle)
-
-    let productBundles = await productBundleRepo.find({ where: { id: In(ids) } })
-
-    for (let i = 0; i < productBundles.length; i++) {
-      const product = productBundles[i]
-
-      const result = await productBundleRepo.save({
-        ...product,
-        status: PRODUCT_BUNDLE_STATUS.DELETED,
-        updater: user
-      })
-    }
-
-    return true
-  }
-}

package/server/service/product-bundle/product-bundle-query.ts

@@ -1,104 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, SelectQueryBuilder } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { buildCondition, buildQuery, convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { PRODUCT_BUNDLE_STATUS } from '../../constants'
-import { ProductBundle } from './product-bundle'
-import { ProductBundleList } from './product-bundle-types'
-
-@Resolver(ProductBundle)
-export class ProductBundleQuery {
-  @Query(returns => ProductBundleList)
-  async myBizplaceProductBundles(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundleList> {
-    const { domain } = context.state
-
-    const qb: SelectQueryBuilder<ProductBundle> = getRepository(ProductBundle).createQueryBuilder()
-
-    const productBundleFilter = params.filters.find(x => x.name == 'product_info')
-    const productFilterColumns = ['sku', 'name', 'description']
-    let filters = params.filters.filter(x => x.name != 'product_info')
-
-    // add status filter to prevent user to see DELETED product bundles
-    filters = [...filters, { name: 'status', operator: 'noteq', value: PRODUCT_BUNDLE_STATUS.DELETED }]
-
-    if (!params.filters.find(filter => filter.name === 'bizplace_id')) {
-      let bizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { domain: { id: domain.id } } })
-      params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [bizplace.id] }]
-    }
-
-    buildQuery(qb, params, context, { domainRef: false })
-    if (productBundleFilter) {
-      qb.andWhere(
-        new Brackets(qb2 => {
-          productFilterColumns.forEach(filter => {
-            const condition = buildCondition(
-              qb.alias,
-              filter,
-              productBundleFilter.operator,
-              productBundleFilter.value,
-              productBundleFilter.relation,
-              Object.keys(qb.getParameters()).length
-            )
-
-            qb2.orWhere(condition.clause, condition.parameters)
-          })
-        })
-      )
-    }
-
-    const [items, total] = await qb
-      .leftJoinAndSelect('ProductBundle.productBundleSettings', 'ProductBundleSetting')
-      .leftJoinAndSelect('ProductBundleSetting.product', 'Product')
-      .leftJoinAndSelect('ProductBundleSetting.productDetail', 'ProductDetail')
-      .leftJoinAndSelect('ProductBundle.bizplace', 'Bizplace')
-      .leftJoinAndSelect('ProductBundle.creator', 'Creator')
-      .leftJoinAndSelect('ProductBundle.updater', 'Updater')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => ProductBundleList)
-  async productBundles(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundleList> {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(ProductBundle).findAndCount({
-      ...convertedParams
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => ProductBundle)
-  async productBundle(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ProductBundle> {
-    const { domain, user } = context.state
-    const repository = getRepository(ProductBundle)
-
-    return await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() productBundle: ProductBundle): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: productBundle.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() productBundle: ProductBundle): Promise<User> {
-    return await getRepository(User).findOneBy({ id: productBundle.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() productBundle: ProductBundle): Promise<User> {
-    return await getRepository(User).findOneBy({ id: productBundle.updaterId })
-  }
-}

package/server/service/product-bundle/product-bundle-types.ts

@@ -1,51 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ProductBundle } from './product-bundle'
-
-@InputType()
-export class NewProductBundle {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@ObjectType()
-export class ProductBundleList {
-  @Field(type => [ProductBundle], { nullable: true })
-  items?: ProductBundle[]
-
-  @Field(type => Int, { nullable: true })
-  total?: number
-}
-
-@InputType()
-export class ProductBundlePatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  sku?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  refCode?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field({ nullable: true })
-  packingType?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}

package/server/service/product-bundle/product-bundle.ts

@@ -1,102 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain, roundTransformer } from '@things-factory/shell'
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-import { ProductBundleSetting } from '../product-bundle-setting/product-bundle-setting'
-
-@Entity()
-@Index('ix_product_bundle_0', (productBundle: ProductBundle) => [productBundle.domain, productBundle.id], {
-  unique: true
-})
-@ObjectType()
-export class ProductBundle {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((productBundle: ProductBundle) => productBundle.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace, {
-    nullable: false
-  })
-  @Field({ nullable: true })
-  bizplace: Bizplace
-
-  @OneToMany(type => ProductBundleSetting, productBundleSetting => productBundleSetting.productBundle)
-  @Field(type => [ProductBundleSetting])
-  productBundleSettings: ProductBundleSetting[]
-
-  @Column()
-  @Field()
-  sku: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refCode: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @Column()
-  @Field()
-  packingType: string
-
-  @Column({ type: 'float', default: 1, transformer: roundTransformer })
-  @Field()
-  packingSize: number
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  creator: User
-
-  @RelationId((productBundle: ProductBundle) => productBundle.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((productBundle: ProductBundle) => productBundle.updater)
-  updaterId: string
-}

package/server/service/product-bundle-setting/index.ts

@@ -1,6 +0,0 @@
-import { ProductBundleSetting } from './product-bundle-setting'
-import { ProductBundleSettingMutation } from './product-bundle-setting-mutation'
-import { ProductBundleSettingQuery } from './product-bundle-setting-query'
-
-export const entities = [ProductBundleSetting]
-export const resolvers = [ProductBundleSettingQuery, ProductBundleSettingMutation]

package/server/service/product-bundle-setting/product-bundle-setting-mutation.ts

@@ -1,168 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { ProductBundleSetting } from './product-bundle-setting'
-import { ProductBundleSettingPatch } from './product-bundle-setting-types'
-
-const debug = require('debug')('things-factory:product-base:productBundle')
-
-@Resolver(ProductBundleSetting)
-export class ProductBundleSettingMutation {
-  @Mutation(returns => [ProductBundleSetting])
-  async updateMultipleProductBundleSetting(
-    @Arg('patches', type => [ProductBundleSettingPatch]) patches: ProductBundleSettingPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<ProductBundleSetting[]> {
-    return await updateMultipleProductBundleSetting(patches)
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteProductBundleSetting(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    await getRepository(ProductBundleSetting).delete({ id })
-
-    return true
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteProductBundleSettings(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    await getRepository(ProductBundleSetting).delete({
-      product: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async linkProductBundle(
-    @Arg('productBundleId') productBundleId: string,
-    @Arg('patches', type => [ProductBundleSettingPatch]) patches: ProductBundleSettingPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    try {
-      const { domain, tx } = context.state
-
-      // const existingBundleLink: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
-      //   where: { productBundle: productBundleId },
-      //   relations: ['product', 'productDetail', 'productBundle']
-      // })
-
-      const qb: SelectQueryBuilder<ProductBundleSetting> = tx
-        .getRepository(ProductBundleSetting)
-        .createQueryBuilder('pbs')
-        .innerJoinAndSelect('pbs.product', 'prd')
-        .innerJoinAndSelect('pbs.productDetail', 'pd')
-        .innerJoinAndSelect('pbs.productBundle', 'pb')
-        .where('pb.id = :productBundleId', { productBundleId })
-        .andWhere('pb.domain_id = :domainId', { domainId: domain.id })
-
-      const existingBundleLink = await qb.getMany()
-
-      let newBundleLink: ProductBundleSetting[] = patches.reduce((acc, curr) => {
-        if (
-          !existingBundleLink.find(
-            item => item.product.id === curr.product.id && item.productDetail.id === curr.productDetail.id
-          )
-        ) {
-          acc.push({
-            productBundle: { id: productBundleId },
-            product: { id: curr.product.id },
-            productDetail: { id: curr.productDetail.id },
-            bundleQty: curr.bundleQty,
-            cuFlag: '+'
-          })
-        }
-        // check if there is existing bundle link but changes in bundle qty
-        else if (
-          existingBundleLink.find(
-            item =>
-              item.product.id === curr.product.id &&
-              item.productDetail.id === curr.productDetail.id &&
-              item.bundleQty !== curr.bundleQty
-          )
-        ) {
-          acc.push({
-            id: curr.id,
-            productBundle: { id: productBundleId },
-            product: { id: curr.product.id },
-            productDetail: { id: curr.productDetail.id },
-            bundleQty: curr.bundleQty,
-            cuFlag: 'M'
-          })
-        }
-        return acc
-      }, [])
-
-      let removeBundleLink: ProductBundleSetting[] = existingBundleLink.reduce((acc, curr) => {
-        if (!patches.find(item => item.id == curr.id)) {
-          acc.push({
-            id: curr.id,
-            productBundle: { id: productBundleId },
-            product: { id: curr.product.id },
-            productDetail: { id: curr.productDetail.id },
-            bundleQty: curr.bundleQty
-          })
-        }
-        return acc
-      }, [])
-
-      if (newBundleLink.length > 0) {
-        await updateMultipleProductBundleSetting(newBundleLink, tx)
-      }
-
-      if (removeBundleLink.length > 0) {
-        await tx.getRepository(ProductBundleSetting).delete({
-          id: In(removeBundleLink.map(bundleLink => bundleLink.id))
-        })
-      }
-
-      return true
-    } catch (error) {
-      debug('link-product-bundle', error)
-      throw error
-    }
-  }
-}
-
-export async function updateMultipleProductBundleSetting(
-  patches: ProductBundleSettingPatch[],
-  tx?: EntityManager
-): Promise<ProductBundleSetting[]> {
-  let results = []
-  const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-  const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-  const productBundleSettingRepo = tx.getRepository(ProductBundleSetting)
-
-  if (_createRecords.length > 0) {
-    for (let i = 0; i < _createRecords.length; i++) {
-      const newRecord = _createRecords[i]
-
-      const result = await productBundleSettingRepo.save({
-        ...newRecord
-      })
-
-      results.push({ ...result, cuFlag: '+' })
-    }
-  }
-
-  if (_updateRecords.length > 0) {
-    for (let i = 0; i < _updateRecords.length; i++) {
-      const newRecord = _updateRecords[i]
-      const productBundleSetting = await productBundleSettingRepo.findOneBy({ id: newRecord.id })
-
-      const result = await productBundleSettingRepo.save({
-        ...productBundleSetting,
-        ...newRecord
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}