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

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

@@ -0,0 +1,248 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, SelectQueryBuilder } from 'typeorm'
+
+import { ProductCombinationSetting } from './product-combination-setting'
+import { NewProductCombinationSetting, ProductCombinationSettingPatch } from './product-combination-setting-type'
+
+const debug = require('debug')('things-factory:product-base:productCombinationSetting')
+
+@Resolver(ProductCombinationSetting)
+export class ProductCombinationSettingMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombinationSetting, { description: 'To create new ProductCombinationSetting' })
+  async createProductCombinationSetting(
+    @Arg('productCombinationSetting') productCombinationSetting: NewProductCombinationSetting,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSetting> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ProductCombinationSetting).save({
+      ...(productCombinationSetting as any),
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombinationSetting, { description: 'To modify ProductCombinationSetting information' })
+  async updateProductCombinationSetting(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProductCombinationSettingPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSetting> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ProductCombinationSetting)
+    const productCombinationSetting = await repository.findOne({
+      where: { id }
+    })
+
+    return await repository.save({
+      ...productCombinationSetting,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ProductCombinationSetting], {
+    description: "To modify multiple ProductCombinationSettings' information"
+  })
+  async updateMultipleProductCombinationSetting(
+    @Arg('patches', type => [ProductCombinationSettingPatch]) patches: ProductCombinationSettingPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSetting[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const productCombinationSettingRepo = tx.getRepository(ProductCombinationSetting)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await productCombinationSettingRepo.save({
+          ...newRecord,
+          domain,
+          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 productCombinationSetting = await productCombinationSettingRepo.findOneBy({ id: newRecord.id })
+
+        const result = await productCombinationSettingRepo.save({
+          ...productCombinationSetting,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ProductCombinationSetting' })
+  async deleteProductCombinationSetting(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductCombinationSetting).delete({ id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple productCombinationSettings' })
+  async deleteProductCombinationSettings(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductCombinationSetting).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To link product combination for kitting process' })
+  async linkProductCombination(
+    @Arg('productCombinationId', type => String) productCombinationId: string,
+    @Arg('patches', type => [ProductCombinationSettingPatch]) patches: ProductCombinationSettingPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      const { domain, tx } = context.state
+
+      const qb: SelectQueryBuilder<ProductCombinationSetting> = tx
+        .getRepository(ProductCombinationSetting)
+        .createQueryBuilder('pbs')
+        .innerJoinAndSelect('pbs.product', 'prd')
+        .innerJoinAndSelect('pbs.productDetail', 'pd')
+        .innerJoinAndSelect('pbs.productCombination', 'pc')
+        .where('pc.id = :productCombinationId', { productCombinationId })
+        .andWhere('pc.domain_id = :domainId', { domainId: domain.id })
+
+      const existingCombinationLink = await qb.getMany()
+
+      let newCombinationLink: ProductCombinationSetting[] = patches.reduce((acc, curr) => {
+        if (
+          !existingCombinationLink.find(
+            item => item.product.id === curr.product.id && item.productDetail.id === curr.productDetail.id
+          )
+        ) {
+          acc.push({
+            productCombination: { id: productCombinationId },
+            product: { id: curr.product.id },
+            productDetail: { id: curr.productDetail.id },
+            qty: curr.qty,
+            cuFlag: '+'
+          })
+        }
+        // check if there is existing bundle link but changes in bundle qty
+        else if (
+          existingCombinationLink.find(
+            item =>
+              item.product.id === curr.product.id &&
+              item.productDetail.id === curr.productDetail.id &&
+              item.qty !== curr.qty
+          )
+        ) {
+          acc.push({
+            id: curr.id,
+            productCombination: { id: productCombinationId },
+            product: { id: curr.product.id },
+            productDetail: { id: curr.productDetail.id },
+            qty: curr.qty,
+            cuFlag: 'M'
+          })
+        }
+        return acc
+      }, [])
+
+      let removeCombinationLink: ProductCombinationSetting[] = existingCombinationLink.reduce((acc, curr) => {
+        if (
+          !patches.find(item => item.product.id == curr.product.id && item.productDetail.id == curr.productDetail.id)
+        ) {
+          acc.push({
+            id: curr.id,
+            productCombination: { id: productCombinationId },
+            product: { id: curr.product.id },
+            productDetail: { id: curr.productDetail.id },
+            qty: curr.qty
+          })
+        }
+        return acc
+      }, [])
+
+      if (newCombinationLink.length > 0) {
+        await updateMultipleProductCombinationSetting(newCombinationLink, context)
+      }
+
+      if (removeCombinationLink.length > 0) {
+        await tx.getRepository(ProductCombinationSetting).delete({
+          id: In(removeCombinationLink.map(combinationLink => combinationLink.id))
+        })
+      }
+
+      return true
+    } catch (error) {
+      debug('link-product-combination', error)
+      throw error
+    }
+  }
+}
+
+export async function updateMultipleProductCombinationSetting(patches: any, context: ResolverContext) {
+  const { domain, user, tx } = context.state
+
+  let results = []
+  const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+  const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+  const productCombinationSettingRepo = tx.getRepository(ProductCombinationSetting)
+
+  if (_createRecords.length > 0) {
+    for (let i = 0; i < _createRecords.length; i++) {
+      const newRecord = _createRecords[i]
+
+      const result = await productCombinationSettingRepo.save({
+        ...newRecord,
+        domain,
+        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 productCombinationSetting = await productCombinationSettingRepo.findOneBy({ id: newRecord.id })
+
+      const result = await productCombinationSettingRepo.save({
+        ...productCombinationSetting,
+        ...newRecord,
+        updater: user
+      })
+
+      results.push({ ...result, cuFlag: 'M' })
+    }
+  }
+
+  return results
+}

package/server/service/product-combination-setting/product-combination-setting-query.ts

@@ -0,0 +1,176 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, SelectQueryBuilder } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { buildCondition, buildQuery, convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { ProductCombination } from '../product-combination/product-combination'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+import { ProductCombinationSetting } from './product-combination-setting'
+import { ProductCombinationSettingList } from './product-combination-setting-type'
+
+@Resolver(ProductCombinationSetting)
+export class ProductCombinationSettingQuery {
+  @Query(returns => ProductCombinationSetting, { description: 'To fetch a ProductCombinationSetting' })
+  async productCombinationSetting(
+    @Arg('productCombinationId') productCombinationId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSetting[]> {
+    const productCombination: ProductCombination = await getRepository(ProductCombination).findOne({
+      where: { id: productCombinationId },
+      relations: ['productCombinationSetting']
+    })
+
+    const productCombinationSettings: ProductCombinationSetting[] = productCombination.productCombinationSettings
+
+    return productCombinationSettings
+  }
+
+  @Query(returns => ProductCombinationSettingList, { description: 'To fetch multiple ProductCombinationSettings' })
+  async productCombinationSettings(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSettingList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, { domain })
+    const [items, total] = await getRepository(ProductCombinationSetting).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @Query(returns => ProductCombinationSettingList, { description: 'To fetch a set of product combinations' })
+  async productCombinationSets(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationSettingList> {
+    const { domain } = context.state
+    const page = params.pagination.page
+    const limit = params.pagination.limit
+
+    const filters = params.filters.filter(
+      x => x.name !== 'product_info' && x.name !== 'productCombinationId' && x.name !== 'bizplace_id'
+    )
+    const bizplaceFilter = params.filters.find(x => x.name == 'bizplace_id')
+    const productCombinationId = params.filters.find(x => x.name === 'productCombinationId')
+    const productInfoFilter = params.filters.find(x => x.name === 'product_info')
+    const productInfoColumns = ['sku', 'name', 'description']
+    params.filters = [...filters]
+
+    params.sortings = [
+      { name: 'prd.sku' },
+      { name: 'prdDet.gtin' },
+      ...params.sortings.map(sorting => {
+        const name = sorting.name.replace('product', '').toLowerCase()
+        return {
+          ...sorting,
+          name
+        }
+      })
+    ]
+
+    if (bizplaceFilter?.value) {
+      const bizplaceId: string = bizplaceFilter.value
+
+      const foundBizplace: Bizplace = await getRepository(Bizplace).findOne({
+        where: { id: bizplaceId } /* CONFIRMME regarding TYPEORM - migrated correctly ? */,
+        relations: ['company', 'company.domain']
+      })
+
+      if (foundBizplace) {
+        const companyDomain: Domain = foundBizplace.company?.domain
+        const companyBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { domain: { id: companyDomain.id } }
+        })
+
+        const bizplaceIds = [companyBizplace.id, foundBizplace.id]
+        params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [...new Set(bizplaceIds)] }]
+      }
+    } else {
+      let bizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { domain: { id: domain.id } } })
+      params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [bizplace.id] }]
+    }
+
+    const qb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder('prd')
+    buildQuery(qb, params, context, {
+      domainRef: false
+    })
+
+    qb.innerJoinAndSelect('product_details', 'prdDet', 'prdDet.product_id = prd.id')
+    qb.leftJoinAndSelect(
+      'product_combination_settings',
+      'pcs',
+      `pcs.product_id = prd.id and pcs.product_detail_id = prdDet.id ${
+        productCombinationId && productCombinationId.operator === 'noteq' ? 'and pcs.product_detail_id = null' : ''
+      }`
+    )
+    qb.leftJoinAndSelect('pcs.productCombination', 'pc')
+
+    if (productInfoFilter) {
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productInfoColumns.forEach(filter => {
+            const condition = buildCondition(
+              qb.alias,
+              filter,
+              productInfoFilter.operator,
+              productInfoFilter.value,
+              productInfoFilter.relation,
+              Object.keys(qb.getParameters()).length
+            )
+
+            qb2.orWhere(condition.clause, condition.parameters)
+          })
+        })
+      )
+    }
+
+    if (productCombinationId && productCombinationId.operator === 'eq') {
+      qb.andWhere('pc.id = :combinationId::uuid', {
+        combinationId: productCombinationId.value
+      })
+    }
+
+    let productCombinationSets = await qb
+      .offset((page - 1) * limit)
+      .limit(limit)
+      .getRawMany()
+
+    const items = productCombinationSets.map(item => {
+      return {
+        id: item.pcs_id,
+        productDetailId: item.prdDet_id,
+        gtin: item.prdDet_gtin,
+        packingType: item.prdDet_packing_type,
+        packingSize: item.prdDet_packing_size,
+        productId: item.prd_id,
+        productSku: item.prd_sku,
+        productName: item.prd_name,
+        productDescription: item.prd_description,
+        productType: item.prd_type,
+        combinationId: item.pc_id,
+        qty: item.pcs_qty
+      }
+    })
+
+    const total = await qb.getCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Product)
+  async product(@Root() productCombinationSetting: ProductCombinationSetting): Promise<Product> {
+    return await getRepository(Product).findOneBy({ id: productCombinationSetting.productId })
+  }
+
+  @FieldResolver(type => ProductDetail)
+  async productDetail(@Root() productCombinationSetting: ProductCombinationSetting): Promise<ProductDetail> {
+    return await getRepository(ProductDetail).findOneBy({ id: productCombinationSetting.productDetailId })
+  }
+
+  @FieldResolver(type => ProductCombination)
+  async productCombination(@Root() productCombinationSetting: ProductCombinationSetting): Promise<ProductCombination> {
+    return await getRepository(ProductCombination).findOneBy({ id: productCombinationSetting.productCombinationId })
+  }
+}

package/server/service/product-combination-setting/product-combination-setting-type.ts

@@ -0,0 +1,44 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductCombinationSetting } from './product-combination-setting'
+
+@InputType()
+export class NewProductCombinationSetting {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@InputType()
+export class ProductCombinationSettingPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  productDetail?: ObjectRef
+
+  @Field({ nullable: true })
+  productCombination?: ObjectRef
+
+  @Field(type => Int)
+  qty: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ProductCombinationSettingList {
+  @Field(type => [ProductCombinationSetting])
+  items: ProductCombinationSetting[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/product-combination-setting/product-combination-setting.ts

@@ -0,0 +1,77 @@
+import { Field, ID, ObjectType, Int } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+
+import { ProductCombination } from '../product-combination/product-combination'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+
+@Entity()
+@Index(
+  'ix_product_combination_setting_0',
+  (productCombinationSetting: ProductCombinationSetting) => [
+    productCombinationSetting.product,
+    productCombinationSetting.productDetail,
+    productCombinationSetting.productCombination
+  ],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ProductCombinationSetting' })
+export class ProductCombinationSetting {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: true })
+  readonly id?: string
+
+  @ManyToOne(type => Product)
+  @Field(type => Product)
+  product?: Product
+
+  @RelationId((productCombinationSetting: ProductCombinationSetting) => productCombinationSetting.product)
+  @Field({ nullable: true })
+  productId?: string
+
+  @ManyToOne(type => ProductDetail)
+  @Field(type => ProductDetail)
+  productDetail?: ProductDetail
+
+  @RelationId((productCombinationSetting: ProductCombinationSetting) => productCombinationSetting.productDetail)
+  @Field({ nullable: true })
+  productDetailId?: string
+
+  @ManyToOne(type => ProductCombination)
+  @Field(type => ProductCombination)
+  productCombination?: ProductCombination
+
+  @RelationId((productCombinationSetting: ProductCombinationSetting) => productCombinationSetting.productCombination)
+  productCombinationId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  qty: number
+
+  @Field({ nullable: true })
+  gtin?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Int, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  remainUomValueWithUom?: string
+
+  @Field({ nullable: true })
+  productSku?: string
+
+  @Field({ nullable: true })
+  productName?: string
+
+  @Field({ nullable: true })
+  productDescription?: string
+
+  @Field({ nullable: true })
+  productType?: string
+
+  @Field({ nullable: true })
+  combinationId?: string
+}

package/server/service/product-detail/index.ts

@@ -0,0 +1,6 @@
+import { ProductDetail } from './product-detail'
+import { ProductDetailMutation } from './product-detail-mutation'
+import { ProductDetailQuery } from './product-detail-query'
+
+export const entities = [ProductDetail]
+export const resolvers = [ProductDetailQuery, ProductDetailMutation]