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

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

@@ -1,143 +0,0 @@
-import { getRepository, EntityManager } from 'typeorm'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '../../../entities'
-
-export const inventoriesByStrategyResolver = {
-  async inventoriesByStrategy(
-    _: any,
-    { worksheetId, batchId, bizplaceId, productName, productSku, packingType, pickingStrategy, locationSortingRules },
-    context: any
-  ) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain, name: 'rule-for-inventory-assignment' }
-    })
-
-    if (!locationSortingRules && inventoryAssignmentSetting) {
-      locationSortingRules = []
-      let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
-      for (const key in locationSetting) {
-        locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
-      }
-    }
-
-    return inventoriesByStrategy(
-      { worksheetId, batchId, bizplaceId, productName, productSku, packingType, pickingStrategy, locationSortingRules },
-      tx
-    )
-  }
-}
-
-export async function inventoriesByStrategy(
-  { worksheetId, batchId, bizplaceId, productName, productSku, packingType, pickingStrategy, locationSortingRules },
-  trxMgr: EntityManager
-) {
-  const qb = await trxMgr.getRepository(Inventory).createQueryBuilder('INV')
-  qb.leftJoinAndSelect('INV.product', 'PROD')
-    .leftJoinAndSelect('INV.location', 'LOC')
-    .addSelect(subQuery =>
-      subQuery
-        .select('COALESCE(SUM(release_qty), 0)', 'releaseQty')
-        .from('order_inventories', 'OI')
-        .where('"OI"."inventory_id" = "INV"."id"')
-        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
-        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
-    )
-    .addSelect(subQuery =>
-      subQuery
-        .select('COALESCE(SUM(release_uom_value), 0)', 'releaseUomValue')
-        .from('order_inventories', 'OI')
-        .where('"OI"."inventory_id" = "INV"."id"')
-        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
-        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
-    )
-    .andWhere('"PROD"."name" = :productName')
-    .andWhere('"PROD"."sku" = :productSku')
-    .andWhere('"INV"."packing_type" = :packingType')
-    .andWhere('"INV"."status" = :status', { status: 'STORED' })
-    .setParameters({
-      productName,
-      productSku,
-      packingType
-    })
-
-  if (batchId !== '') {
-    qb.andWhere('"INV"."batch_id" = :batchId', { batchId })
-  }
-
-  if (bizplaceId) {
-    qb.andWhere('"INV"."bizplace_id" = :bizplaceId', { bizplaceId: bizplaceId })
-  }
-
-  switch (pickingStrategy.toUpperCase()) {
-    case 'FIFO':
-      qb.orderBy('"INV"."created_at"', 'ASC')
-      if (locationSortingRules?.length > 0) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
-          idx === 0
-            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-        })
-      }
-      break
-
-    case 'LIFO':
-      qb.orderBy('"INV"."created_at"', 'DESC')
-      if (locationSortingRules?.length > 0) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
-          idx === 0
-            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-        })
-      }
-      break
-
-    case 'FEFO':
-      qb.orderBy('"INV"."expiration_date"', 'ASC')
-      if (locationSortingRules?.length > 0) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
-          idx === 0
-            ? qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-        })
-      }
-      break
-
-    case 'LOCATION':
-      if (locationSortingRules?.length > 0) {
-        locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
-          idx === 0
-            ? qb.orderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-            : qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-        })
-      } else qb.orderBy('"LOC"."name"', 'DESC')
-      break
-    default:
-      qb.orderBy('"INV"."created_at"', 'ASC')
-
-      break
-  }
-
-  const { entities, raw } = await qb.getRawAndEntities()
-  const items = entities
-    .map((inv: Inventory, idx: number) => {
-      const qty: number = inv?.qty > 0 ? inv.qty : 0
-      const uomValue: number = inv?.uomValue > 0 ? inv.uomValue : 0
-      const lockedQty: number = inv.lockedQty || 0
-      const lockedUomValue: number = inv.lockedUomValue || 0
-      const releaseQty: number = parseInt(raw[idx].releaseQty) || 0
-      const releaseUomValue: number = parseFloat(raw[idx].releaseUomValue) || 0
-
-      return {
-        ...inv,
-        qty: qty - lockedQty - releaseQty,
-        uomValue: uomValue - lockedUomValue - releaseUomValue
-      }
-    })
-    .filter((inv: Inventory) => inv.qty)
-
-  const total: number = await qb.getCount()
-  return { items, total }
-}

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

@@ -1,129 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { buildQuery, Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, Brackets } from 'typeorm'
-import { Inventory, InventoryChange } from '../../../entities'
-
-export const inventoriesResolver = {
-  async inventories(_: any, { filters, pagination, sortings, locationSortingRules }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const productFilters = filters.find(x => x.name == 'product_info')
-    filters = filters.filter(x => x.name != 'product_info')
-    const params = { filters, pagination }
-    
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-      params.filters.push({
-        name: 'bizplace',
-        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 qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
-    buildQuery(qb, params, context)
-
-    qb.leftJoinAndSelect('iv.domain', 'domain')
-      .leftJoinAndSelect('iv.bizplace', 'bizplace')
-      .leftJoinAndSelect('iv.product', 'product')
-      .leftJoinAndSelect('iv.warehouse', 'warehouse')
-      .leftJoinAndSelect('iv.location', 'location')
-      .leftJoinAndSelect('iv.creator', 'creator')
-      .leftJoinAndSelect('iv.updater', 'updater')
-
-    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')
-    }
-
-    if(productFilters){
-      let productFilterValue = `%${productFilters.value.toLowerCase()}%`
-      qb.andWhere((qb) => {
-        const subQuery = qb.subQuery()
-            .select()
-            .from(Product, `products`)
-            .where(`products.id = iv.product_id`)
-            .andWhere(new Brackets(qb => {
-              qb.where("Lower(products.sku) LIKE :productInfo", { productInfo: productFilterValue})
-                .orWhere("Lower(products.name) LIKE :productInfo", { productInfo: productFilterValue})
-                .orWhere("Lower(products.description) LIKE :productInfo", { productInfo: productFilterValue})
-            }))          
-            .getQuery();
-        return `EXISTS ${subQuery}`;
-      })
-    }
-
-    if (sortings?.length !== 0) {
-      const arrChildSortData = ['bizplace', 'product', 'location', 'warehouse', 'zone']
-      const sort = (sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'iv.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        {}
-      )
-      qb.orderBy(sort)
-    }
-
-    if (locationSortingRules?.length > 0) {
-      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-        qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-      })
-    }
-
-    let [items, total] = await qb.getManyAndCount()
-
-    items = await Promise.all(
-      items.map(async (item: Inventory) => {
-        let inventoryChangeCount = await getRepository(InventoryChange).count({
-          where: { inventory: item.id }
-        })
-
-        const selectedQty = item.lockedQty ? item.lockedQty : 0
-        const selectedUomValue = item.lockedUomValue ? item.lockedUomValue : 0
-
-        return {
-          ...item,
-          changeCount: inventoryChangeCount,
-          remainQty: item.qty - selectedQty,
-          remainUomValue: item.uomValue - selectedUomValue
-        }
-      })
-    )
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/inventory/inventory-by-pallet.ts

@@ -1,15 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { Equal, getRepository, Not } from 'typeorm'
-import { INVENTORY_STATUS } from '../../../constants'
-import { Inventory } from '../../../entities'
-
-export const inventoryByPalletResolver = {
-  async inventoryByPallet(_: any, { palletId }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(Inventory).findOne({
-      where: { domain, palletId, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) },
-      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
-    })
-  }
-}

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

@@ -1,50 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
-import { INVENTORY_TRANSACTION_TYPE } from '../../../constants'
-import { Inventory, Location } from '../../../entities'
-import { generateInventoryHistory } from '../../../utils'
-
-export const inventoryTransfer = {
-  async inventoryTransfer(_: any, { palletId, cartonId, fromLocationName, toLocationName }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    // 1. check toLocation exist
-    const toLocation: Location = await tx.getRepository(Location).findOne({
-      where: { domain: domain, name: toLocationName },
-      relations: ['domain', 'warehouse']
-    })
-    if (!toLocation) throw new Error(`To location doesn't exists`)
-
-    const fromLocation: Location = await tx.getRepository(Location).findOne({
-      where: { domain: domain, name: fromLocationName },
-      relations: ['domain', 'warehouse']
-    })
-    if (!toLocation) throw new Error(`From location doesn't exists`)
-
-    // 2. search for related inventory
-    const invQb: SelectQueryBuilder<Inventory> = await tx
-      .getRepository(Inventory)
-      .createQueryBuilder('INV')
-      .where('INV.domain_id = :domainId', { domainId: domain.id })
-      .andWhere('INV.location_id = :fromLocationId', { fromLocationId: fromLocation.id })
-
-    if (cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: cartonId })
-    else invQb.andWhere('INV.pallet_id = :palletId', { palletId: palletId })
-
-    let inventories: Inventory[] = await invQb.getMany()
-    if (!inventories?.length) throw new Error('Inventory not found')
-
-    await Promise.all(
-      inventories.map(async (inventory: Inventory) => {
-        inventory.warehouse = toLocation.warehouse
-        inventory.location = toLocation
-        inventory.zone = toLocation.zone
-        inventory.updater = user
-        inventory = await tx.getRepository(Inventory).save(inventory)
-
-        await generateInventoryHistory(inventory, null, INVENTORY_TRANSACTION_TYPE.RELOCATE, 0, 0, user, tx)
-      })
-    )
-  }
-}

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

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const inventoryResolver = {
-  async inventory(_: any, { palletId }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(Inventory).findOne({
-      where: { domain: domain, palletId },
-      relations: ['domain', 'bizplace', 'product', 'location', 'warehouse', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/inventory/update-inventory-remark.ts

@@ -1,19 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const updateInventoryRemark = {
-  async updateInventoryRemark(_: any, { id, remark }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(Inventory)
-    const inventory = await repository.findOne({ where: { domain: domain, id } })
-
-    return await repository.save({
-      ...inventory,
-      remark,
-      updater: user
-    })
-  }
-}

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

@@ -1,31 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
-import { Inventory } from '../../../entities'
-
-export const updateInventory = {
-  async updateInventory(_: any, { patch }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const invQb: SelectQueryBuilder<Inventory> = await tx
-      .getRepository(Inventory)
-      .createQueryBuilder('INV')
-      .where('INV.domain_id = :domainId', { domainId: domain.id })
-      .andWhere('INV.bizplace_id = :bizplaceId', { bizplaceId: patch.bizplace.id })
-      .andWhere('INV.batch_id = :batchId', { batchId: patch.batchId })
-      .andWhere('INV.product_id = :productId', { productId: patch.product.id })
-      .andWhere('INV.packing_type = :packingType', { packingType: patch.packingType })
-      .andWhere('INV.packing_size = :packingSize', { packingSize: patch.packingSize })
-
-    if (patch?.cartonId) invQb.andWhere('INV.carton_id = :cartonId', { cartonId: patch.cartonId })
-    else invQb.andWhere('INV.pallet_id = :palletId', { palletId: patch.palletId })
-
-    const inventory = await invQb.getOne()
-
-    return await tx.getRepository(Inventory).save({
-      ...inventory,
-      ...patch,
-      updater: user
-    })
-  }
-}

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

@@ -1,17 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const createInventoryChange = {
-  async createInventoryChange(_: any, { inventoryChange }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    return await tx.getRepository(InventoryChange).save({
-      ...inventoryChange,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-}

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

@@ -1,12 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const deleteInventoryChange = {
-  async deleteInventoryChange(_: any, { name }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(InventoryChange).delete({ domain: domain, name })
-    return true
-  }
-}

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

@@ -1,15 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const deleteInventoryChanges = {
-  async deleteInventoryChanges(_: any, { names }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(InventoryChange).delete({
-      domain: domain,
-      name: In(names)
-    })
-    return true
-  }
-}

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

@@ -1,27 +0,0 @@
-import { inventoryChangeResolver } from './inventory-change'
-import { inventoryChangesResolver } from './inventory-changes'
-
-import { updateInventoryChange } from './update-inventory-change'
-import { updateMultipleInventoryChange } from './update-multiple-inventory-change'
-import { createInventoryChange } from './create-inventory-change'
-import { deleteInventoryChange } from './delete-inventory-change'
-import { deleteInventoryChanges } from './delete-inventory-changes'
-import { submitInventoryChanges } from './submit-inventory-changes'
-import { approveInventoryChanges } from './approve-inventory-changes'
-import { rejectInventoryChanges } from './reject-inventory-changes'
-
-export const Query = {
-  ...inventoryChangesResolver,
-  ...inventoryChangeResolver
-}
-
-export const Mutation = {
-  ...updateInventoryChange,
-  ...updateMultipleInventoryChange,
-  ...createInventoryChange,
-  ...deleteInventoryChange,
-  ...deleteInventoryChanges,
-  ...submitInventoryChanges,
-  ...approveInventoryChanges,
-  ...rejectInventoryChanges
-}

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

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const inventoryChangeResolver = {
-  async inventoryChange(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(InventoryChange).findOne({
-      where: { domain: domain, name },
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/inventory-change/reject-inventory-changes.ts

@@ -1,42 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { InventoryChange, InventoryHistory } from '../../../entities'
-
-export const rejectInventoryChanges = {
-  async rejectInventoryChanges(_: any, { patches }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    const _inventoryChanges = await tx.getRepository(InventoryChange).find({
-      where: { id: In(patches.map(item => item.id)) },
-      relations: [
-        'inventory',
-        'inventory.bizplace',
-        'inventory.product',
-        'inventory.location',
-        'inventory.warehouse',
-        'bizplace',
-        'product',
-        'location'
-      ]
-    })
-
-    if (_inventoryChanges.length > 0) {
-      for (let i = 0; i < _inventoryChanges.length; i++) {
-        if (_inventoryChanges[i].status.toLocaleLowerCase() != 'pending') return true
-        _inventoryChanges[i].status = 'REJECTED'
-
-        // Get last row of InventoryHistory
-        let latestEntry = await tx.getRepository(InventoryHistory).find({
-          where: { palletId: _inventoryChanges[i].palletId, domain: domain },
-          order: { seq: 'DESC' },
-          take: 1
-        })
-
-        if (latestEntry.length > 0) _inventoryChanges[i].lastInventoryHistory = latestEntry[0]
-      }
-
-      await tx.getRepository(InventoryChange).save(_inventoryChanges.filter(change => change.status == 'REJECTED'))
-    }
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-change/submit-inventory-changes.ts

@@ -1,101 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { EntityManager } from 'typeorm'
-import { Inventory, InventoryChange, Location } from '../../../entities'
-import { InventoryNoGenerator } from '../../../utils'
-
-export const submitInventoryChanges = {
-  async submitInventoryChanges(_: any, { patches }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const _createRecords = patches.filter((patch: any) => !patch.id)
-    const _updateRecords = patches.filter((patch: any) => patch.id)
-
-    const inventoryChangeRepo = tx.getRepository(InventoryChange)
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        var location = await tx.getRepository(Location).findOne({
-          where: { id: newRecord.location.id },
-          relations: ['warehouse']
-        })
-        newRecord.location = location
-        newRecord.zone = location.zone
-        newRecord.warehouse = location.warehouse
-
-        newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
-
-        var product: Product = await tx.getRepository(Product).findOne(newRecord.product.id)
-        newRecord.product = product
-
-        newRecord.status = 'PENDING'
-        newRecord.transactionType = 'NEW'
-
-        newRecord.expirationDate =
-          ((newRecord?.expirationDate && new Date(newRecord.expirationDate).getFullYear()) || 0) < 2000
-            ? null
-            : newRecord.expirationDate
-
-        await inventoryChangeRepo.save({
-          ...newRecord,
-          id: undefined,
-          name: InventoryNoGenerator.inventoryName(),
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-
-        let existingRecord = await tx.getRepository(Inventory).findOne({
-          where: { id: updateRecord.id },
-          relations: ['location', 'warehouse', 'product', 'bizplace']
-        })
-
-        if (!!updateRecord?.location?.id) {
-          var location = await tx.getRepository(Location).findOne({
-            where: { id: updateRecord.location.id },
-            relations: ['warehouse']
-          })
-          updateRecord.location = location
-          updateRecord.zone = location.zone
-          updateRecord.warehouse = location.warehouse
-        }
-
-        if (!!updateRecord?.bizplace?.id)
-          updateRecord.bizplace = await tx.getRepository(Bizplace).findOne(updateRecord.bizplace.id)
-
-        if (!!updateRecord?.product?.id)
-          updateRecord.product = await tx.getRepository(Product).findOne(updateRecord.product.id)
-
-        updateRecord.status = 'PENDING'
-        updateRecord.transactionType = 'CHANGES'
-
-        updateRecord.expirationDate =
-          ((updateRecord?.expirationDate && new Date(updateRecord.expirationDate).getFullYear()) || 0) < 2000
-            ? null
-            : updateRecord.expirationDate
-
-        await inventoryChangeRepo.save({
-          palletId: existingRecord.palletId,
-          ...updateRecord,
-          id: undefined,
-          name: InventoryNoGenerator.inventoryName(),
-          inventory: existingRecord,
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-      }
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-change/update-inventory-change.ts

@@ -1,21 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { InventoryChange } from '../../../entities'
-
-export const updateInventoryChange = {
-  async updateInventoryChange(_: any, { name, patch }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(InventoryChange)
-    const inventoryChange = await repository.findOne({
-      where: { domain: domain, name }
-    })
-
-    return await repository.save({
-      ...inventoryChange,
-      ...patch,
-      updater: user
-    })
-  }
-}