@things-factory/product-base 3.7.13 → 3.8.3

package/server/{entities → service/product-bundle}/product-bundle.ts

@@ -1,3 +1,7 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -6,71 +10,93 @@ import {
   ManyToOne,
   OneToMany,
   PrimaryGeneratedColumn,
+  RelationId,
   UpdateDateColumn
 } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { ProductBundleSetting } from './'
+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')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @ManyToOne(type => Domain)
+  @Field()
   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 })
+  @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/{graphql/resolvers/product-bundle-setting/link-product-bundle.ts → service/product-bundle-setting/product-bundle-setting-mutation.ts}

@@ -1,14 +1,49 @@
-import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
+import { Arg, Ctx, Mutation, Resolver, Directive } from 'type-graphql'
+import { EntityManager, getRepository, In, SelectQueryBuilder } from 'typeorm'
 
 import { Domain } from '@things-factory/shell'
 
-import { ProductBundleSetting } from '../../../entities'
-import { updateMultipleProductBundleSetting } from './update-multiple-product-bundle-setting'
+import { ProductBundleSetting } from './product-bundle-setting'
+import { ProductBundleSettingPatch } from './product-bundle-setting-types'
 
 const debug = require('debug')('things-factory:product-base:productBundle')
 
-export const linkProductBundle = {
-  async linkProductBundle(_: any, { productBundleId, patches }, context: any) {
+@Resolver(ProductBundleSetting)
+export class ProductBundleSettingMutation {
+  @Mutation(returns => [ProductBundleSetting])
+  async updateMultipleProductBundleSetting(
+    @Arg('patches', type => [ProductBundleSettingPatch]) patches: ProductBundleSettingPatch[],
+    @Ctx() context: any
+  ): Promise<ProductBundleSetting[]> {
+    return await updateMultipleProductBundleSetting(patches)
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteProductBundleSetting(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+    await getRepository(ProductBundleSetting).delete({ id })
+
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteProductBundleSettings(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): 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: any
+  ): Promise<Boolean> {
     try {
       const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
@@ -85,9 +120,49 @@ export const linkProductBundle = {
           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.findOne({ id: newRecord.id })
+
+      const result = await productBundleSettingRepo.save({
+        ...productBundleSetting,
+        ...newRecord
+      })
+
+      results.push({ ...result, cuFlag: 'M' })
+    }
+  }
+
+  return results
+}

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

@@ -1,12 +1,27 @@
+import { Args, Ctx, Query, Resolver } 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 { Product } from '../../../entities'
+import { Product } from '../product/product'
+import { ProductBundleSetting } from './product-bundle-setting'
+import { ProductBundleSettingList } from './product-bundle-setting-types'
 
-export const productBundleSets = {
-  async productBundleSets(_: any, params: ListParam, context: any) {
+@Resolver(ProductBundleSetting)
+export class ProductBundleSettingQuery {
+  @Query(returns => ProductBundleSettingList)
+  async productBundleSettings(@Args() params: ListParam, @Ctx() context: any): Promise<ProductBundleSettingList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(ProductBundleSetting).findAndCount({
+      ...convertedParams
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => ProductBundleSettingList)
+  async productBundleSets(@Args() params: ListParam, @Ctx() context: any): Promise<ProductBundleSettingList> {
     const { domain }: { domain: Domain } = context.state
     const page = params.pagination.page
     const limit = params.pagination.limit
@@ -41,9 +56,7 @@ export const productBundleSets = {
     qb.leftJoinAndSelect(
       'product_bundle_settings',
       'pbs',
-      `pbs.product_id = prd.id and pbs.product_detail_id = prdDet.id ${
-        productBundleId && productBundleId.operator === 'noteq' ? 'and pbs.product_detail_id = null' : ''
-      }`
+      'pbs.product_id = prd.id and pbs.product_detail_id = prdDet.id'
     )
     qb.leftJoinAndSelect('pbs.productBundle', 'pb')
 
@@ -79,20 +92,36 @@ export const productBundleSets = {
 
     const items = productBundleSets.map(item => {
       return {
+        // id: item.pbs_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,
+        // bundleId: item.pb_id,
+        // bundleSku: item.pb_sku,
+        // bundleName: item.pb_name,
+        // bundleDescription: item.pb_description,
+        // bundleQty: item.pbs_bundle_qty
+        ...item,
         id: item.pbs_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,
-        bundleId: item.pb_id,
-        bundleSku: item.pb_sku,
-        bundleName: item.pb_name,
-        bundleDescription: item.pb_description,
+        product: {
+          id: item.prd_id,
+          sku: item.prd_sku,
+          name: item.prd_name,
+          description: item.prd_description,
+          type: item.prd_type
+        },
+        productDetail: {
+          id: item.prdDet_id,
+          gtin: item.prdDet_gtin,
+          packingType: item.prdDet_packing_type,
+          packingSize: item.prdDet_packing_size
+        },
         bundleQty: item.pbs_bundle_qty
       }
     })

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

@@ -0,0 +1,41 @@
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductBundleSetting } from './product-bundle-setting'
+
+@ObjectType()
+export class ProductBundleSettingList {
+  @Field(type => [ProductBundleSetting], { nullable: true })
+  items?: ProductBundleSetting[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class ProductBundleSettingPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  productDetail?: ObjectRef
+
+  @Field({ nullable: true })
+  productBundle?: ObjectRef
+
+  @Field(type => Int, { nullable: true })
+  bundleQty?: number
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

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

@@ -0,0 +1,45 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+
+import { ProductBundle } from '../product-bundle/product-bundle'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+
+@Entity()
+@Index(
+  'ix_product_bundle_setting_0',
+  (productBundleSetting: ProductBundleSetting) => [
+    productBundleSetting.product,
+    productBundleSetting.productDetail,
+    productBundleSetting.productBundle
+  ],
+  { unique: true }
+)
+@ObjectType()
+export class ProductBundleSetting {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: true })
+  readonly id?: string
+
+  @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
+  product?: Product
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
+  productDetail?: ProductDetail
+
+  @ManyToOne(type => ProductBundle, { nullable: true })
+  @Field(type => ProductBundle, { nullable: true })
+  productBundle?: ProductBundle
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  bundleQty?: number
+
+  @Field({ nullable: true })
+  productId?: string
+
+  @Field({ nullable: true })
+  bundleId?: string
+}

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

@@ -0,0 +1,6 @@
+import { ProductCombination } from './product-combination'
+import { ProductCombinationQuery } from './product-combination-query'
+import { ProductCombinationMutation } from './product-combination-mutation'
+
+export const entities = [ProductCombination]
+export const resolvers = [ProductCombinationQuery, ProductCombinationMutation]

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

@@ -0,0 +1,142 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Repository } from 'typeorm'
+
+import { ProductDetail } from '../product-detail/product-detail'
+import { ProductCombination, ProductCombinationStatus } from './product-combination'
+import { NewProductCombination, ProductCombinationPatch } from './product-combination-type'
+
+@Resolver(ProductCombination)
+export class ProductCombinationMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombination, { description: 'To create new ProductCombination' })
+  async createProductCombination(
+    @Arg('productCombination') productCombination: NewProductCombination,
+    @Ctx() context: any
+  ): Promise<ProductCombination> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ProductCombination).save({
+      ...productCombination,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombination, { description: 'To modify ProductCombination information' })
+  async updateProductCombination(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProductCombinationPatch,
+    @Ctx() context: any
+  ): Promise<ProductCombination> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ProductCombination)
+    const productCombination = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...productCombination,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ProductCombination], { description: "To modify multiple ProductCombinations' information" })
+  async updateMultipleProductCombination(
+    @Arg('productDetailId', type => String) productDetailId: string,
+    @Arg('patches', type => [ProductCombinationPatch]) patches: ProductCombinationPatch[],
+    @Ctx() context: any
+  ): Promise<ProductCombination[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => !patch.id)
+    const _updateRecords = patches.filter((patch: any) => patch.id)
+    const productDetailRepo = tx.getRepository(ProductDetail)
+    const productCombinationRepo = tx.getRepository(ProductCombination)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        let newRecord = _createRecords[i]
+        const productDetail: ProductDetail = await productDetailRepo.findOne({
+          where: { id: productDetailId },
+          relations: ['product']
+        })
+
+        delete newRecord.id
+
+        if (!newRecord?.status) {
+          newRecord.status = ProductCombinationStatus.INACTIVE
+        }
+
+        const result = await productCombinationRepo.save({
+          ...newRecord,
+          domain,
+          productDetail,
+          product: productDetail.product,
+          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 productCombination = await productCombinationRepo.findOne({ domain, id: newRecord.id })
+
+        if (newRecord.status) {
+          newRecord.status = newRecord.status.toUpperCase()
+        }
+
+        const result = await productCombinationRepo.save({
+          ...productCombination,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ProductCombination' })
+  async deleteProductCombination(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { user, tx } = context.state
+
+    await tx.getRepository(ProductCombination).update({ id }, { deletedAt: new Date(), deletedBy: user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple productCombinations' })
+  async deleteProductCombinations(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { user, tx } = context.state
+
+    const productCombinationRepo: Repository<ProductCombination> = tx.getRepository(ProductCombination)
+
+    let productCombinations = await productCombinationRepo.find({ where: { id: In(ids) } })
+
+    for (let i = 0; i < productCombinations.length; i++) {
+      const product = productCombinations[i]
+
+      await productCombinationRepo.save({
+        ...product,
+        status: ProductCombinationStatus.DELETED,
+        updater: user
+      })
+    }
+
+    return true
+  }
+}

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

@@ -0,0 +1,46 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { ProductCombination } from './product-combination'
+import { ProductCombinationList } from './product-combination-type'
+
+@Resolver(ProductCombination)
+export class ProductCombinationQuery {
+  @Query(returns => ProductCombination, { description: 'To fetch a ProductCombination' })
+  async productCombination(@Arg('id') name: string, @Ctx() context: any): Promise<ProductCombination> {
+    const { domain, tx } = context.state
+
+    return await tx.getRepository(ProductCombination).findOne({
+      where: { domain, name }
+    })
+  }
+
+  @Query(returns => ProductCombinationList, { description: 'To fetch multiple ProductCombinations' })
+  async productCombinations(@Args() params: ListParam, @Ctx() context: any): Promise<ProductCombinationList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(ProductCombination).findAndCount({
+      ...convertedParams,
+      relations: ['product', 'productDetail']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() productCombination: ProductCombination): Promise<Domain> {
+    return await getRepository(Domain).findOne(productCombination.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() productCombination: ProductCombination): Promise<User> {
+    return await getRepository(User).findOne(productCombination.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() productCombination: ProductCombination): Promise<User> {
+    return await getRepository(User).findOne(productCombination.creatorId)
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductCombination, ProductCombinationStatus } from './product-combination'
+
+@InputType()
+export class NewProductCombination {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ProductCombinationStatus, { nullable: true })
+  status?: string
+}
+
+@InputType()
+export class ProductCombinationPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  productDetail?: ObjectRef
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ProductCombinationList {
+  @Field(type => [ProductCombination])
+  items: ProductCombination[]
+
+  @Field(type => Int)
+  total: number
+}