@things-factory/warehouse-base 4.0.0-y.0 → 4.0.4

package/server/entities/index.ts

@@ -1,36 +0,0 @@
-import { Inventory } from './inventory'
-import { InventoryChange } from './inventory-change'
-import { InventoryHistory } from './inventory-history'
-import { ReducedInventoryHistory } from './reduced-inventory-history'
-import { Location } from './location'
-import { Movement } from './movement'
-import { Warehouse } from './warehouse'
-import { Pallet } from './pallet'
-import { PalletHistory } from './pallet-history'
-import { PalletCount } from './pallet-count'
-
-export const entities = [
-  Location,
-  Inventory,
-  InventoryChange,
-  InventoryHistory,
-  ReducedInventoryHistory,
-  Warehouse,
-  Movement,
-  Pallet,
-  PalletHistory,
-  PalletCount
-]
-
-export {
-  Location,
-  Inventory,
-  InventoryChange,
-  InventoryHistory,
-  ReducedInventoryHistory,
-  Warehouse,
-  Movement,
-  Pallet,
-  PalletHistory,
-  PalletCount
-}

package/server/entities/pallet-count.ts

@@ -1,40 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, OneToMany, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-@Entity()
-@Index('ix_pallet-count_0', (palletCount: PalletCount) => [palletCount.domain, palletCount.name], { unique: true })
-export class PalletCount {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({ default: 0 })
-  seq: number
-
-  @Column({
-    nullable: true
-  })
-  description: 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,7 +0,0 @@
-import * as typeDefs from './types'
-import * as resolvers from './resolvers'
-
-export const schema = {
-  typeDefs,
-  resolvers
-}

package/server/graphql/resolvers/index.ts

@@ -1,33 +0,0 @@
-import * as Inventory from './inventory'
-import * as InventoryChange from './inventory-change'
-import * as InventoryHistory from './inventory-history'
-import * as Location from './location'
-import * as Movement from './movement'
-import * as Warehouse from './warehouse'
-import * as Pallet from './pallet'
-import * as PalletHistory from './pallet-history'
-import * as PalletCount from './pallet-count'
-
-export const queries = [
-  Location.Query,
-  Inventory.Query,
-  InventoryChange.Query,
-  InventoryHistory.Query,
-  Warehouse.Query,
-  Movement.Query,
-  Pallet.Query,
-  PalletHistory.Query,
-  PalletCount.Query
-]
-
-export const mutations = [
-  Location.Mutation,
-  Inventory.Mutation,
-  InventoryChange.Mutation,
-  InventoryHistory.Mutation,
-  Warehouse.Mutation,
-  Movement.Mutation,
-  Pallet.Mutation,
-  PalletHistory.Mutation,
-  PalletCount.Mutation
-]

package/server/graphql/resolvers/inventory/check-carton-identicality.ts

@@ -1,32 +0,0 @@
-import { getRepository, Repository } from 'typeorm'
-import { INVENTORY_STATUS } from '../../../constants'
-import { Inventory } from '../../../entities'
-
-export const checkCartonIdenticalityResolver = {
-  async checkCartonIdenticality(_: any, { cartonA, palletA, cartonB }, context: any) {
-    const invRepo: Repository<Inventory> = getRepository(Inventory)
-    const invA: Inventory = await invRepo.findOne({
-      where: { domain: context.state.domain, palletId: palletA, cartonId: cartonA, status: INVENTORY_STATUS.STORED },
-      relations: ['product']
-    })
-
-    const invB: Inventory = await invRepo.findOne({
-      where: {
-        domain: context.state.domain,
-        packingType: invA.packingType,
-        packingSize: invA.packingSize,
-        product: invA.product,
-        cartonId: cartonB,
-        status: INVENTORY_STATUS.STORED
-      },
-      relations: ['product']
-    })
-
-    return (
-      invA?.expirationDate === invB?.expirationDate &&
-      invA?.product?.id === invB?.product?.id &&
-      invA?.packingType === invB?.packingType &&
-      invA?.packingSize === invB?.packingSize
-    )
-  }
-}

package/server/graphql/resolvers/inventory/check-inventory-owner.ts

@@ -1,26 +0,0 @@
-import { Bizplace } from '@things-factory/biz-base'
-import { getRepository, Repository } from 'typeorm'
-import { INVENTORY_STATUS } from '../../../constants'
-import { Inventory } from '../../../entities'
-
-export const checkInventoryOwnerResolver = {
-  async checkInventoryOwner(_: any, { palletId, bizplaceName }, context: any) {
-    const invRepo: Repository<Inventory> = getRepository(Inventory)
-    const bizRepo: Repository<Bizplace> = getRepository(Bizplace)
-
-    const inventory: Inventory = await invRepo.findOne({
-      where: { domain: context.state.domain, palletId, status: INVENTORY_STATUS.STORED },
-      relations: ['bizplace']
-    })
-
-    if (!inventory) throw new Error('This inventory status is not stored.')
-
-    const ownerBizplace: Bizplace = await bizRepo.findOne({
-      where: { name: bizplaceName }
-    })
-
-    const foundBizplace: Bizplace = inventory.bizplace
-
-    return Boolean(ownerBizplace.id === foundBizplace.id)
-  }
-}

package/server/graphql/resolvers/inventory/check-product-identicality.ts

@@ -1,24 +0,0 @@
-import { getRepository, Repository } from 'typeorm'
-import { INVENTORY_STATUS } from '../../../constants'
-import { Inventory } from '../../../entities'
-
-export const checkProductIdenticalityResolver = {
-  async checkProductIdenticality(_: any, { palletA, palletB }, context: any) {
-    const invRepo: Repository<Inventory> = getRepository(Inventory)
-    const invA: Inventory = await invRepo.findOne({
-      where: { domain: context.state.domain, palletId: palletA, status: INVENTORY_STATUS.STORED },
-      relations: ['product']
-    })
-
-    const invB: Inventory = await invRepo.findOne({
-      where: { domain: context.state.domain, palletId: palletB, status: INVENTORY_STATUS.STORED },
-      relations: ['product']
-    })
-
-    return (
-      invA?.batchId === invB?.batchId &&
-      invA?.product?.id === invB?.product?.id &&
-      invA?.packingType === invB?.packingType
-    )
-  }
-}

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

@@ -1,15 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const createInventory = {
-  async createInventory(_: any, { inventory }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    return await tx.getRepository(Inventory).save({
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user,
-      ...inventory
-    })
-  }
-}

package/server/graphql/resolvers/inventory/delete-inventories.ts

@@ -1,14 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const deleteInventories = {
-  async deleteInventories(_: any, { id }, context) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    await tx.getRepository(Inventory).delete({
-      id: In(id)
-    })
-
-    return true
-  }
-}

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

@@ -1,10 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const deleteInventory = {
-  async deleteInventory(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    return await tx.getRepository(Inventory).delete({ domain: context.state.domain, name })
-  }
-}

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

@@ -1,38 +0,0 @@
-import { checkProductIdenticalityResolver } from './check-product-identicality'
-import { checkCartonIdenticalityResolver } from './check-carton-identicality'
-import { checkInventoryOwnerResolver } from './check-inventory-owner'
-import { createInventory } from './create-inventory'
-import { deleteInventories } from './delete-inventories'
-import { deleteInventory } from './delete-inventory'
-import { inventoriesResolver } from './inventories'
-import { inventoriesByProduct } from './inventories-by-product'
-import { inventoriesByStrategyResolver, inventoriesByStrategy } from './inventories-by-strategy'
-import { inventoryResolver } from './inventory'
-import { inventoryByPalletResolver } from './inventory-by-pallet'
-import { updateInventory } from './update-inventory'
-import { updateInventoryRemark } from './update-inventory-remark'
-import { updateMultipleInventory } from './update-multiple-inventory'
-import { inventoryTransfer } from './inventory-transfer'
-import { inventoriesByBundleResolver } from './inventories-by-bundle'
-
-export const Query = {
-  ...inventoriesResolver,
-  ...inventoryResolver,
-  ...inventoriesByProduct,
-  ...inventoriesByStrategyResolver,
-  ...checkProductIdenticalityResolver,
-  ...checkCartonIdenticalityResolver,
-  ...checkInventoryOwnerResolver,
-  ...inventoryByPalletResolver,
-  ...inventoriesByBundleResolver
-}
-
-export const Mutation = {
-  ...updateInventory,
-  ...createInventory,
-  ...deleteInventory,
-  ...updateMultipleInventory,
-  ...deleteInventories,
-  ...inventoryTransfer,
-  ...updateInventoryRemark
-}

package/server/graphql/resolvers/inventory/inventories-by-bundle.ts

@@ -1,168 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { Inventory } from '../../../entities'
-import { ProductBundleSetting } from '@things-factory/product-base'
-
-export const inventoriesByBundleResolver = {
-  async inventoriesByBundle(_: any, { filters, pagination, sortings }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const params = { filters, pagination }
-
-    const productBundleId = params.filters.filter(x => x.name === 'productBundleId')[0].value
-    if (!productBundleId) {
-      throw new Error('params product bundle is missing')
-    }
-
-    const bundleReleaseQty: number = params.filters.filter(x => x.name === 'bundleReleaseQty')[0].value
-
-    // remove productBundleId and bundleReleaseQty from params.filters
-    params.filters = params.filters.filter(x => x.name !== 'productBundleId' && x.name !== 'bundleReleaseQty')
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace_id')) {
-      params.filters.push({
-        name: 'bizplace_id',
-        operator: 'in',
-        value: await getPermittedBizplaceIds(domain, user),
-        relation: true
-      })
-    }
-
-    const remainOnlyParam: { name: string; operator: string; value: boolean } = params?.filters?.find(
-      (f: { name: string; operator: string; value: any }) => f.name === 'remainOnly'
-    )
-
-    let remainOnly: boolean = false
-    if (typeof remainOnlyParam?.value !== 'undefined') {
-      remainOnly = remainOnlyParam.value
-      params.filters = params.filters.filter(
-        (f: { name: string; operator: string; value: any }) => f.name !== 'remainOnly'
-      )
-    }
-
-    const unlockOnlyParam: { name: string; operator: string; value: boolean } = params?.filters?.find(
-      (f: { name: string; operator: string; value: any }) => f.name === 'unlockOnly'
-    )
-
-    let unlockOnly: boolean = false
-    if (typeof unlockOnlyParam?.value !== 'undefined') {
-      unlockOnly = unlockOnlyParam.value
-      params.filters = params.filters.filter(
-        (f: { name: string; operator: string; value: any }) => f.name !== 'unlockOnly'
-      )
-    }
-
-    const productBundleSettings: ProductBundleSetting[] = await getRepository(ProductBundleSetting).find({
-      where: { productBundle: productBundleId },
-      relations: ['product', 'productBundle']
-    })
-
-    if (!productBundleSettings.length) {
-      throw new Error('product bundle settings is not found')
-    }
-
-    const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
-    buildQuery(qb, params, context)
-
-    qb.select('iv.product_id', 'productId')
-      .addSelect('iv.batch_id', 'batchId')
-      .addSelect('iv.batch_id_ref', 'batchIdRef')
-      .addSelect('iv.packing_type', 'packingType')
-      .addSelect('SUM(iv.qty)', 'qty')
-      .addSelect('SUM(iv.locked_qty)', 'lockedQty')
-      .addSelect('SUM(iv.uom_value)', 'uomValue')
-      .addSelect('SUM(iv.locked_uom_value)', 'lockedUomValue')
-      .addSelect('prd.sku', 'productSku')
-      .addSelect('prd.name', 'productName')
-      .addSelect('prd.description', 'productDescription')
-      .addSelect('prd.type', 'productType')
-      .addSelect('prd.primary_unit', 'uom')
-      .leftJoin('iv.product', 'prd')
-
-    if (remainOnly) {
-      qb.andWhere('iv.qty > 0')
-        .andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
-        .andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
-    }
-
-    if (unlockOnly) {
-      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END = 0')
-    }
-
-    qb.andWhere('iv.product_id IN (:...productIds)', {
-      productIds: productBundleSettings.map(productBundle => productBundle.product.id)
-    })
-      .groupBy('iv.product_id')
-      .addGroupBy('iv.batch_id')
-      .addGroupBy('iv.batch_id_ref')
-      .addGroupBy('iv.packing_type')
-      .addGroupBy('prd.sku')
-      .addGroupBy('prd.name')
-      .addGroupBy('prd.description')
-      .addGroupBy('prd.type')
-      .addOrderBy('prd.name')
-      .addGroupBy('prd.primary_unit')
-      .addOrderBy('iv.batch_id')
-
-    let bundleGroup = await qb.getRawMany()
-
-    bundleGroup = bundleGroup.map((item: any) => {
-      return {
-        ...item,
-        bundleId: productBundleId,
-        remainQty: item.qty - (item.lockedQty ? item.lockedQty : 0),
-        remainUomValue: item.uomValue - (item.lockedUomValue ? item.lockedUomValue : 0),
-        uom: item.uom,
-        bundleQty: productBundleSettings.filter(pbs => pbs.product.id === item.productId)[0].bundleQty
-      }
-    })
-
-    const bundleSetting = productBundleSettings.map(pbs => {
-      return {
-        id: pbs.id,
-        productId: pbs.product.id,
-        bundleId: pbs.productBundle.id,
-        bundleQty: pbs.bundleQty,
-        releaseQty: bundleReleaseQty * pbs.bundleQty,
-        productReleaseQty: 0,
-        productReleaseUomValue: 0
-      }
-    })
-
-    /** ************************ **/
-    bundleGroup = bundleGroup
-      .map(group => {
-        const uomValue = group.remainUomValue / group.remainQty
-
-        bundleSetting.forEach(setting => {
-          let assigned = false
-          let releaseQty = 0
-          let releaseUomValue = 0
-
-          if (group.productId === setting.productId) {
-            if (setting.productReleaseQty < setting.releaseQty) {
-              assigned = true
-              const leftQty = setting.releaseQty - setting.productReleaseQty
-              releaseQty = leftQty > group.remainQty ? group.remainQty : leftQty
-              releaseUomValue = Math.round(releaseQty * uomValue * 100) / 100
-              setting.productReleaseQty += releaseQty
-              setting.productReleaseUomValue += releaseUomValue
-            }
-
-            group.assigned = assigned
-            group.releaseQty = releaseQty
-            group.releaseUomValue = releaseUomValue
-            group.releaseUomValueWithUom = `${releaseUomValue} ${group.uom}`
-          }
-        })
-
-        return group
-      })
-      .filter(group => group.assigned)
-    /** ************************ **/
-
-    return { bundleGroup, bundleSetting }
-  }
-}

package/server/graphql/resolvers/inventory/inventories-by-product.ts

@@ -1,164 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds, getPartnersCompanyBizplaces, Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { convertListParams, ListParam, Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, EntityManager } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const inventoriesByProduct = {
-  async inventoriesByProduct(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-      let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-      const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
-
-      const page = params.pagination.page
-      const limit = params.pagination.limit  
-       
-      let bizplaceFilter = params.filters.find(filter=>filter.name =='bizplace')
-      let productFilter = params.filters.find(filter=>filter.name =='product')
-      let productTypeFilter = params.filters.find(filter=>filter.name =='type')
-      let availableStockFilter = params.filters.find(filter=>filter.name =='availableStock')
-      let lowStockFilter = params.filters.find(filter=>filter.name =='lowStock')
-      let overStockFilter = params.filters.find(filter=>filter.name =='overStock')
-
-      if(bizplaceFilter){
-        const bizplaceQueryBuilder: SelectQueryBuilder<Bizplace> = getRepository(Bizplace).createQueryBuilder('b')
-        bizplaceQueryBuilder
-        .innerJoin('companies', 'c2', ' c2.domain_id = b.domain_id')
-        .innerJoin('bizplaces', 'b2', 'b2.company_id = c2.id')
-        .where('b2.id = :bizplaceId', { bizplaceId: bizplaceFilter.value })
-
-        let bizplaceList = await bizplaceQueryBuilder.getMany()
-        
-        permittedBizplaceIds = [
-          ...permittedBizplaceIds.filter(itm => itm == bizplaceFilter.value),
-          ...bizplaceList.map(bz=>bz.id),
-          ...partnersCompanyBizplaces.map(biz=>biz.id)
-        ]
-      }
-
-      let bizplaceQuery = ''
-      if(permittedBizplaceIds.length > 0){
-        bizplaceQuery = `AND EXISTS (
-          SELECT * FROM (VALUES ${permittedBizplaceIds.map(id => `('${id}')`).join(',')})
-          AS bizFilter(bizplace_id)
-          WHERE bizFilter.bizplace_id::uuid = "Inventory"."bizplace_id"
-        )`
-      } else {
-        bizplaceQuery = `1 = 0`
-      }
-
-      let productQuery = ''
-      if (productFilter) {
-        let productValue = productFilter.value
-          .toLowerCase()
-          .split(',')
-          .map(prod => {
-            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-          })
-          .join(',')
-        productQuery = `AND (
-          Lower("Product"."name") LIKE ANY(ARRAY[${productValue}])
-          OR Lower("Product"."sku") LIKE ANY(ARRAY[${productValue}])
-          OR Lower("Product"."description") LIKE ANY(ARRAY[${productValue}])
-          OR Lower("ProductRef"."name") LIKE ANY(ARRAY[${productValue}])
-          OR Lower("ProductRef"."sku") LIKE ANY(ARRAY[${productValue}])
-          OR Lower("ProductRef"."description") LIKE ANY(ARRAY[${productValue}])
-        )`
-      }
-
-      if(productTypeFilter){
-        let productTypeValue = productTypeFilter.value
-          .toLowerCase()
-          .split(',')
-          .map(prod => {
-            return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-          })
-          .join(',')
-        productQuery = productQuery + ` AND (
-          Lower("Product"."type") LIKE ANY(ARRAY[${productTypeValue}])
-        )`
-      }
-
-      let availableStockQuery = ''
-      if(availableStockFilter?.value){
-        availableStockQuery = ` AND SUM("Inventory"."qty") > 0`
-      }
-
-      let thresholdQuery = ''
-      if(lowStockFilter?.value){
-        thresholdQuery = `AND COALESCE("ProductDetailBizplaceSetting"."min_qty", "Product"."min_qty",0) > SUM("Inventory"."qty")`
-      }
-
-      if(overStockFilter?.value){
-        thresholdQuery = `AND COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0)  > 0 AND 
-          COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0)  < SUM("Inventory"."qty")`
-      }
-
-      await tx.query(`
-        create temp table temp_inv_history AS 
-        (
-          SELECT "Product"."id" AS "id", "Product"."sku" AS "sku", "Product"."name" AS "name", "Product"."type" AS "type", "Product"."description" AS "description", 
-          "Product"."weight" AS "weight", "ProductRef"."name" AS "productRefName", 
-          "ProductRef"."description" AS "productRefDesciption", "Bizplace"."name" AS "bizplaceName", SUM("Inventory"."qty") AS "qty" ,
-          CASE WHEN SUM("Inventory"."qty") > 0 THEN SUM(COALESCE("Inventory"."unit_cost", 0) * "Inventory"."qty")/ SUM("Inventory"."qty") ELSE 0 END AS "averageUnitCost",
-          COALESCE("ProductDetailBizplaceSetting"."min_qty", "Product"."min_qty",0) AS "minQty", 
-          COALESCE("ProductDetailBizplaceSetting"."max_qty", "Product"."max_qty",0) AS "maxQty"
-          FROM "inventories" "Inventory" 
-          LEFT JOIN "products" "Product" ON "Product"."id"="Inventory"."product_id" 
-          LEFT JOIN "product_details" "ProductDetails" ON "ProductDetails"."product_id" = "Product"."id" 
-            AND "ProductDetails"."is_default"
-          LEFT JOIN "product_detail_bizplace_settings" "ProductDetailBizplaceSetting" ON "ProductDetailBizplaceSetting"."product_detail_id" = "ProductDetails"."id" 
-            AND "ProductDetailBizplaceSetting"."domain_id" = "Inventory"."domain_id"
-          LEFT JOIN "products" "ProductRef" ON "ProductRef"."id"="Product"."product_ref_id" 
-          INNER JOIN "bizplaces" "Bizplace" ON "Bizplace"."id"="Inventory"."bizplace_id"
-          WHERE "Inventory"."qty" >= 0
-          AND "Inventory"."domain_id" = $1
-          ${bizplaceQuery}
-          ${productQuery}
-          GROUP BY "Product"."id", "ProductRef"."id", "Bizplace"."id", "ProductDetailBizplaceSetting"."id"
-          HAVING 1 = 1
-          ${availableStockQuery}
-          ${thresholdQuery}
-        )`,[domain.id]
-      )
-
-      const results: any = await tx.query(`
-          SELECT * FROM temp_inv_history
-          ORDER BY "bizplaceName", "sku" 
-          OFFSET $1 LIMIT $2
-        `,[(page - 1) * limit, limit]
-      )
-
-      const total: any = await tx.query(`SELECT COUNT(*) FROM temp_inv_history`)
-      
-      tx.query(`drop table temp_inv_history`)
-
-      return {
-        items: results.map((item: any) => {
-          return {
-            product: {
-              id: item.id,
-              name: item.name,
-              sku: item.sku,
-              description: item.description,
-              type: item.type,
-              weight: item.weight,
-              productRef: { name: item.productRefName, description: item.productRefDesciption },
-              bizplace: { name: item.bizplaceName },
-              minQty: item.minQty,
-              maxQty: item.maxQty
-            },
-            averageUnitCost: item.averageUnitCost,
-            qty: item.qty
-          }
-        }),
-        total: total[0].count 
-      }
-
-    } catch (error) {
-      throw error      
-    }
-  }
-}