@things-factory/product-base 3.7.13 → 3.8.3

package/server/entities/product-combination.ts

@@ -1,78 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { Product, ProductCombinationSetting, ProductDetail } from './'
-
-@Entity()
-@Index(
-  'ix_product_combination_0',
-  (productCombination: ProductCombination) => [productCombination.domain, productCombination.id],
-  {
-    unique: true
-  }
-)
-export class ProductCombination {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @OneToMany(
-    type => ProductCombinationSetting,
-    productCombinationSetting => productCombinationSetting.productCombination
-  )
-  productCombinationSettings: ProductCombinationSetting[]
-
-  @ManyToOne(type => Product)
-  product: Product
-
-  @ManyToOne(type => ProductDetail, {
-    nullable: false
-  })
-  productDetail: ProductDetail
-
-  @Column()
-  name: string
-
-  @Column({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  status: string
-
-  @Column({ nullable: true })
-  deletedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  deletedBy: User
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/entities/product-set.ts

@@ -1,65 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, OneToMany, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
-import { User } from '@things-factory/auth-base'
-import { Product } from './'
-
-@Entity()
-@Index('ix_product_set_0', (productSet: ProductSet) => [productSet.bizplace, productSet.name], { unique: true })
-export class ProductSet {
-
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @ManyToOne(type => Bizplace, {
-    nullable: false
-  })
-  bizplace: Bizplace
-
-  @Column({ nullable: true })
-  code: string
-
-  @Column()
-  name: string
-  
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @OneToMany(
-    type => Product,
-    product => product.productSet,
-    {
-      nullable: true
-    }
-  )
-  product: Product[]
-
-  @Column({
-    nullable: true, default: 'ACTIVE'
-  })
-  status: string
-  
-  @Column()
-  type: string
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/graphql/index.ts

@@ -1,9 +0,0 @@
-import { deepMerge } from '@things-factory/utils'
-
-import * as resolvers from './resolvers'
-import * as typeDefs from './types'
-
-export const schema = {
-  typeDefs,
-  resolvers: deepMerge.apply(null, Object.values(resolvers))
-}

package/server/graphql/resolvers/index.ts

@@ -1,8 +0,0 @@
-export * from './product-bundle-setting'
-export * from './product-bundle'
-export * from './product-set'
-export * from './product'
-export * from './product-detail'
-export * from './product-detail-bizplace-setting'
-export * from './product-combination'
-export * from './product-combination-setting'

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

@@ -1,78 +0,0 @@
-import { EntityManager, getRepository, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { Product, ProductDetail } from '../../../entities'
-import { updateMultipleProductDetail } from '../product-detail/update-multiple-product-detail'
-import { validateProduct } from './validate-product'
-
-export const createProductResolver = {
-  async createProduct(_: any, { product }, context: any) {
-    return await createProduct(product, context)
-  }
-}
-
-export async function createProduct(product: any, context: any) {
-  try {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const productRepo: Repository<Product> = tx.getRepository(Product) || getRepository(Product)
-    const bizplaceRepo: Repository<Bizplace> = tx.getRepository(Bizplace) || getRepository(Bizplace)
-
-    let bizplace: Bizplace
-    if (product.bizplace?.id) {
-      bizplace = await bizplaceRepo.findOne(product.bizplace.id)
-    } else if (context.state?.bizplace) {
-      bizplace = context.state.bizplace
-    } else {
-      bizplace = await bizplaceRepo.findOne({ where: { domain } })
-    }
-
-    if (product?.productRef?.id) {
-      product.productRef = await productRepo.findOne(product.productRef.id)
-    }
-
-    if (!product?.id) delete product.id
-
-    await validateProduct(
-      {
-        ...product,
-        bizplace,
-        domain
-      },
-      context
-    )
-
-    if (product.uom) {
-      product.primaryUnit = product.uom
-    }
-
-    if (product.uomValue) {
-      product.primaryValue = product.uomValue
-    }
-
-    const result = await productRepo.save({
-      ...product,
-      bizplace,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    let productDetails = product.productDetails
-    if (!productDetails) {
-      productDetails = [new ProductDetail({ ...product, product: result, isDefault: true })]
-      if (productDetails[0].gtin == null || productDetails[0] == undefined) {
-        productDetails[0].gtin = product.sku
-      }
-    }
-
-    await updateMultipleProductDetail(result.id, productDetails, context)
-
-    return result
-  } catch (error) {
-    throw error
-  }
-}

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

@@ -1,21 +0,0 @@
-import promisesAll from 'promises-all'
-import { createProduct } from './create-product'
-import { logger } from '@things-factory/env'
-
-export const createProductsResolver = {
-  async createProducts(_: any, { products }, context: any) {
-    return await createProducts(products, context)
-  }
-}
-
-export async function createProducts(products, context: any) {
-  const { resolve, reject } = await promisesAll.all(products.map(product => createProduct(product, context)))
-
-  if (reject.length) {
-    reject.forEach(({ name, message }) => logger.error(`${name}: ${message}`))
-
-    return reject
-  }
-
-  return resolve
-}

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

@@ -1,19 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-import { Product } from '../../../entities'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { PRODUCT_STATUS } from '../../../constants'
-
-export const deleteProduct = {
-  async deleteProduct(_: any, { name }, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-    const productSetRepo: Repository<Product> = tx.getRepository(Product)
-    const productSet = await productSetRepo.findOne({domain, name})
-
-    return await productSetRepo.save({
-      ...productSet,
-      status: PRODUCT_STATUS.DELETED,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/product/delete-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 deleteProducts = {
-  async deleteProducts(_: 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: new Date()
-      }
-    )
-  }
-}

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

@@ -1,34 +0,0 @@
-import { Product, ProductDetail } from '../../../entities'
-import { createProduct } from './create-product'
-
-export const importMultipleProduct = {
-  async importMultipleProduct(_: any, { patches }, context: any): Promise<any> {
-    try {
-      let results = []
-
-      //// 1. Group and massage data based on sku for Product and Product Details.
-      let massagedPatch = patches.reduce(function(acc, currentObj) {
-        let existingParent = acc.find(itm => itm.sku == currentObj.sku)
-        if(existingParent){
-          existingParent.productDetails = [...existingParent.productDetails, new ProductDetail({...currentObj, childProductDetail: currentObj.childGtin})]
-          return acc
-        }else{
-          let newProduct = {...currentObj, productDetails: [new ProductDetail({...currentObj, childProductDetail: currentObj.childGtin, isDefault: true})]}
-          return [...acc, newProduct]
-        }
-      }, [])
-
-
-      //// 2. Update all Grouped Product data and Product Details Data
-      for (let i = 0; i < massagedPatch.length; i++) {
-        const patch: Product = massagedPatch[i]
-        const result = await createProduct(patch, context)
-        results.push({ ...result, cuFlag: '+' })
-      }
-  
-      return results      
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,32 +0,0 @@
-import { Query } from './product-query'
-
-import { createProductResolver } from './create-product'
-import { createProductsResolver } from './create-products'
-import { deleteProduct } from './delete-product'
-import { deleteProducts } from './delete-products'
-import { undeleteProducts } from './undelete-products'
-import { linkProductResolver } from './link-product'
-import { myBizplaceProducts } from './my-bizplace-products'
-import { productsByBizplace } from './products-by-bizplace'
-import { importMultipleProduct } from './import-multiple-product'
-import { updateMultipleProduct } from './update-multiple-product'
-import { updateProductResolver } from './update-product'
-
-export const ProductResolver = {
-  Query: {
-    ...Query,
-    ...myBizplaceProducts,
-    ...productsByBizplace
-  },
-  Mutation: {
-    ...createProductResolver,
-    ...createProductsResolver,
-    ...deleteProduct,
-    ...deleteProducts,
-    ...undeleteProducts,
-    ...importMultipleProduct,
-    ...updateMultipleProduct,
-    ...updateProductResolver,
-    ...linkProductResolver
-  }
-}

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

@@ -1,46 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Product, ProductSet } from '../../../entities'
-import { updateProduct } from './update-product'
-
-export const linkProductResolver = {
-  async linkProduct(_: any, { productSetId, patches }, context: any): Promise<any> {
-    const { tx }: { tx: EntityManager } = context.state
-
-    let productSet = await tx.getRepository(ProductSet).findOne({
-      where: { id: productSetId },
-      relations: ['domain', 'creator', 'updater', 'product']
-    })
-
-    let existingProductLink: any = productSet.product
-
-    let newProductLink: Product[] = patches.reduce((acc, curr) => {
-      if (!existingProductLink.find(itm => itm.id == curr.id)) {
-        acc.push({ id: curr.id })
-      }
-      return acc
-    }, [])
-
-    let removeProductLink: Product[] = existingProductLink.reduce((acc, curr) => {
-      if (!patches.find(itm => itm.id == curr.id)) {
-        acc.push({ id: curr.id })
-      }
-      return acc
-    }, [])
-
-    if (newProductLink.length > 0) {
-      for (let i = 0; i < newProductLink.length; i++) {
-        const patch: Product = { ...newProductLink[i], productSet }
-        await updateProduct(newProductLink[i].id, patch, context)
-      }
-    }
-
-    if (removeProductLink.length > 0) {
-      for (let i = 0; i < removeProductLink.length; i++) {
-        const patch: Product = { ...removeProductLink[i], productSet: null }
-        await updateProduct(removeProductLink[i].id, patch, context)
-      }
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/product/my-bizplace-products.ts

@@ -1,66 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
-import { buildCondition, buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
-import { Product, ProductDetail } from '../../../entities'
-
-export const myBizplaceProducts = {
-  async myBizplaceProducts(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const qb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder()
-
-    const productFilters = params.filters.filter(x => x.name == 'product_info')
-    const deletedFilter = params.filters.find(x => x.name == 'deleted')
-    const filters = params.filters.filter(x => x.name != 'product_info' && x.name != 'deleted')
-    const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
-
-    if (!params.filters.find(filter => filter.name === 'bizplace_id')) {
-      // const companyBizplace: Bizplace = await getCompanyBizplace(domain, user)
-      let bizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { domain } })
-      params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [bizplace.id] }]
-    }
-    
-    params.filters =[...params.filters, { name: 'deletedAt', operator: deletedFilter?.value ? 'is_not_null' : 'is_null'}]
-
-    buildQuery(qb, params, context, false)
-    if (productFilters && productFilters.length > 0) {
-      let productInfo = productFilters[0]
-      qb.andWhere(
-        new Brackets(qb2 => {
-          productFilterColumns.forEach(filter => {
-            const condition = buildCondition(
-              qb.alias,
-              filter,
-              productInfo.operator,
-              productInfo.value,
-              productInfo.relation,
-              Object.keys(qb.getParameters()).length
-            )
-
-            qb2.orWhere(condition.clause, condition.parameters)
-          })
-        })
-      )
-    }
-
-    let [items, total] = await qb
-      .leftJoinAndSelect('Product.bizplace', 'Bizplace')
-      .leftJoinAndSelect('Product.productRef', 'ProductRef')
-      .leftJoinAndSelect('Product.parentProductRef', 'ParentProductRef')
-      .leftJoinAndSelect('Product.productDetails', 'ProductDetails')
-      .leftJoinAndSelect('Product.creator', 'Creator')
-      .leftJoinAndSelect('Product.updater', 'Updater')
-      .getManyAndCount()
-
-    items = items.map(itm=> {
-      let defaultProductDetail = itm.productDetails.find(itm=>itm.isDefault)
-      return {
-        ...itm,
-        ...new ProductDetail(defaultProductDetail, true)
-      }
-    })
-
-    return { items, total }
-  }
-}

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

@@ -1,117 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import {
-  Bizplace,
-  getCompaniesBizplaces,
-  getPartnersCompanyBizplaces,
-  getPermittedBizplaceIds
-} from '@things-factory/biz-base'
-import { buildCondition, buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { Brackets, getRepository, SelectQueryBuilder, In } from 'typeorm'
-import { Product as ProductEntity } from '../../../entities'
-
-export const Query = {
-  async product(_: any, { sku }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    if (context?.state?.bizplace) {
-      return await getRepository(ProductEntity).findOne({
-        where: {
-          domain: domain,
-          sku,
-          bizplace: context.state.bizplace
-        },
-        relations: ['domain', 'bizplace', 'productRef', 'creator', 'updater']
-      })
-    } else {
-      return await getRepository(ProductEntity).findOne({
-        where: {
-          domain: domain,
-          sku,
-          bizplace: In(await getPermittedBizplaceIds(domain, user))
-        },
-        relations: ['domain', 'bizplace', 'productRef', 'creator', 'updater']
-      })
-    }
-  },
-
-  async products(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-    const { domains }: { domains: Domain[] } = user
-
-    const qb: SelectQueryBuilder<ProductEntity> = getRepository(ProductEntity).createQueryBuilder()
-
-    const productFilters = params.filters.filter(x => x.name == 'product_info')
-    const filters = params.filters.filter(x => x.name != 'product_info')
-    const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace_id')) {
-      const warehouseDomain: Domain = domain
-      const companiesBizplaces: Bizplace[] = await getCompaniesBizplaces(domains, warehouseDomain)
-      const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
-
-      const companyBizIds: string[] = companiesBizplaces.map((biz: Bizplace) => biz.id)
-
-      params.filters = [
-        ...filters,
-        {
-          name: 'bizplace_id',
-          operator: 'in',
-          value: [...companyBizIds, ...partnersCompanyBizplaces.map(biz => biz.id)]
-        }
-      ]
-    } else {
-      const bizplaceId: string[] = params.filters.filter(param => param.name == 'bizplace_id').map(item => item.value)
-
-      const foundBizplace: Bizplace = await getRepository(Bizplace).findOne({
-        where: { id: bizplaceId[0] },
-        relations: ['company', 'company.domain']
-      })
-
-      if (foundBizplace) {
-        const companyDomain: Domain = foundBizplace.company?.domain
-        const companyBizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-
-        params.filters
-          .filter(x => x.name == 'bizplace_id')
-          .map(itm => {
-            itm.operator = 'in'
-            itm.value = [companyBizplace.id, foundBizplace.id]
-          })
-      }
-    }
-
-    params.filters = [...filters, { name: 'deletedAt', operator: 'is_null' }]
-
-    buildQuery(qb, params, context, false)
-    if (productFilters && productFilters.length > 0) {
-      let productInfo = productFilters[0]
-      qb.andWhere(
-        new Brackets(qb2 => {
-          productFilterColumns.forEach(filter => {
-            const condition = buildCondition(
-              qb.alias,
-              filter,
-              productInfo.operator,
-              productInfo.value,
-              productInfo.relation,
-              Object.keys(qb.getParameters()).length
-            )
-
-            qb2.orWhere(condition.clause, condition.parameters)
-          })
-        })
-      )
-    }
-
-    let [items, total] = await qb
-      .leftJoinAndSelect('Product.bizplace', 'Bizplace')
-      .leftJoinAndSelect('Product.productRef', 'ProductRef')
-      .leftJoinAndSelect('Product.productDetails', 'ProductDetails')
-      .leftJoinAndSelect('ProductDetails.childProductDetail', 'ChildProductDetail')
-      .leftJoinAndSelect('Product.creator', 'Creator')
-      .leftJoinAndSelect('Product.updater', 'Updater')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/product/products-by-bizplace.ts

@@ -1,79 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getCompanyBizplace, getMyBizplace } from '@things-factory/biz-base'
-import { buildCondition, convertListParams, buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, Brackets } from 'typeorm'
-import { Product, ProductDetail } from '../../../entities'
-
-export const productsByBizplace = {
-  async productsByBizplace(_: any, params: ListParam, context: any) {
-
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const qb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder()
-
-    const productFilters = params.filters.filter(x => x.name == 'product_info')
-    const bizplaceFilter = params.filters.find(x => x.name == 'bizplace')
-    const deletedFilter = params.filters.find(x => x.name == 'deleted')
-    const filters = params.filters.filter(x => x.name != 'product_info' && x.name!= 'bizplace' && x.name != 'deleted')
-    const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
-
-    let companyBizplace: Bizplace, myBizplace: Bizplace
-    if (!bizplaceFilter || bizplaceFilter.value == '') {
-      myBizplace = await getMyBizplace(domain, user)
-      companyBizplace = await getCompanyBizplace(domain, user)
-    } else {
-      myBizplace = await getRepository(Bizplace).findOne(bizplaceFilter.value, {
-        relations: ['company', 'company.domain']
-      })
-      companyBizplace = await getRepository(Bizplace).findOne({
-        where: { domain: myBizplace.company.domain }
-      })
-    }
-
-    params.filters = [
-      ...filters,
-      { name: 'deletedAt', operator: deletedFilter?.value ? 'is_not_null' : 'is_null'},,
-      { name: 'bizplace_id', operator: 'in', value: [companyBizplace.id, myBizplace.id] }
-    ]
-
-    buildQuery(qb, params, context, false)
-    if (productFilters && productFilters.length > 0) {
-      let productInfo = productFilters[0]
-      qb.andWhere(
-        new Brackets(qb2 => {
-          productFilterColumns.forEach(filter => {
-            const condition = buildCondition(
-              qb.alias,
-              filter,
-              productInfo.operator,
-              productInfo.value,
-              productInfo.relation,
-              Object.keys(qb.getParameters()).length
-            )
-
-            qb2.orWhere(condition.clause, condition.parameters)
-          })
-        })
-      )
-    }
-
-    let [items, total] = await qb
-      .leftJoinAndSelect('Product.bizplace', 'Bizplace')
-      .leftJoinAndSelect('Product.productRef', 'ProductRef')
-      .leftJoinAndSelect('Product.parentProductRef', 'ParentProductRef')
-      .leftJoinAndSelect('Product.productDetails', 'ProductDetails')
-      .leftJoinAndSelect('Product.creator', 'Creator')
-      .leftJoinAndSelect('Product.updater', 'Updater')
-      .getManyAndCount()
-
-    items = items.map(itm=> {
-      let defaultProductDetail = itm.productDetails.find(itm=>itm.isDefault)
-      return {
-        ...itm,
-        ...new ProductDetail(defaultProductDetail, true)
-      }
-    })
-
-    return { items, total }
-  }
-}