@things-factory/product-base 3.7.13 → 3.8.3

package/server/graphql/resolvers/product/undelete-products.ts

@@ -1,21 +0,0 @@
-import { EntityManager, getRepository, In } from 'typeorm'
-import { PRODUCT_STATUS } from '../../../constants'
-import { Product } from '../../../entities'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-export const undeleteProducts = {
-  async undeleteProducts(_: any, { ids }, context: any) {
-    const { tx, user }: { tx: EntityManager; user: User } = context.state
-    const productRepo = tx.getRepository(Product)
-
-    await productRepo.update(
-      {
-        id: In(ids)
-      },
-      {
-        deletedAt: null
-      }
-    )
-  }
-}

package/server/graphql/resolvers/product/update-multiple-product.ts

@@ -1,33 +0,0 @@
-import { Product } from '../../../entities'
-import { createProduct } from './create-product'
-import { updateProduct } from './update-product'
-
-export const updateMultipleProduct = {
-  async updateMultipleProduct(_: any, { patches }, context: any): Promise<any> {
-    try {
-      let results = []
-      const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-      const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-  
-      if (_createRecords.length > 0) {
-        for (let i = 0; i < _createRecords.length; i++) {
-          const patch: Product = _createRecords[i]
-          const result = await createProduct(patch, context)
-          results.push({ ...result, cuFlag: '+' })
-        }
-      }
-  
-      if (_updateRecords.length > 0) {
-        for (let i = 0; i < _updateRecords.length; i++) {
-          const patch: Product = _updateRecords[i]
-          const result = await updateProduct(patch.id, patch, context)
-          results.push({ ...result, cuFlag: 'M' })
-        }
-      }
-  
-      return results      
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/product/update-product.ts

@@ -1,75 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { EntityManager, Repository } from 'typeorm'
-import { Product, ProductDetail } from '../../../entities'
-import { Domain } from '@things-factory/shell'
-import { updateProductDetail } from '../product-detail/update-product-detail'
-import { createProductDetail } from '../product-detail/create-product-detail'
-import { validateProduct } from './validate-product'
-
-export const updateProductResolver = {
-  async updateProduct(_: any, { id, patch }, context: any) {
-    return await updateProduct(id, patch, context)
-  }
-}
-
-export async function updateProduct(id: string, patch, context) {
-  try {
-    const { user, tx, domain }: { user: User; tx: EntityManager; domain: Domain } = context.state
-  
-    const bizplaceRepo: Repository<Bizplace> = tx.getRepository(Bizplace)
-    const productRepo: Repository<Product> = tx.getRepository(Product)
-    const productDetailRepo: Repository<ProductDetail> = tx.getRepository(ProductDetail)
-  
-  
-    let product = await productRepo.findOne({ where: { id }, relations: ['domain'] })
-  
-    let productDetail = await productDetailRepo.findOne({ where: { product: { id } , isDefault: true }, relations: ['domain'] })
-  
-    if (patch.productRef && patch.productRef.id) {
-      patch.productRef = await productRepo.findOne(patch.productRef.id)
-    }
-  
-    let bizplace: Bizplace
-    if (product.bizplace?.id) {
-      bizplace = await bizplaceRepo.findOne(product.bizplace.id)
-    } else {
-      bizplace = await bizplaceRepo.findOne({ where: { name: domain.name } })
-    }
-  
-    await validateProduct({
-      ...product,
-      ...patch,
-      bizplace,
-      domain
-    }, context)
-
-    if(patch.uom){
-      product.primaryUnit = patch.uom
-    }
-
-    if(patch.uomValue){
-      product.primaryValue = patch.uomValue
-    }
-  
-    product = await productRepo.save({
-      ...product,
-      ...patch,
-      domain,
-      updater: user
-    })
-  
-    if(productDetail){
-      if(product.gtin){
-        delete product.gtin
-      }
-      productDetail = await updateProductDetail(productDetail.id, new ProductDetail({...product, ...patch, product}), context)
-    }else{
-      productDetail = await createProductDetail(new ProductDetail({...product, ...patch, product, isDefault: true}), context)
-    }
-  
-    return product     
-  } catch (error) {
-    throw error
-  }
-}

package/server/graphql/resolvers/product-bundle/create-product-bundle.ts

@@ -1,16 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductBundle } from '../../../entities'
-
-export const createProductBundle = {
-  async createProductBundle(_: any, { productBundle }, context: any) {
-    const { domain, user } = context.state
-
-    return await getRepository(ProductBundle).save({
-      ...productBundle,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-}
-

package/server/graphql/resolvers/product-bundle/delete-product-bundle.ts

@@ -1,13 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductBundle } from '../../../entities'
-
-export const deleteProductBundle = {
-  async deleteProductBundle(_: any, { name }, context: any) {
-    const { domain, user } = context.state
-
-    await getRepository(ProductBundle).delete({ domain, name })
-    
-    return true
-  }
-}
-

package/server/graphql/resolvers/product-bundle/delete-product-bundles.ts

@@ -1,26 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository, In } from 'typeorm'
-import { ProductBundle } from '../../../entities'
-import { PRODUCT_BUNDLE_STATUS } from '../../../constants'
-import { User } from '@things-factory/auth-base'
-
-export const deleteProductBundles = {
-  async deleteProductBundles(_: any, { ids }, context: any) {
-    const { tx, user }: { tx: EntityManager; user: 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/graphql/resolvers/product-bundle/index.ts

@@ -1,22 +0,0 @@
-import { Query } from './product-bundle-query'
-
-import { updateProductBundle } from './update-product-bundle'
-import { updateMultipleProductBundle } from './update-multiple-product-bundle'
-import { createProductBundle } from './create-product-bundle'
-import { deleteProductBundle } from './delete-product-bundle'
-import { deleteProductBundles } from './delete-product-bundles'
-import { myBizplaceProductBundles } from './my-bizplace-product-bundles'
-
-export const ProductBundleResolver = {
-  Query: {
-    ...Query,
-    ...myBizplaceProductBundles
-  },
-  Mutation: {
-    ...updateProductBundle,
-    ...updateMultipleProductBundle,
-    ...createProductBundle,
-    ...deleteProductBundle,
-    ...deleteProductBundles
-  }
-}

package/server/graphql/resolvers/product-bundle/product-bundle-query.ts

@@ -1,24 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Domain, ListParam, convertListParams } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ProductBundle as ProductBundleEntity } from '../../../entities'
-
-export const Query = {
-  async productBundle(_: any, { name }, context: any) {
-    const { domain, user } = context.state
-    const repository = getRepository(ProductBundleEntity)
-
-    return await repository.findOne({
-      where: { domain, name }
-    })
-  },
-
-  async productBundles(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(ProductBundleEntity).findAndCount({
-      ...convertedParams
-    })
-    
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/product-bundle/update-multiple-product-bundle.ts

@@ -1,68 +0,0 @@
-import { Bizplace } from '@things-factory/biz-base'
-import { getRepository } from 'typeorm'
-import { ProductBundle } from '../../../entities'
-import { PRODUCT_BUNDLE_STATUS } from '../../../constants'
-
-export const updateMultipleProductBundle = {
-  async updateMultipleProductBundle(_: any, { patches }, context: any) {
-    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 || ''
-
-          if (newRecord.bizplace?.id) {
-            bizplace = await bizplaceRepo.findOne(newRecord.bizplace.id)
-          } else {
-            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.findOne({ domain, 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
-  }
-}
-

package/server/graphql/resolvers/product-bundle/update-product-bundle.ts

@@ -1,19 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductBundle } from '../../../entities'
-
-export const updateProductBundle = {
-  async updateProductBundle(_: any, { name, patch }, context: any) {
-    const { domain, user } = context.state
-
-    const repository = getRepository(ProductBundle)
-    const productBundle = await repository.findOne({ 
-      where: { domain, name }
-    })
-
-    return await repository.save({
-      ...productBundle,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/product-bundle-setting/create-product-bundle-setting.ts

@@ -1,15 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductBundleSetting } from '../../../entities'
-
-export const createProductBundleSetting = {
-  async createProductBundleSetting(_: any, { productBundleSetting }, context: any) {
-    const { user } = context.state
-
-    return await getRepository(ProductBundleSetting).save({
-      ...productBundleSetting,
-      creator: user,
-      updater: user
-    })
-  }
-}
-

package/server/graphql/resolvers/product-bundle-setting/delete-product-bundle-setting.ts

@@ -1,11 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductBundleSetting } from '../../../entities'
-
-export const deleteProductBundleSetting = {
-  async deleteProductBundleSetting(_: any, { id }, context: any) {
-    await getRepository(ProductBundleSetting).delete({ id })
-    
-    return true
-  }
-}
-

package/server/graphql/resolvers/product-bundle-setting/delete-product-bundle-settings.ts

@@ -1,14 +0,0 @@
-import { getRepository, In } from 'typeorm'
-import { ProductBundleSetting } from '../../../entities'
-
-export const deleteProductBundleSettings = {
-  async deleteProductBundleSettings(_: any, { ids }, context: any) {
-
-    await getRepository(ProductBundleSetting).delete({ 
-        product: In(ids)
-    })
-    
-    return true
-  }
-}
-

package/server/graphql/resolvers/product-bundle-setting/index.ts

@@ -1,22 +0,0 @@
-import { Query } from './product-bundle-setting-query'
-
-import { updateMultipleProductBundleSetting } from './update-multiple-product-bundle-setting'
-import { createProductBundleSetting } from './create-product-bundle-setting'
-import { deleteProductBundleSetting } from './delete-product-bundle-setting'
-import { deleteProductBundleSettings } from './delete-product-bundle-settings'
-import { productBundleSets } from './product-bundle-sets'
-import { linkProductBundle } from './link-product-bundle'
-
-export const ProductBundleSettingResolver = {
-  Query: {
-    ...Query,
-    ...productBundleSets
-  },
-  Mutation: {
-    ...updateMultipleProductBundleSetting,
-    ...createProductBundleSetting,
-    ...deleteProductBundleSetting,
-    ...deleteProductBundleSettings,
-    ...linkProductBundle
-  }
-}

package/server/graphql/resolvers/product-bundle-setting/product-bundle-setting-query.ts

@@ -1,14 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ListParam, convertListParams } from '@things-factory/shell'
-import { ProductBundleSetting as ProductBundleSettingEntity } from '../../../entities'
-
-export const Query = {
-  async productBundleSettings(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(ProductBundleSettingEntity).findAndCount({
-      ...convertedParams
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/product-bundle-setting/update-multiple-product-bundle-setting.ts

@@ -1,47 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { ProductBundleSetting } from '../../../entities'
-
-export const updateMultipleProductBundleSettingResolver = {
-  async updateMultipleProductBundleSetting(_: any, { patches }, context: any) {
-    await updateMultipleProductBundleSetting(patches)
-  }
-}
-
-export async function updateMultipleProductBundleSetting(
-  patches: ProductBundleSetting[],
-  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-combination/create-product-combination.ts

@@ -1,16 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ProductCombination } from '../../../entities'
-
-export const createProductCombination = {
-  async createProductBundle(_: any, { productCombination }, context: any) {
-    const { domain, user } = context.state
-
-    return await getRepository(ProductCombination).save({
-      ...productCombination,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/product-combination/delete-product-combination.ts

@@ -1,13 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ProductCombination } from '../../../entities'
-
-export const deleteProductCombination = {
-  async deleteProductCombination(_: any, { id }, context: any) {
-    const { domain, user } = context.state
-
-    await getRepository(ProductCombination).update({ id }, { deletedAt: new Date(), deletedBy: user })
-
-    return true
-  }
-}

package/server/graphql/resolvers/product-combination/delete-product-combinations.ts

@@ -1,28 +0,0 @@
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-
-import { PRODUCT_COMBINATION_STATUS } from '../../../constants'
-import { ProductCombination } from '../../../entities'
-
-export const deleteProductCombinations = {
-  async deleteProductCombinations(_: any, { ids }, context: any) {
-    const { tx, user }: { tx: EntityManager; user: User } = context.state
-    const productCombinationRepo: Repository<ProductCombination> =
-      getRepository(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]
-
-      const result = await productCombinationRepo.save({
-        ...product,
-        status: PRODUCT_COMBINATION_STATUS.DELETED,
-        updater: user
-      })
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/product-combination/index.ts

@@ -1,19 +0,0 @@
-import { createProductCombination } from './create-product-combination'
-import { deleteProductCombination } from './delete-product-combination'
-import { deleteProductCombinations } from './delete-product-combinations'
-import { Query } from './product-combination-query'
-import { updateMultipleProductCombination } from './update-multiple-product-combination'
-import { updateProductCombination } from './update-product-combination'
-
-export const ProductCombinationResolver = {
-  Query: {
-    ...Query
-  },
-  Mutation: {
-    ...updateProductCombination,
-    ...updateMultipleProductCombination,
-    ...createProductCombination,
-    ...deleteProductCombination,
-    ...deleteProductCombinations
-  }
-}

package/server/graphql/resolvers/product-combination/product-combination-query.ts

@@ -1,25 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { convertListParams, ListParam } from '@things-factory/shell'
-
-import { ProductCombination as ProductCombinationEntity } from '../../../entities'
-
-export const Query = {
-  async productCombination(_: any, { name }, context: any) {
-    const { domain, user } = context.state
-    const repository = getRepository(ProductCombinationEntity)
-
-    return await repository.findOne({
-      where: { domain, name }
-    })
-  },
-
-  async productCombinations(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(ProductCombinationEntity).findAndCount({
-      ...convertedParams
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/product-combination/update-multiple-product-combination.ts

@@ -1,63 +0,0 @@
-import { PRODUCT_COMBINATION_STATUS } from '../../../constants'
-import { ProductCombination, ProductDetail } from '../../../entities'
-
-export const updateMultipleProductCombination = {
-  async updateMultipleProductCombination(_: any, { productDetailId, patches }, context: any) {
-    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 === '') {
-          newRecord.status = PRODUCT_COMBINATION_STATUS.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
-  }
-}

package/server/graphql/resolvers/product-combination/update-product-combination.ts

@@ -1,20 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ProductCombination } from '../../../entities'
-
-export const updateProductCombination = {
-  async updateProductCombination(_: any, { id, patch }, context: any) {
-    const { domain, user } = context.state
-
-    const repository = getRepository(ProductCombination)
-    const productCombination = await repository.findOne({
-      where: { domain, id }
-    })
-
-    return await repository.save({
-      ...productCombination,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/product-combination-setting/create-product-combination-setting.ts

@@ -1,15 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ProductCombinationSetting } from '../../../entities'
-
-export const createProductCombinationSetting = {
-  async createProductCombinationSetting(_: any, { productCombinationSetting }, context: any) {
-    const { user } = context.state
-
-    return await getRepository(ProductCombinationSetting).save({
-      ...productCombinationSetting,
-      creator: user,
-      updater: user
-    })
-  }
-}