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

package/server/graphql/resolvers/inventory-history/onhand-inventories.ts

@@ -1,233 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-
-export const onhandInventoriesResolver = {
-  async onhandInventories(_: any, { filters, pagination, sortings, locationSortingRules }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    // define all inputs
-    let userFilter = filters.find(data => data.name === 'user')
-    let product = filters.find(data => data.name === 'product')
-    let createdAt = filters.find(data => data.name === 'created_at')
-    let location = filters.find(data => data.name === 'location')
-    let batchId = filters.find(data => data.name === 'batchId')
-    let palletId = filters.find(data => data.name === 'palletId')
-    let cartonId = filters.find(data => data.name === 'cartonId')
-    let packingType = filters.find(data => data.name === 'packingType')
-    let timezoneOffset = filters.find(data => data.name === 'timezoneOffset').value + ' minutes'
-
-    // expiration date filter
-    let expiration = filters.find(data => data.name === 'expiration').value
-    let expFromDate = filters.find(data => data.name === 'expFromDate')
-    let expToDate = filters.find(data => data.name === 'expToDate')
-
-    let bizplaceFilter = { name: '', operator: '', value: [] }
-
-    // prepare query filters
-    if (userFilter) {
-      const user: User = await tx.getRepository(User).findOne({
-        where: { id: userFilter.value },
-        relations: ['bizplaces']
-      })
-
-      const bizplace: Bizplace = user.bizplaces[0]
-
-      if (!bizplace) throw 'Invalid input'
-
-      bizplaceFilter = { name: 'bizplace', operator: 'eq', value: [bizplace.id] }
-    } else {
-      bizplaceFilter = !filters.find((filter: any) => filter.name === 'bizplace')
-        ? {
-            name: 'bizplace',
-            operator: 'in',
-            value: await getPermittedBizplaceIds(domain, user),
-            relation: true
-          }
-        : {
-            ...filters.find(data => data.name === 'bizplace'),
-            value: [filters.find(data => data.name === 'bizplace').value]
-          }
-    }
-
-    let queryFilter = ``
-    let bizplaces = bizplaceFilter.value.map(id => `('${id}')`).join(',')
-
-    if (product) {
-      let products = product.value
-        .toLowerCase()
-        .split(',')
-        .map(prod => {
-          return "'%" + prod.trim().replace(/'/g, "''") + "%'"
-        })
-        .join(',')
-
-      queryFilter =
-        queryFilter +
-        ` and exists (
-            select prd.id as product_id from products prd
-            inner join bizplaces b on b.id = prd.bizplace_id 
-            inner join companies c on c.domain_id = b.domain_id 
-            inner join bizplaces b2 on b2.company_id = c.id
-            where exists (
-              SELECT * FROM tmp_bizfilter bizFilter
-              WHERE bizFilter.bizplace_id = "b2"."id"
-            )
-            and (lower(prd.name) like any(array[${products}])
-            or lower(prd.description) like any(array[${products}])
-            or lower(prd.sku) like any(array[${products}]))
-            and prd.id = rih.product_id
-            group by prd.id
-        )`
-    }
-
-    if (location) {
-      let locations = location.value
-        .map(loc => {
-          return "'" + loc + "'"
-        })
-        .join(',')
-
-      queryFilter =
-        queryFilter +
-        `and exists (
-          select loc.id from locations loc where
-          loc.id = any(array[${locations}]::uuid[])
-          and loc.id = rih.location_id
-        )`
-    }
-
-    // default sorting
-    let queryOrder = 'order by created_at desc'
-    if (sortings && sortings.length > 0) {
-      const arrObjectMap = [
-        { name: 'palletId', value: 'rih.pallet_id' },
-        { name: 'cartonId', value: 'rih.carton_id' },
-        { name: 'batchId', value: 'rih.batch_id' },
-        { name: 'initialInboundAt', value: 'rih.initial_inbound_at' },
-        { name: 'bizplace|name', value: 'bz.name' },
-        { name: 'product|name', value: 'prd.sku' },
-        { name: 'remainQty', value: 'rih.qty' },
-        { name: 'location|name', value: 'loc.name' }
-      ]
-      sortings.forEach((sorting, idx) => {
-        let itmIndex = arrObjectMap.findIndex(x => x.name === sorting.name)
-
-        queryOrder = `${idx === 0 ? 'order by' : queryOrder + ','} ${
-          itmIndex >= 0 ? arrObjectMap[itmIndex].value : sorting.name
-        } ${sorting.desc ? 'DESC' : 'ASC'}`
-      })
-    }
-
-    if (batchId) queryFilter = `${queryFilter} and lower(rih.batch_id) like '${batchId.value.toLowerCase()}' `
-
-    if (palletId) queryFilter = `${queryFilter} and rih.pallet_id like '${palletId.value}' `
-
-    if (cartonId) queryFilter = `${queryFilter} and rih.carton_id like '${cartonId.value}' `
-
-    if (packingType) queryFilter = `${queryFilter} and rih.packing_type like '${packingType.value}' `
-
-    let expirationQueryFilter = ``
-    if (expiration)
-      expirationQueryFilter = ` and iv.expiration_date >= '${expFromDate.value}'::timestamp + '${timezoneOffset}'::INTERVAL and 
-      iv.expiration_date <= '${expToDate.value}'::timestamp + '${timezoneOffset}'::INTERVAL + '1 day'::INTERVAL`
-
-    // query the results
-    await tx.query(`
-      CREATE TEMP TABLE tmp_bizfilter AS (
-        SELECT bizplace_id::uuid FROM (VALUES ${bizplaces}) AS bizFilter(bizplace_id)
-      );
-    `)
-
-    await tx.query(
-      `
-      create temp table tmp_src as (
-        select domain_id, pallet_id, carton_id, seq, qty, uom_value, packing_type, batch_id, batch_id_ref, created_at, status,
-        product_id::uuid as product_id, bizplace_id::uuid as bizplace_id, location_id::uuid as location_id 
-        from reduced_inventory_histories rih 
-        where domain_id = $1 and created_at < $2::timestamp + $3::INTERVAL + '1 day'::INTERVAL 
-      );
-    `,
-      [domain.id, createdAt.value, timezoneOffset]
-    )
-
-    await tx.query(
-      `          
-        create temp table tmp_data as (
-          select dt.*, rih.carton_id, rih.batch_id, rih.batch_id_ref, rih.product_id, rih.packing_type, rih.bizplace_id, rih.location_id, iv.uom, 
-          iv.expiration_date, iv.reusable_pallet_id, iv.remark
-          from
-          (
-            select ih.domain_id, ih.pallet_id, sum(ih.qty) as qty, sum(ih.uom_value) as uom_value, max(ih.seq) as last_seq, max(ih.created_at) as created_at,
-            min(ih.created_at) as initial_inbound_at
-            from tmp_src ih
-            group by ih.domain_id, ih.pallet_id
-          ) dt
-          inner join tmp_src rih on dt.domain_id = rih.domain_id and dt.pallet_id = rih.pallet_id and dt.last_seq = rih.seq and rih.status <> 'TERMINATED'
-          inner join inventories iv on iv.domain_id = dt.domain_id and iv.pallet_id = dt.pallet_id
-          where exists (
-            SELECT * FROM tmp_bizfilter bizFilter
-            WHERE bizFilter.bizplace_id = "rih"."bizplace_id"
-          )
-          ${queryFilter}
-          ${expirationQueryFilter}
-        );
-      `
-    )
-
-    const total: any = await tx.query(`select count(*) from tmp_data`)
-
-    const result: any = await tx.query(
-      ` 
-          select 
-          rih.domain_id, rih.pallet_id as "palletId", rih.carton_id as "cartonId", rih.qty as "remainQty", rih.uom_value as "uomValue", rih.uom, rih.last_seq, rih.created_at,
-          rih.initial_inbound_at as "initialInboundAt",
-          case when rih.reusable_pallet_id is not null then concat(rih.batch_id, ' (', plt.name, ')') else rih.batch_id end as "batchId",
-          rih.batch_id_ref as "batchIdRef", rih.product_id, rih.packing_type as "packingType", rih.bizplace_id, rih.location_id,
-          prd.name as product_name, prd.sku as product_sku, prd.description as product_description,
-          bz.name as bizplace_name, 
-          loc.name as location_name, loc."zone" as location_zone, loc."row" as location_row, loc."column" as location_column, loc.shelf as location_shelf,
-          wh.name as warehouse_name, plt.name as reusable_pallet_name,
-          rih.remark,
-          rih.expiration_date as "expirationDate"
-          from tmp_data rih
-          left join pallets plt on plt.id = rih.reusable_pallet_id
-          inner join products prd on prd.id = rih.product_id
-          inner join bizplaces bz on bz.id = rih.bizplace_id
-          inner join locations loc on loc.id = rih.location_id
-          inner join warehouses wh on wh.id = loc.warehouse_id
-          WHERE 1 = 1
-          ${queryOrder}
-          OFFSET $1 LIMIT $2;
-      `,
-      [(pagination.page - 1) * pagination.limit, pagination.limit]
-    )
-
-    tx.query(`
-      drop table tmp_src, tmp_data, tmp_bizfilter
-    `)
-
-    // map all results
-    let items = result.map(itm => {
-      return {
-        ...itm,
-        bizplace: {
-          name: itm.bizplace_name
-        },
-        location: {
-          name: itm.location_name,
-          type: itm.location_type,
-          zone: itm.location_zone
-        },
-        product: {
-          name: itm.product_name,
-          description: itm.product_description,
-          sku: itm.product_sku
-        }
-      }
-    })
-
-    return { items, total: total[0].count }
-  }
-}

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

@@ -1,21 +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 updateInventoryHistory = {
-  async updateInventoryHistory(_: any, { name, patch }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(InventoryHistory)
-    const inventoryHistory = await repository.findOne({
-      where: { domain: domain, name }
-    })
-
-    return await repository.save({
-      ...inventoryHistory,
-      ...patch,
-      updater: user
-    })
-  }
-}

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

@@ -1,48 +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 updateMultipleInventoryHistory = {
-  async updateMultipleInventoryHistory(_: 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 inventoryHistoryRepo = tx.getRepository(InventoryHistory)
-
-    if (_createRecords.length > 0) {
-      let newRecord = new InventoryHistory()
-      for (let i = 0; i < _createRecords.length; i++) {
-        newRecord = _createRecords[i]
-      }
-
-      const result = await inventoryHistoryRepo.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 inventoryHistory = await inventoryHistoryRepo.findOne(newRecord.id)
-
-        const result = await inventoryHistoryRepo.save({
-          ...inventoryHistory,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,25 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, Repository } from 'typeorm'
-import { Location, Warehouse } from '../../../entities'
-
-export const createLocationResolver = {
-  async createLocation(_: any, { location }, context: any) {
-    return await createLocation(location, context)
-  }
-}
-
-export async function createLocation(location: Location, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-  const locationRepository: Repository<Location> = tx.getRepository(Location)
-  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
-
-  return await locationRepository.save({
-    ...location,
-    warehouse: await warehouseRepository.findOne(location.warehouse.id),
-    domain,
-    creator: user,
-    updater: user
-  })
-}

package/server/graphql/resolvers/location/delete-all-locations.ts

@@ -1,12 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { Location, Warehouse } from '../../../entities'
-
-export const deleteAllLocations = {
-  async deleteAllLocations(_: any, { warehouseId }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    await tx.getRepository(Location).delete({
-      warehouse: await tx.getRepository(Warehouse).findOne(warehouseId)
-    })
-  }
-}

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

@@ -1,16 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-import { Location } from '../../../entities'
-
-export const deleteLocationResolver = {
-  async deleteLocation(_: any, { id }, context: any) {
-    await deleteLocation(id, context)
-  }
-}
-
-export async function deleteLocation(id: string, context: any) {
-  const { tx }: { tx: EntityManager } = context.state
-
-  const repository: Repository<Location> = tx.getRepository(Location)
-  await repository.delete(id)
-  return true
-}

package/server/graphql/resolvers/location/delete-locations.ts

@@ -1,16 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-import { Location } from '../../../entities'
-
-export const deleteLocationsResolver = {
-  async deleteLocations(_: any, { ids }, context: any) {
-    await deleteLocations(ids, context)
-  }
-}
-
-export async function deleteLocations(ids: string[], context: any) {
-  const { tx }: { tx: EntityManager } = context.state
-
-  const repository: Repository<Location> = tx.getRepository(Location)
-  await repository.delete(ids)
-  return true
-}

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

@@ -1,30 +0,0 @@
-import { createLocation, createLocationResolver } from './create-location'
-import { deleteAllLocations } from './delete-all-locations'
-import { deleteLocation, deleteLocationResolver } from './delete-location'
-import { deleteLocations, deleteLocationsResolver } from './delete-locations'
-import { locationResolver } from './location'
-import { locationByNameResolver } from './location-by-name'
-import { locationOccupanciesResolver } from './location-occupancies'
-import { locationsByGroupResolver } from './locations-by-group'
-import { locationsResolver } from './locations'
-import { updateLocation, updateLocationResolver } from './update-location'
-import { updateMultipleLocation } from './update-multiple-location'
-
-export const Query = {
-  ...locationsResolver,
-  ...locationResolver,
-  ...locationByNameResolver,
-  ...locationOccupanciesResolver,
-  ...locationsByGroupResolver
-}
-
-export const Mutation = {
-  ...updateLocationResolver,
-  ...createLocationResolver,
-  ...deleteLocationResolver,
-  ...deleteLocationsResolver,
-  ...deleteAllLocations,
-  ...updateMultipleLocation
-}
-
-export { updateLocation, createLocation, deleteLocation, deleteLocations }

package/server/graphql/resolvers/location/location-by-name.ts

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

package/server/graphql/resolvers/location/location-occupancies.ts

@@ -1,45 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Location, Warehouse } from '../../../entities'
-
-export const locationOccupanciesResolver = {
-  async locationOccupancies(_: any, { warehouse }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    var where = {
-      domain: domain,
-      type: 'SHELF'
-    }
-
-    if (warehouse !== '') {
-      const foundWarehouse = await getRepository(Warehouse).findOne({
-        where: {
-          domain: domain,
-          name: warehouse
-        }
-      })
-
-      if (foundWarehouse) where['warehouse'] = foundWarehouse.id
-      else throw new Error(`${warehouse} was not found!`)
-    }
-
-    const locations = await getRepository(Location).find({
-      where,
-      relations: ['domain', 'warehouse', 'creator', 'updater']
-    })
-
-    let occupied = 0
-    locations.forEach(location => {
-      if (location.status === 'OCCUPIED') occupied += 1
-    })
-
-    const total = locations.length
-
-    const empty = total - occupied
-
-    let percentage = 0
-    if (occupied !== 0) percentage = Math.round((occupied / total) * 100)
-
-    return { total, occupied, empty, percentage }
-  }
-}

package/server/graphql/resolvers/location/location.ts

@@ -1,10 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Location } from '../../../entities'
-
-export const locationResolver = {
-  async location(_: any, { id }, context: any) {
-    return await getRepository(Location).findOne(id, {
-      relations: ['domain', 'warehouse', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/location/locations-by-group.ts

@@ -1,29 +0,0 @@
-import { Domain, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Location } from '../../../entities'
-
-export const locationsByGroupResolver = {
-  async locationsByGroup(_: any, params: ListParam, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const warehouseIdParam = params.filters.find(param => param.name = 'warehouse_id')
-    
-    if (!warehouseIdParam.value) throw new Error (`invalid warehouse ID`)
-
-    const items = await getRepository(Location).query(`
-      SELECT CONCAT("zone",'-',"row",'-',"column") as name, "zone", "row", "column"
-      FROM locations WHERE domain_id = '${domain.id}'
-      AND warehouse_id = '${warehouseIdParam.value}'
-      GROUP BY "zone", "row", "column"
-    `)
-
-    let [{ total }] = await getRepository(Location).query(`
-      SELECT COUNT(DISTINCT("zone", "row", "column")) as total
-      FROM locations WHERE domain_id = '${domain.id}'
-      AND warehouse_id = '${warehouseIdParam.value}'
-    `)
-
-    total = parseInt(total)
-
-    return { items, total }
-  } 
-}

package/server/graphql/resolvers/location/locations.ts

@@ -1,18 +0,0 @@
-import { buildQuery, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Location } from '../../../entities'
-
-export const locationsResolver = {
-  async locations(_: any, params: ListParam, context: any) {
-    const queryBuilder = getRepository(Location).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-    const [items, total] = await queryBuilder
-      .leftJoinAndSelect('Location.domain', 'Domain')
-      .leftJoinAndSelect('Location.warehouse', 'Warehouse')
-      .leftJoinAndSelect('Location.creator', 'Creator')
-      .leftJoinAndSelect('Location.updater', 'Updater')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-}

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

@@ -1,27 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { EntityManager, Repository } from 'typeorm'
-import { Location, Warehouse } from '../../../entities'
-
-export const updateLocationResolver = {
-  async updateLocation(_: any, { id, patch }, context: any) {
-    return await updateLocation(id, patch, context.state.user)
-  }
-}
-
-export async function updateLocation(id: string, patch: Location, context: any) {
-  const { user, tx }: { user: User; tx: EntityManager } = context.state
-
-  const locationRepository: Repository<Location> = tx.getRepository(Location)
-  const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  const location: Location = await locationRepository.findOne(id)
-
-  if (patch.warehouse && patch.warehouse.id) {
-    patch.warehouse = await warehouseRepository.findOne(patch.warehouse.id)
-  }
-
-  return await locationRepository.save({
-    ...location,
-    ...patch,
-    updater: user
-  })
-}

package/server/graphql/resolvers/location/update-multiple-location.ts

@@ -1,29 +0,0 @@
-import { Location } from '../../../entities'
-import { createLocation } from './create-location'
-import { updateLocation } from './update-location'
-
-export const updateMultipleLocation = {
-  async updateMultipleLocation(_: any, { patches }, context: any) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const patch: Location = _createRecords[i]
-        const result = await createLocation(patch, context)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: Location = _updateRecords[i]
-        const result = await updateLocation(patch.id, patch, context)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,13 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Movement } from '../../../entities'
-
-export const createMovement = {
-  async createMovement(_: any, { movement }, context: any) {
-    return await getRepository(Movement).save({
-      ...movement,
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-  }
-}

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

@@ -1,9 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Movement } from '../../../entities'
-
-export const deleteMovement = {
-  async deleteMovement(_: any, { name }) {
-    await getRepository(Movement).delete(name)
-    return true
-  }
-}