@things-factory/product-base 3.7.13 → 3.8.3

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

@@ -0,0 +1,233 @@
+import _ from 'lodash'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { getRepository, In, Raw } from 'typeorm'
+
+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: any
+  ): 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: any
+  ): 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: any): Promise<Boolean> {
+    const { domain, user } = context.state
+
+    await getRepository(ProductDetail).delete({ domain, name })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteProductDetails(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, user } = context.state
+
+    await getRepository(ProductDetail).delete({
+      domain,
+      name: In(names)
+    })
+
+    return true
+  }
+}
+
+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
+  })
+}
+
+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
+  })
+}
+
+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 → service}/product-detail/product-detail-query.ts

@@ -1,29 +1,56 @@
-import { Bizplace, getCompaniesBizplaces, getPartnersCompanyBizplaces } from '@things-factory/biz-base'
-import { buildCondition, Domain, ListParam, buildQuery } from '@things-factory/shell'
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
-import { ProductDetail as ProductDetailEntity } from '../../../entities'
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, getRepository, SelectQueryBuilder, Repository } from 'typeorm'
 
-export const Query = {
-  async productDetail(_: any, { gtin, customerCompanyDomainId }, context: any) {
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCompaniesBizplaces, getPartnersCompanyBizplaces } from '@things-factory/biz-base'
+import { buildQuery, Filter, Pagination, Sorting, buildCondition, Domain } 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: any
+  ): Promise<ProductDetail> {
     const { tx } = context.state
-    const repository = tx.getRepository(ProductDetailEntity)
 
     const customerDomainId: Domain = await tx.getRepository(Domain).findOne(customerCompanyDomainId)
     if (!customerDomainId) throw new Error('Unable to find company domain')
+    var foundProductDetail
+    if (gtin == '') {
+      foundProductDetail = await tx.getRepository(ProductDetail).findOne({
+        where: { domain: customerDomainId, product: productId },
+        relations: ['product']
+      })
+    } else {
+      foundProductDetail = await tx.getRepository(ProductDetail).findOne({
+        where: { domain: customerDomainId, gtin },
+        relations: ['product']
+      })
+    }
 
-    const foundProductDetail = await repository.findOne({
-      where: { domain: customerDomainId, gtin },
-      relations: ['product']
-    })
     if (!foundProductDetail) throw new Error('No product candidate found')
 
     return foundProductDetail
-  },
+  }
 
-  async productDetails(_: any, params: ListParam, context: any) {
+  @Query(returns => ProductDetailList)
+  async productDetails(
+    @Ctx() context: any,
+    @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 }: { domains: Domain[] } = 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'
@@ -46,9 +73,7 @@ export const Query = {
         x.name != 'create_arrival_notice'
     )
 
-    const qb: SelectQueryBuilder<ProductDetailEntity> = getRepository(ProductDetailEntity).createQueryBuilder(
-      'ProductDetail'
-    )
+    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')
@@ -140,30 +165,19 @@ export const Query = {
 
     return { items, total }
   }
-}
 
-export const ProductDetail = {
-  async domain(productDetail) {
-    return (
-      await getRepository(ProductDetailEntity).findOne(productDetail.id, {
-        relations: ['domain']
-      })
-    )?.domain
-  },
+  @FieldResolver(type => Domain)
+  async domain(@Root() productDetail: ProductDetail): Promise<Domain> {
+    return await getRepository(Domain).findOne(productDetail.domain.id)
+  }
 
-  async creator(productDetail) {
-    return (
-      await getRepository(ProductDetailEntity).findOne(productDetail.id, {
-        relations: ['creator']
-      })
-    )?.creator
-  },
+  @FieldResolver(type => User)
+  async updater(@Root() productDetail: ProductDetail): Promise<User> {
+    return await getRepository(User).findOne(productDetail.updater.id)
+  }
 
-  async updater(productDetail) {
-    return (
-      await getRepository(ProductDetailEntity).findOne(productDetail.id, {
-        relations: ['updater']
-      })
-    )?.updater
+  @FieldResolver(type => User)
+  async creator(@Root() productDetail: ProductDetail): Promise<User> {
+    return await getRepository(User).findOne(productDetail.creator.id)
   }
 }

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

@@ -0,0 +1,280 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductDetail } from './product-detail'
+
+@InputType()
+export class NewProductDetail {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  gtin?: string
+
+  @Field({ nullable: true })
+  refCode?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  isDefault: boolean
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  movement?: string
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  childProductDetail?: ObjectRef
+
+  @Field(type => [ObjectRef], { nullable: true })
+  parentProductDetails?: ObjectRef[]
+
+  @Field(type => Float, { nullable: true })
+  childQty?: number
+  weightUnit?: string
+
+  @Field(type => Float, { nullable: true })
+  nettWeight?: number
+
+  @Field(type => Float, { nullable: true })
+  grossWeight?: number
+  lengthUnit?: string
+
+  @Field(type => Float, { nullable: true })
+  width?: number
+
+  @Field(type => Float, { nullable: true })
+  depth?: number
+
+  @Field(type => Float, { nullable: true })
+  height?: number
+
+  @Field(type => Float, { nullable: true })
+  volume?: number
+
+  @Field(type => Int, { nullable: true })
+  bufferQty?: number
+
+  @Field(type => Int, { nullable: true })
+  minQty?: number
+
+  @Field(type => Int, { nullable: true })
+  maxQty?: number
+
+  @Field({ nullable: true })
+  auxUnit1?: string
+
+  @Field({ nullable: true })
+  auxValue1?: string
+
+  @Field({ nullable: true })
+  auxUnit2?: string
+
+  @Field({ nullable: true })
+  auxValue2?: string
+
+  @Field({ nullable: true })
+  auxUnit3?: string
+
+  @Field({ nullable: true })
+  auxValue3?: string
+
+  @Field({ nullable: true })
+  auxUnit4?: string
+
+  @Field({ nullable: true })
+  auxValue4?: string
+
+  @Field({ nullable: true })
+  auxUnit5?: string
+
+  @Field({ nullable: true })
+  auxValue5?: string
+
+  @Field({ nullable: true })
+  isTrackedAsInventory?: boolean
+
+  @Field(type => Int, { nullable: true })
+  discountId?: number
+
+  @Field(type => Float, { nullable: true })
+  costPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  mrpPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  sellPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  afterTaxCostPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  afterTaxSalesPrice?: number
+
+  @Field({ nullable: true })
+  inventoryAccountCode?: string
+
+  @Field({ nullable: true })
+  cogsAccountCode?: string
+}
+
+@ObjectType()
+export class ProductDetailList {
+  @Field(type => [ProductDetail], { nullable: true })
+  items?: ProductDetail[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class ProductDetailPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  gtin?: string
+
+  @Field({ nullable: true })
+  refCode?: string
+
+  @Field({ nullable: true })
+  product: ObjectRef
+
+  @Field({ nullable: true })
+  isDefault: boolean
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  movement?: string
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  childProductDetail?: string
+
+  @Field({ nullable: true })
+  childGtin?: string
+
+  @Field(type => Float, { nullable: true })
+  childQty?: number
+
+  @Field({ nullable: true })
+  weightUnit?: string
+
+  @Field(type => Float, { nullable: true })
+  nettWeight?: number
+
+  @Field(type => Float, { nullable: true })
+  grossWeight?: number
+
+  @Field({ nullable: true })
+  lengthUnit?: string
+
+  @Field(type => Float, { nullable: true })
+  width?: number
+
+  @Field(type => Float, { nullable: true })
+  depth?: number
+
+  @Field(type => Float, { nullable: true })
+  height?: number
+
+  @Field(type => Float, { nullable: true })
+  volume?: number
+
+  @Field(type => Int, { nullable: true })
+  bufferQty?: number
+
+  @Field(type => Int, { nullable: true })
+  minQty?: number
+
+  @Field(type => Int, { nullable: true })
+  maxQty?: number
+
+  @Field({ nullable: true })
+  auxUnit1?: string
+
+  @Field({ nullable: true })
+  auxValue1?: string
+
+  @Field({ nullable: true })
+  auxUnit2?: string
+
+  @Field({ nullable: true })
+  auxValue2?: string
+
+  @Field({ nullable: true })
+  auxUnit3?: string
+
+  @Field({ nullable: true })
+  auxValue3?: string
+
+  @Field({ nullable: true })
+  auxUnit4?: string
+
+  @Field({ nullable: true })
+  auxValue4?: string
+
+  @Field({ nullable: true })
+  auxUnit5?: string
+
+  @Field({ nullable: true })
+  auxValue5?: string
+
+  @Field({ nullable: true })
+  isTrackedAsInventory: boolean
+
+  @Field(type => Int, { nullable: true })
+  discountId?: number
+
+  @Field(type => Float, { nullable: true })
+  costPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  mrpPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  sellPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  afterTaxCostPrice?: number
+
+  @Field(type => Float, { nullable: true })
+  afterTaxSalesPrice?: number
+
+  @Field({ nullable: true })
+  inventoryAccountCode?: string
+
+  @Field({ nullable: true })
+  cogsAccountCode?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}