@things-factory/product-base 8.0.0-beta.9 → 8.0.2

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

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

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

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

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

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

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