@things-factory/product-base 3.7.13 → 3.8.3

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

@@ -0,0 +1,116 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ProductCombinationSetting } from '../product-combination-setting/product-combination-setting'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+
+export enum ProductCombinationStatus {
+  ACTIVE = 'ACTIVE',
+  ACTIVATED = 'ACTIVATED',
+  DELETED = 'DELETED',
+  INACTIVE = 'INACTIVE'
+}
+
+registerEnumType(ProductCombinationStatus, {
+  name: 'ProductCombinationStatus',
+  description: 'status enumeration of a productCombination'
+})
+
+@Entity()
+@Index(
+  'ix_product_combination_0',
+  (productCombination: ProductCombination) => [productCombination.domain, productCombination.id],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ProductCombination' })
+export class ProductCombination {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((productCombination: ProductCombination) => productCombination.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @OneToMany(
+    type => ProductCombinationSetting,
+    productCombinationSetting => productCombinationSetting.productCombination
+  )
+  @Field(type => [ProductCombinationSetting], { nullable: true })
+  productCombinationSettings?: ProductCombinationSetting[]
+
+  @ManyToOne(type => Product)
+  @Field(type => Product)
+  product?: Product
+
+  @RelationId((productCombination: ProductCombination) => productCombination.product)
+  productId?: string
+
+  @ManyToOne(type => ProductDetail, { nullable: false })
+  @Field(type => ProductDetail)
+  productDetail?: ProductDetail
+
+  @RelationId((productCombination: ProductCombination) => productCombination.productDetail)
+  productDetailId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  deletedAt: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  deletedBy: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.deletedBy)
+  deletedById?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.creator)
+  updaterId?: string
+}

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

@@ -0,0 +1,6 @@
+import { ProductCombinationSetting } from './product-combination-setting'
+import { ProductCombinationSettingQuery } from './product-combination-setting-query'
+import { ProductCombinationSettingMutation } from './product-combination-setting-mutation'
+
+export const entities = [ProductCombinationSetting]
+export const resolvers = [ProductCombinationSettingQuery, ProductCombinationSettingMutation]

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

@@ -0,0 +1,247 @@
+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: any
+  ): Promise<ProductCombinationSetting> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ProductCombinationSetting).save({
+      ...productCombinationSetting,
+      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: any
+  ): Promise<ProductCombinationSetting> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ProductCombinationSetting)
+    const productCombinationSetting = await repository.findOne({
+      where: { domain, 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: any
+  ): 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.findOne(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: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductCombinationSetting).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple productCombinationSettings' })
+  async deleteProductCombinationSettings(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductCombinationSetting).delete({
+      domain,
+      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: any
+  ): 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.id == curr.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: any) {
+  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.findOne(newRecord.id)
+
+      const result = await productCombinationSettingRepo.save({
+        ...productCombinationSetting,
+        ...newRecord,
+        updater: user
+      })
+
+      results.push({ ...result, cuFlag: 'M' })
+    }
+  }
+
+  return results
+}

package/server/{graphql/resolvers/product-combination-setting/product-combination-sets.ts → service/product-combination-setting/product-combination-setting-query.ts}

@@ -1,13 +1,48 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
-import { buildCondition, buildQuery, Domain, ListParam } from '@things-factory/shell'
+import { buildCondition, buildQuery, convertListParams, Domain, 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: any
+  ): Promise<ProductCombinationSetting[]> {
+    const productCombination: ProductCombination = await getRepository(ProductCombination).findOne({
+      where: { id: productCombinationId },
+      relations: ['productCombinationSetting']
+    })
+
+    const productCombinationSettings: ProductCombinationSetting[] = productCombination.productCombinationSettings
+
+    return productCombinationSettings
+  }
 
-import { Product } from '../../../entities'
+  @Query(returns => ProductCombinationSettingList, { description: 'To fetch multiple ProductCombinationSettings' })
+  async productCombinationSettings(
+    @Args() params: ListParam,
+    @Ctx() context: any
+  ): Promise<ProductCombinationSettingList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(ProductCombinationSetting).findAndCount(convertedParams)
+
+    return { items, total }
+  }
 
-export const productCombinationSets = {
-  async productCombinationSets(_: any, params: ListParam, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  @Query(returns => ProductCombinationSettingList, { description: 'To fetch a set of product combinations' })
+  async productCombinationSets(@Args() params: ListParam, @Ctx() context: any): Promise<ProductCombinationSettingList> {
+    const { domain } = context.state
     const page = params.pagination.page
     const limit = params.pagination.limit
 
@@ -116,4 +151,19 @@ export const productCombinationSets = {
 
     return { items, total }
   }
+
+  @FieldResolver(type => Product)
+  async product(@Root() productCombinationSetting: ProductCombinationSetting): Promise<Product> {
+    return await getRepository(Product).findOne(productCombinationSetting.productId)
+  }
+
+  @FieldResolver(type => ProductDetail)
+  async productDetail(@Root() productCombinationSetting: ProductCombinationSetting): Promise<ProductDetail> {
+    return await getRepository(ProductDetail).findOne(productCombinationSetting.productDetailId)
+  }
+
+  @FieldResolver(type => ProductCombination)
+  async productCombination(@Root() productCombinationSetting: ProductCombinationSetting): Promise<ProductCombination> {
+    return await getRepository(ProductCombination).findOne(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,48 @@
+import { Field, ID, ObjectType } 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)
+  productId?: string
+
+  @ManyToOne(type => ProductDetail)
+  @Field(type => ProductDetail)
+  productDetail?: ProductDetail
+
+  @RelationId((productCombinationSetting: ProductCombinationSetting) => productCombinationSetting.productDetail)
+  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
+}

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]