@things-factory/product-base 8.0.0-beta.9 → 8.0.2

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

@@ -0,0 +1,238 @@
+import _ from 'lodash'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Raw } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { Product } from '../product/product'
+import { ProductDetail } from './product-detail'
+import { ProductDetailPatch } from './product-detail-types'
+
+@Resolver(ProductDetail)
+export class ProductDetailMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ProductDetail)
+  async updateProductDetail(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProductDetailPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductDetail> {
+    return await updateProductDetail(id, patch, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ProductDetail])
+  async updateMultipleProductDetail(
+    @Arg('productId') productId: string,
+    @Arg('patches', type => [ProductDetailPatch]) patches: ProductDetailPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ProductDetail[]> {
+    try {
+      return await updateMultipleProductDetail(productId, patches, context)
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteProductDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, user } = context.state
+
+    await getRepository(ProductDetail).delete({ domain: { id: domain.id }, name })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteProductDetails(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, user } = context.state
+
+    await getRepository(ProductDetail).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+
+    return true
+  }
+}
+
+export async function createProductDetail(productDetail: any, context: ResolverContext) {
+  const { domain, user, tx } = context.state
+
+  return await tx.getRepository(ProductDetail).save({
+    ...productDetail,
+    domain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateProductDetail(id: string, patch: any, context: ResolverContext) {
+  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
+  })
+}
+
+export async function updateMultipleProductDetail(productId, patches, context: ResolverContext) {
+  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.findOneBy({ 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: { id: childProductDetail.product.id } }
+        })
+
+        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: { id: product.id }, 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) {
+      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/service/product-detail/product-detail-query.ts

@@ -0,0 +1,213 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCompaniesBizplaces, getPartnersCompanyBizplaces } from '@things-factory/biz-base'
+import { buildCondition, buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
+import { ProductDetail } from './product-detail'
+import { ProductDetailList } from './product-detail-types'
+
+@Resolver(ProductDetail)
+export class ProductDetailQuery {
+  @Directive('@transaction')
+  @Query(returns => ProductDetail)
+  async productDetail(
+    @Arg('gtin') gtin: string,
+    @Arg('productId') productId: string,
+    @Arg('customerCompanyDomainId') customerCompanyDomainId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductDetail> {
+    const { tx } = context.state
+
+    const customerDomain = await tx.getRepository(Domain).findOneBy({ id: customerCompanyDomainId })
+    if (!customerDomain) {
+      throw new Error('Unable to find company domain')
+    }
+
+    var foundProductDetail
+    if (productId) {
+      foundProductDetail = await tx.getRepository(ProductDetail).findOne({
+        where: { domain: { id: customerDomain.id }, product: { id: productId } },
+        relations: ['product']
+      })
+    } else {
+      foundProductDetail = await tx.getRepository(ProductDetail).findOne({
+        where: { domain: { id: customerDomain.id }, gtin },
+        relations: ['product']
+      })
+    }
+
+    if (!foundProductDetail) throw new Error('No product candidate found')
+
+    return foundProductDetail
+  }
+
+  @Query(returns => ProductDetailList)
+  async productDetails(
+    @Ctx() context: ResolverContext,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<ProductDetailList> {
+    const { domain, user } = context.state
+    const { domains } = user
+
+    const params = { filters, pagination }
+    const productInfoFilters = params.filters.find(x => x.name == 'product_info' || x.name == 'sku' || x.name == 'name' || x.name == 'description' || x.name == 'type')
+
+    const bizplaceFilter = params.filters.find(x => x.name == 'bizplace_id')
+    const productFilter = params.filters.find(x => x.name == 'product')
+    const createArrivalNotice = params.filters.find(x => x.name == 'create_arrival_notice')
+    const productInfoFilterColumns = ['sku', 'name', 'description', 'type', 'brand']
+    params.filters = params.filters.filter(
+      x =>
+        x.name != 'product_info' &&
+        x.name != 'bizplace_id' &&
+        x.name != 'product' &&
+        x.name != 'sku' &&
+        x.name != 'brand' &&
+        x.name != 'name' &&
+        x.name != 'description' &&
+        x.name != 'type' &&
+        x.name != 'create_arrival_notice'
+    )
+
+    const qb: SelectQueryBuilder<ProductDetail> = getRepository(ProductDetail).createQueryBuilder('ProductDetail')
+    qb.innerJoinAndSelect('ProductDetail.product', 'Product', '"Product"."deleted_at" IS NULL')
+    qb.innerJoinAndSelect('Product.bizplace', 'Bizplace')
+    qb.leftJoinAndSelect('ProductDetail.childProductDetail', 'ChildProductDetail')
+    qb.leftJoinAndSelect('Product.creator', 'Creator')
+    qb.leftJoinAndSelect('Product.updater', 'Updater')
+
+    buildQuery(qb, params, context, {
+      domainRef: false,
+      searchables: ['name']
+    })
+
+    if (bizplaceFilter?.value) {
+      const bizplaceId: string = bizplaceFilter.value
+
+      const foundBizplace: Bizplace = await getRepository(Bizplace).findOne({
+        where: { id: bizplaceId } /* CONFIRMME regarding TYPEORM - did I migrate correctly ? */,
+        relations: ['company', 'company.domain']
+      })
+
+      if (foundBizplace) {
+        const companyDomain: Domain = foundBizplace.company?.domain
+        const companyBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { domain: { id: companyDomain.id } }
+        })
+
+        const bizplaceIds = [companyBizplace.id, foundBizplace.id]
+        qb.andWhere('Bizplace.id IN (:...bizplaceIds)', { bizplaceIds: [...new Set(bizplaceIds)] })
+      }
+    } else {
+      const warehouseDomain: Domain = domain
+      let bizplaceIds = []
+      if (warehouseDomain?.extType === 'company') {
+        const companyBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { domain: { id: warehouseDomain.id } }
+        })
+        bizplaceIds.push(companyBizplace.id)
+      } else if (warehouseDomain?.extType === 'factory') {
+        const myBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { domain: { id: warehouseDomain.id } },
+          relations: ['domain']
+        })
+        const companiesBizplaces: Bizplace[] = await getCompaniesBizplaces(domains, warehouseDomain)
+        const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
+        bizplaceIds = [...bizplaceIds, myBizplace.id, ...companiesBizplaces.map(biz => biz.id), ...partnersCompanyBizplaces.map(biz => biz.id)]
+      } else {
+        const companiesBizplaces: Bizplace[] = await getCompaniesBizplaces(domains, warehouseDomain)
+        const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
+        bizplaceIds = [...bizplaceIds, ...companiesBizplaces.map(biz => biz.id), ...partnersCompanyBizplaces.map(biz => biz.id)]
+      }
+
+      qb.andWhere('Product.bizplace_id IN (:...bizplaceIds)', { bizplaceIds: bizplaceIds })
+    }
+
+    if (productFilter?.value) {
+      if (productFilter.operator === 'eq') {
+        qb.andWhere('ProductDetail.product_id = :productId', { productId: productFilter.value })
+      } else if (productFilter.operator === 'in') {
+        qb.andWhere('ProductDetail.product_id in(:...productId)', { productId: productFilter.value })
+      }
+    }
+
+    if (productInfoFilters?.value) {
+      let productInfo = productInfoFilters
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productInfoFilterColumns.forEach(filter => {
+            const condition = buildCondition('Product', filter, productInfo.operator, productInfo.value, productInfo.relation, Object.keys(qb.getParameters()).length)
+
+            qb2.orWhere(condition.clause, condition.parameters)
+          })
+        })
+      )
+    }
+
+    if (createArrivalNotice?.value) {
+      qb.andWhere('(Product.isRequireSerialNumberScanning = false OR (Product.isRequireSerialNumberScanning = true AND ProductDetail.isDefault = true))')
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
+    items = items.map(item => {
+      return {
+        ...item,
+        productId: item.product.id,
+        name: item.product.name,
+        description: item.product.description,
+        type: item.product.type,
+        sku: item.product.sku,
+        isRequireSerialNumberScanningInbound: item.product.isRequireSerialNumberScanningInbound,
+        isRequireSerialNumberScanningOutbound: item.product.isRequireSerialNumberScanningOutbound
+      }
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => ProductDetailList)
+  async checkGtin(
+    @Arg('gtin') gtin: string,
+    @Arg('customerCompanyDomainId') customerCompanyDomainId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductDetailList> {
+    try {
+      const { tx } = context.state
+
+      const customerDomainId: Domain = await getRepository(Domain).findOneBy({ id: customerCompanyDomainId })
+      if (!customerDomainId) throw new Error('Unable to find company domain')
+      var foundProductDetails
+
+      let [items, total] = await getRepository(ProductDetail).findAndCount({
+        where: { domain: { id: customerDomainId.id }, gtin },
+        relations: ['product']
+      })
+
+      if (items?.length <= 0) throw new Error('No product candidate found')
+
+      return { items, total }
+    } catch (e) {
+      throw new Error(e)
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() productDetail: ProductDetail): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: productDetail.domain.id })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() productDetail: ProductDetail): Promise<User> {
+    return await getRepository(User).findOneBy({ id: productDetail.updater.id })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() productDetail: ProductDetail): Promise<User> {
+    return await getRepository(User).findOneBy({ id: productDetail.creator.id })
+  }
+}