@things-factory/warehouse-base 4.0.0-alpha.8 → 4.0.0-beta.2

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
-    })
-  }
-}

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

@@ -1,47 +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 updateMultipleInventoryChange = {
-  async updateMultipleInventoryChange(_: any, { patches }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const inventoryChangeRepo = tx.getRepository(InventoryChange)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await inventoryChangeRepo.save({
-          ...newRecord,
-          domain: domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const inventoryChange = await inventoryChangeRepo.findOne(newRecord.id)
-
-        const result = await inventoryChangeRepo.save({
-          ...inventoryChange,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/inventory-history/bizplace-inventory-histories.ts

@@ -1,81 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { convertListParams, Domain } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder, Brackets, Between, EntityManager, In, Raw } from 'typeorm'
-import { InventoryHistory, Location, Warehouse } from '../../../entities'
-
-export const bizplaceInventoryHistories = {
-  async bizplaceInventoryHistories(_: any, { inventoryHistory, filters, pagination, sortings }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const ownerBizplace: Bizplace = await getMyBizplace(domain, user)
-    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(inventoryHistory.bizplace.id)
-
-    const productFilters = filters.find(x => x.name == 'product_info')
-    filters = filters.filter(x => x.name != 'product_info')
-
-    const fromDate: Date = new Date(inventoryHistory.fromDate)
-    const toDate: Date = new Date(inventoryHistory.toDate)
-
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    let where = { domain: domain }
-
-    if (productFilters) {
-      let productFilterValue = `%${productFilters.value.toLowerCase()}%`
-      const productQb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder('prd')
-
-      productQb.where(
-        new Brackets(qb => {
-          qb.where('Lower(prd.sku) LIKE :productInfo', { productInfo: productFilterValue })
-            .orWhere('Lower(prd.name) LIKE :productInfo', { productInfo: productFilterValue })
-            .orWhere('Lower(prd.description) LIKE :productInfo', { productInfo: productFilterValue })
-        })
-      )
-
-      const _products = await productQb.getMany()
-
-      where['product'] = In(_products.map((product: Product) => product.id))
-    }
-
-    if (inventoryHistory && inventoryHistory.warehouseName) {
-      const _warehouses: Warehouse[] = await tx.getRepository(Warehouse).find({
-        domain: domain,
-        name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.warehouseName.toLowerCase()}'`)
-      })
-      where['warehouse'] = In(_warehouses.map((warehouse: Warehouse) => warehouse.id))
-    }
-
-    if (inventoryHistory && inventoryHistory.locationName) {
-      const _locations = await tx.getRepository(Location).find({
-        where: {
-          domain: domain,
-          name: Raw(alias => `LOWER(${alias}) LIKE '${inventoryHistory.locationName.toLowerCase()}'`)
-        }
-      })
-      where['location'] = In(_locations.map((location: Location) => location.id))
-    }
-
-    where['createdAt'] = Between(fromDate, toDate)
-
-    convertedParams.where = {
-      ...convertedParams.where,
-      ...where,
-      bizplace: customerBizplace
-    }
-
-    const result = await tx.getRepository(InventoryHistory).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'product', 'warehouse', 'location', 'bizplace', 'updater'],
-      order: {
-        palletId: 'ASC',
-        seq: 'ASC'
-      }
-    })
-
-    let items = result[0] as any
-    let total = result[1]
-
-    return { items, total }
-  }
-}

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

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