@things-factory/product-base 3.7.13 → 3.8.3

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

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

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

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

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

@@ -1,21 +0,0 @@
-import { createProductCombinationSetting } from './create-product-combination-setting'
-import { deleteProductCombinationSetting } from './delete-product-combination-setting'
-import { deleteProductCombinationSettings } from './delete-product-combination-settings'
-import { linkProductCombination } from './link-product-combination'
-import { productCombinationSets } from './product-combination-sets'
-import { Query } from './product-combination-setting-query'
-import { updateMultipleProductCombinationSetting } from './update-multiple-product-combination-setting'
-
-export const ProductCombinationSettingResolver = {
-  Query: {
-    ...Query,
-    ...productCombinationSets
-  },
-  Mutation: {
-    ...updateMultipleProductCombinationSetting,
-    ...createProductCombinationSetting,
-    ...deleteProductCombinationSetting,
-    ...deleteProductCombinationSettings,
-    ...linkProductCombination
-  }
-}

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

@@ -1,88 +0,0 @@
-import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { ProductCombinationSetting } from '../../../entities'
-import { updateMultipleProductCombinationSetting } from './update-multiple-product-combination-setting'
-
-const debug = require('debug')('things-factory:product-base:productCombinationSetting')
-
-export const linkProductCombination = {
-  async linkProductCombination(_: any, { productCombinationId, patches }, context: any) {
-    try {
-      const { domain, tx }: { domain: Domain; tx: EntityManager } = 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, tx)
-      }
-
-      if (removeCombinationLink.length > 0) {
-        await tx.getRepository(ProductCombinationSetting).delete({
-          id: In(removeCombinationLink.map(combinationLink => combinationLink.id))
-        })
-      }
-    } catch (error) {
-      debug('link-product-combination', error)
-      throw error
-    }
-  }
-}

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

@@ -1,16 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { ProductCombination, ProductCombinationSetting } from '../../../entities'
-
-export const Query = {
-  async productCombinationSettings(_: any, { productCombinationId }, context: any) {
-    const productCombination: ProductCombination = await getRepository(ProductCombination).findOne({
-      where: { id: productCombinationId },
-      relations: ['productCombinationSetting']
-    })
-
-    const productCombinationSettings: ProductCombinationSetting[] = productCombination.productCombinationSettings
-
-    return productCombinationSettings
-  }
-}

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

@@ -1,47 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { ProductCombinationSetting } from '../../../entities'
-
-export const updateMultipleProductCombinationSettingResolver = {
-  async updateMultipleProductCombinationSetting(_: any, { patches }, context: any) {
-    await updateMultipleProductCombinationSetting(patches)
-  }
-}
-
-export async function updateMultipleProductCombinationSetting(
-  patches: ProductCombinationSetting[],
-  tx?: EntityManager
-): Promise<ProductCombinationSetting[]> {
-  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
-      })
-
-      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({ id: newRecord.id })
-
-      const result = await productCombinationSettingRepo.save({
-        ...productCombinationSetting,
-        ...newRecord
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}

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

@@ -1,27 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ProductDetail } from '../../../entities'
-
-export const createProductDetailResolver = {
-  async createProductDetail(_: any, { productDetail }, context: any) {
-    const { domain, user } = context.state
-
-    return await getRepository(ProductDetail).save({
-      ...productDetail,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-}
-
-export async function createProductDetail(productDetail: any, context: any) {
-  const { domain, user, tx } = context.state
-
-  return await tx.getRepository(ProductDetail).save({
-    ...productDetail,
-    domain,
-    creator: user,
-    updater: user
-  })
-}
-

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

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

package/server/graphql/resolvers/product-detail/delete-product-details.ts

@@ -1,16 +0,0 @@
-import { getRepository, In } from 'typeorm'
-import { ProductDetail } from '../../../entities'
-
-export const deleteProductDetailsResolver = {
-  async deleteProductDetails(_: any, { names }, context: any) {
-    const { domain, user } = context.state
-
-    await getRepository(ProductDetail).delete({ 
-        domain,
-        name: In(names)
-    })
-    
-    return true
-  }
-}
-

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

@@ -1,19 +0,0 @@
-import { Query, ProductDetail } from './product-detail-query'
-
-import { updateProductDetailResolver, updateProductDetail } from './update-product-detail'
-import { updateMultipleProductDetailResolver, updateMultipleProductDetail } from './update-multiple-product-detail'
-import { createProductDetailResolver, createProductDetail } from './create-product-detail'
-import { deleteProductDetailResolver } from './delete-product-detail'
-import { deleteProductDetailsResolver } from './delete-product-details'
-
-export const ProductDetailResolver = {
-  ProductDetail,
-  Query,
-  Mutation: {
-    ...updateProductDetailResolver,
-    ...updateMultipleProductDetailResolver,
-    ...createProductDetailResolver,
-    ...deleteProductDetailResolver,
-    ...deleteProductDetailsResolver
-  }
-}

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

@@ -1,157 +0,0 @@
-import { getRepository, In, Raw } from 'typeorm'
-import { Product, ProductDetail } from '../../../entities'
-import _ from 'lodash'
-
-export const updateMultipleProductDetailResolver = {
-  async updateMultipleProductDetail(_: any, { productId, patches }, context: any) {
-    try {      
-      await updateMultipleProductDetail(productId, patches, context)
-      
-    } catch (error) {
-      throw error
-    }
-  }
-}
-
-export async function updateMultipleProductDetail(productId, patches, context: any) {
-  try {    
-    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 _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    const productRepo = tx.getRepository(Product)
-    const productDetailRepo = tx.getRepository(ProductDetail)
-
-    const product: Product = await productRepo.findOne({where:{id: productId},relations: ['productDetails'] })
-
-    const defaultProductDetail: ProductDetail = patches.find(x=>x.isDefault)
-
-    if (_createRecords.length > 0) {
-        for (let i = 0; i < _createRecords.length; i++) {
-          const newRecord = {
-            ..._createRecords[i],
-            name: _createRecords[i].gtin,
-            product,
-            childProductDetail: null,
-            childQty: 0,
-            domain: domain,
-            creator: user,
-            updater: user,
-          }
-          
-          if(newRecord.gtin == null || newRecord.gtin == undefined){
-            throw new Error('GTIN cannot be empty.')
-          }
-
-          const result = await productDetailRepo.save(newRecord)
-          
-          results.push({ ...result, cuFlag: '+' })
-        }
-    }
-
-    let deleteIds = []
-    for (let x = 0; x < product.productDetails.length; x++) {
-      let updateRecords = _updateRecords.find(ur => ur.id == product.productDetails[x].id)
-
-      if(updateRecords){
-        const productDetail: ProductDetail = await productDetailRepo.findOne({ id: updateRecords.id })
-
-        const updateRecord = {
-          ...productDetail,
-          ...updateRecords,
-          name: updateRecords.gtin,
-          product,
-          childProductDetail: null,
-          childQty: 0,
-          updater: user
-        }
-
-        if(updateRecord.gtin == '' || updateRecord.gtin == null || updateRecord.gtin == undefined){
-          throw new Error('GTIN cannot be empty.')
-        }
-
-        const result = await productDetailRepo.save({
-          ...productDetail,
-          ...updateRecord,
-          name: updateRecord.gtin,
-          product,
-          childProductDetail: null,
-          childQty: 0,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }else{
-        deleteIds.push(product.productDetails[x].id)
-      }      
-    }
-
-    await productDetailRepo.delete({id: In(deleteIds)});
-    
-    for await (let patch of patches.filter(x=> x.childProductDetail)) {
-      let matchedChildProductDetail = results.find(itm=> itm.gtin == patch.childProductDetail)
-
-      if(matchedChildProductDetail){
-        const childProductDetail: ProductDetail = await productDetailRepo.findOne({where: { id: matchedChildProductDetail.id }, relations: ['product'] })
-        const productDetail: ProductDetail = await productDetailRepo.findOne({where: { gtin: patch.gtin, product: childProductDetail.product } })
-
-        await productDetailRepo.save({
-          ...productDetail,
-          childQty: patch.childQty,
-          childProductDetail: childProductDetail,
-          updater: user
-        })
-      }
-    }
-
-    let defaultProductUpdate:Product
-
-    //// Temporary solution, to fetch the first case packing type of SKU and update Case data in Product Table.
-    //// To be removed    
-    let firstCase:ProductDetail = await productDetailRepo.findOne({
-      where: { product: product, packingType: Raw(alias =>`lower(${alias}) = 'case'`)},
-      order: {
-        name: "ASC",
-      }
-    })
-    if (firstCase){
-      defaultProductUpdate = {
-        ...defaultProductUpdate,
-        caseGtin: firstCase.gtin,
-        caseWidth: firstCase.width,
-        caseHeight: firstCase.height,
-        caseDepth: firstCase.depth,
-        caseGrossWeight: firstCase.grossWeight,
-        caseWeight: firstCase.nettWeight,
-        caseVolume: firstCase.volume
-      }
-    }
-    /////////////////////////////////////////////////////
-
-    if(defaultProductDetail.isDefault){
-      defaultProductUpdate = {
-        ...defaultProductUpdate,
-        packingType: defaultProductDetail.packingType,
-        primaryUnit: defaultProductDetail.uom,
-        primaryValue: defaultProductDetail.uomValue,
-        cogsAccountCode: defaultProductDetail.cogsAccountCode
-      }
-    }
-
-    if(!_.isEmpty(defaultProductUpdate)){
-      await productRepo.update(
-        {
-          id: product.id
-        },
-        defaultProductUpdate
-      )
-    }
-
-    return results
-  } catch (error) {
-    throw error
-  }
-}

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

@@ -1,26 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { EntityManager, Repository, getRepository } from 'typeorm'
-import { Product, ProductDetail } from '../../../entities'
-
-export const updateProductDetailResolver = {
-  async updateProductDetail(_: any, { id, patch }, context: any) {
-    return await updateProductDetail(id, patch, context)
-  }
-}
-
-export async function updateProductDetail(id: string, patch: any, context: any) {
-  const { domain, user, tx } = context.state
-
-  const repository = tx.getRepository(ProductDetail)
-  const productDetail: ProductDetail = await repository.findOne({where: { id }})
-
-  if(patch.gtin == undefined){
-    delete patch.gtin
-  }
-
-  return await repository.save({
-    ...productDetail,
-    ...patch,
-    updater: user
-  })
-}

package/server/graphql/resolvers/product-detail-bizplace-setting/create-product-detail-bizplace-setting.ts

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

package/server/graphql/resolvers/product-detail-bizplace-setting/delete-product-detail-bizplace-setting.ts

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

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

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

package/server/graphql/resolvers/product-detail-bizplace-setting/index.ts

@@ -1,19 +0,0 @@
-import { Query, ProductDetailBizplaceSetting } from './product-detail-bizplace-setting-query'
-
-import { updateProductDetailBizplaceSetting } from './update-product-detail-bizplace-setting'
-import { updateMultipleProductDetailBizplaceSetting } from './update-multiple-product-detail-bizplace-setting'
-import { createProductDetailBizplaceSetting } from './create-product-detail-bizplace-setting'
-import { deleteProductDetailBizplaceSetting } from './delete-product-detail-bizplace-setting'
-import { deleteProductDetailBizplaceSettings } from './delete-product-detail-bizplace-settings'
-
-export const ProductDetailBizplaceSettingResolver = {
-  ProductDetailBizplaceSetting,
-  Query,
-  Mutation: {
-    ...updateProductDetailBizplaceSetting,
-    ...updateMultipleProductDetailBizplaceSetting,
-    ...createProductDetailBizplaceSetting,
-    ...deleteProductDetailBizplaceSetting,
-    ...deleteProductDetailBizplaceSettings
-  }
-}

package/server/graphql/resolvers/product-detail-bizplace-setting/product-detail-bizplace-setting-query.ts

@@ -1,74 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Domain, ListParam, buildQuery, convertListParams } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ProductDetail as ProductDetailEntity, ProductDetailBizplaceSetting as ProductDetailBizplaceSettingEntity } from '../../../entities'
-
-export const Query = {
-  async productDetailBizplaceSetting(_: any, { name }, context: any) {
-    const { domain, user } = context.state
-    const repository = getRepository(ProductDetailBizplaceSettingEntity)
-
-    return await repository.findOne({
-      where: { domain, name }
-    })
-  },
-
-  async productDetailBizplaceSettings(_: any, params: ListParam, context: any) {
-    const { domain, user: updater }: { domain: Domain; user: User } = context.state
-
-    const queryBuilder = getRepository(ProductDetailEntity).createQueryBuilder('productDetail')
-
-    buildQuery(queryBuilder, params, context, false)
-    
-    let qb = queryBuilder.leftJoinAndSelect('productDetail.productDetailBizplaceSettings', 'pdbs',
-      '"pdbs"."product_detail_id"="productDetail"."id"')
-      .leftJoinAndSelect('productDetail.domain', 'domain')
-      .leftJoinAndSelect('productDetail.creator', 'creator')
-      .leftJoinAndSelect('productDetail.updater', 'updater')
-
-    // qb.andWhere('pdbs.bizplace_id = :bizplaceId', { bizplaceId: bizplace.id })
-
-    const [items, total] = await qb.getManyAndCount()
-
-    return { items: items.map(itm=>{
-      let productDetailBizplaceSetting = itm.productDetailBizplaceSettings[0]
-
-      return {
-        requirePacking: false,
-        bufferQty: 0,
-        minQty: 0,
-        maxQty: 0,
-        productDetail: itm ,
-        ...(productDetailBizplaceSetting ? productDetailBizplaceSetting : {})
-      }
-    }), total }
-
-    // const convertedParams = convertListParams(params)
-    // const [items, total] = await getRepository(ProductDetailBizplaceSettingEntity).findAndCount({
-    //   ...convertedParams
-    // })
-    
-    // return { items, total }
-  }
-}
-
-export const ProductDetailBizplaceSetting = {
-  async domain(productDetailBizplaceSetting) {
-    return (await getRepository(ProductDetailBizplaceSettingEntity).findOne(productDetailBizplaceSetting.id, {
-      relations: ['domain']
-    }))?.domain
-  },
-
-  async creator(productDetailBizplaceSetting) {
-    return (await getRepository(ProductDetailBizplaceSettingEntity).findOne(productDetailBizplaceSetting.id, {
-      relations: ['creator']
-    }))?.creator
-  },
-
-  async updater(productDetailBizplaceSetting) {
-    return (await getRepository(ProductDetailBizplaceSettingEntity).findOne(productDetailBizplaceSetting.id, {
-      relations: ['updater']
-    }))?.updater
-  }
-}

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

@@ -1,57 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Bizplace } from '@things-factory/biz-base'
-import { ProductDetailBizplaceSetting, ProductDetail } from '../../../entities'
-
-export const updateMultipleProductDetailBizplaceSetting = {
-  async updateMultipleProductDetailBizplaceSetting(_: any, { 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 productDetailBizplaceSettingRepo = tx.getRepository(ProductDetailBizplaceSetting)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-        delete newRecord.id
-        
-        const productDetail = await tx.getRepository(ProductDetail).findOne(newRecord.productDetail.id)
-        
-        if(productDetail){
-          const result = await productDetailBizplaceSettingRepo.save({
-            ...newRecord,
-            name: productDetail.gtin,
-            productDetail,
-            domain: 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 productDetailBizplaceSetting = await productDetailBizplaceSettingRepo.findOne({ domain, id: newRecord.id})
-          const productDetail = await tx.getRepository(ProductDetail).findOne(newRecord.productDetail.id)
-
-          const result = await productDetailBizplaceSettingRepo.save({
-            ...productDetailBizplaceSetting,
-            ...newRecord,
-            name: productDetail.gtin,
-            productDetail,
-            updater: user
-          })
-
-          results.push({ ...result, cuFlag: 'M' })
-        }
-    }
-  
-    return results
-  }
-}
-