@things-factory/warehouse-base 3.7.13 → 3.8.1

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,32 +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'
-import { locationWithInventoriesResolver } from './location-with-inventories'
-
-export const Query = {
-  ...locationsResolver,
-  ...locationResolver,
-  ...locationByNameResolver,
-  ...locationOccupanciesResolver,
-  ...locationsByGroupResolver,
-  ...locationWithInventoriesResolver
-}
-
-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,33 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { Location, Warehouse } from '../../../entities'
-
-export const locationOccupanciesResolver = {
-  async locationOccupancies(_: any, { warehouse, types }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    const foundWarehouse: Warehouse = await getRepository(Warehouse).findOne({
-      where: {
-        domain,
-        name: warehouse
-      },
-      relations: ['locations']
-    })
-
-    if (!foundWarehouse) throw new Error(`${warehouse} was not found!`)
-
-    const locations: Location[] =
-      types && types.length
-        ? foundWarehouse?.locations?.filter((location: Location) => types.indexOf(location.type) !== -1)
-        : foundWarehouse?.locations
-
-    const total: number = locations.length
-    const occupied: number = locations.filter((location: Location) => location.status === 'OCCUPIED')?.length || 0
-    const empty: number = total - occupied
-    const percentage: number = occupied > 0 ? Math.round((occupied / total) * 100) : 0
-
-    return { total, occupied, empty, percentage }
-  }
-}

package/server/graphql/resolvers/location/location-with-inventories.ts

@@ -1,87 +0,0 @@
-import { buildQuery, ListParam, Domain } from '@things-factory/shell'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { getRepository } from 'typeorm'
-import { INVENTORY_STATUS } from '../../../constants/inventory'
-import { Inventory, Location } from '../../../entities'
-import { User } from '@things-factory/auth-base'
-
-export const locationWithInventoriesResolver = {
-  async locationWithInventories(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-    const bizplaceIds = await getPermittedBizplaceIds(domain, user)
-    const queryBuilder = getRepository(Location).createQueryBuilder()
-
-    const warehouseName = params.filters.find(x => x.name === 'warehouseName' && x.operator.toLowerCase() === 'eq')
-      ?.value
-
-    params.filters = []
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .innerJoinAndSelect('Location.domain', 'Domain')
-      .leftJoinAndSelect('Location.warehouse', 'Warehouse')
-      .leftJoinAndSelect(
-        'inventories',
-        'Inventory',
-        'Location.id = Inventory.location_id AND Inventory.status = :InvStatus',
-        {
-          InvStatus: INVENTORY_STATUS.STORED
-        }
-      )
-      .leftJoinAndSelect('Inventory.product', 'Product')
-      .leftJoinAndSelect('Inventory.bizplace', 'Bizplace', 'Bizplace.id IN (:...bizplaceIds)', {
-        bizplaceIds: [...new Set(bizplaceIds)]
-      })
-      .leftJoinAndSelect('Inventory.creator', 'Creator')
-      .leftJoinAndSelect('Inventory.updater', 'Updater')
-
-    if (warehouseName) {
-      queryBuilder.andWhere('Warehouse.name = :warehouseName', { warehouseName })
-    }
-
-    let items = await queryBuilder.getRawMany()
-    const total = await queryBuilder.getCount()
-
-    items = items
-      .map(item => {
-        return {
-          id: item.Location_id,
-          name: item.Location_name,
-          bizplace: {
-            name: item.Bizplace_name || '',
-            description: item.Bizplace_description || ''
-          },
-          product: {
-            name: item.Product_name || '',
-            sku: item.Product_sku || '',
-            description: item.Product_description || ''
-          },
-          palletId: item.Inventory_pallet_id || '',
-          batchId: item.Inventory_batch_id || '',
-          qty: item.Inventory_qty || 0,
-          uomValue: item.Inventory_uom_value || 0.0,
-          uom: item.Inventory_uom || '',
-          packingType: item.Inventory_packing_type || '',
-          packingSize: item.Inventory_packing_size || 0.0,
-          expirationDate: item.Inventory_expiration_date || '',
-          warehouse: item.Warehouse_name,
-          zone: item.Location_zone
-        }
-      })
-      .reduce((acc, curr) => {
-        acc.push(curr)
-
-        const accQty: number =
-          curr.palletId !== '' ? acc.filter(x => x.id === curr.id).reduce((x, y) => (x += y.qty), 0) : 0
-
-        acc = acc.map(x => {
-          if (x.id === curr.id) return { ...x, accumulatedQty: accQty }
-          else return { ...x }
-        })
-
-        return acc
-      }, [])
-
-    return { items, total }
-  }
-}

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

@@ -1,12 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { Location } from '../../../entities'
-
-export const locationResolver = {
-  async location(_: any, { name }, context: any) {
-    return await getRepository(Location).findOne({
-      where: { name },
-      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
-  }
-}

package/server/graphql/resolvers/movement/inbound-movements-counter.ts

@@ -1,69 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain, ListParam } from '@things-factory/shell'
-
-import { InventoryHistory } from '../../../entities'
-
-export const inboundMovementsCounterResolver = {
-  async inboundMovementsCounter(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    let bizplaces = await getPermittedBizplaceIds(domain, user)
-    bizplaces = bizplaces
-      .map(bizplace => {
-        return "'" + bizplace.trim() + "'"
-      })
-      .join(',')
-
-    let startDate = new Date()
-    let endDate = new Date()
-    startDate.setDate(startDate.getDate() - 30)
-    startDate.setHours(0)
-    startDate.setMinutes(0)
-    startDate.setSeconds(0)
-    const timeNow = `${endDate.getHours()}:${endDate.getMinutes()}:${endDate.getSeconds()}`
-
-    const counter = await getRepository(InventoryHistory).query(`
-      select inbound_date, count(*) from(
-        select date(ih.created_at) inbound_date from inventory_histories ih
-        where ih.bizplace_id in (${bizplaces})
-        and ih.transaction_type in ('NEW', 'PUTAWAY')
-        and created_at between '${startDate.toLocaleDateString()} 00:00:00' and '${endDate.toLocaleDateString()} ${timeNow}'
-        and domain_id = '${domain.id}'
-      ) as foo
-      group by inbound_date
-      order by inbound_date asc
-    `)
-
-    let items = []
-    for (let i = 0; i < 30; i++) {
-      const month = startDate.toLocaleString('default', { month: 'short' })
-      const day = startDate.getDate()
-
-      items.push({
-        date: `${month} ${day.toString().padStart(2, '0')}`,
-        count: '0'
-      })
-      startDate.setDate(startDate.getDate() + 1)
-    }
-
-    let compareDate = new Date()
-    compareDate.setDate(compareDate.getDate() - 30)
-    compareDate.setHours(0)
-    compareDate.setMinutes(0)
-    compareDate.setSeconds(0)
-
-    items = items.map((item: { date: string; count: number }) => {
-      item.count =
-        counter.find(ctr => ctr.inbound_date.toLocaleDateString() === compareDate.toLocaleDateString())?.count || 0
-
-      compareDate.setDate(compareDate.getDate() + 1)
-
-      return item
-    })
-
-    return items
-  }
-}

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

@@ -1,23 +0,0 @@
-import { movementResolver } from './movement'
-import { movementsResolver } from './movements'
-import { inboundMovementsCounterResolver } from './inbound-movements-counter'
-import { outboundMovementsCounterResolver } from './outbound-movements-counter'
-import { weeklyMovementsCounterResolver } from './weekly-movements-counter'
-
-import { updateMovement } from './update-movement'
-import { createMovement } from './create-movement'
-import { deleteMovement } from './delete-movement'
-
-export const Query = {
-  ...movementsResolver,
-  ...movementResolver,
-  ...inboundMovementsCounterResolver,
-  ...outboundMovementsCounterResolver,
-  ...weeklyMovementsCounterResolver
-}
-
-export const Mutation = {
-  ...updateMovement,
-  ...createMovement,
-  ...deleteMovement
-}

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

@@ -1,16 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { getRepository, In } from 'typeorm'
-import { Movement } from '../../../entities'
-
-export const movementResolver = {
-  async movement(_: any, { name }, context: any) {
-    return await getRepository(Movement).findOne({
-      where: {
-        domain: context.state.domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
-      },
-      relations: ['domain', 'bizplace', 'inventory', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/movement/movements.ts

@@ -1,17 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { Movement } from '../../../entities'
-
-export const movementsResolver = {
-  async movements(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
-
-    const [items, total] = await getRepository(Movement).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'inventory', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/movement/outbound-movements-counter.ts

@@ -1,71 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { InventoryHistory } from '../../../entities'
-
-export const outboundMovementsCounterResolver = {
-  async outboundMovementsCounter(_: any, { month, year }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    let bizplaces = await getPermittedBizplaceIds(domain, user)
-    bizplaces = bizplaces
-      .map(bizplace => {
-        return "'" + bizplace.trim() + "'"
-      })
-      .join(',')
-
-    let startDate = new Date()
-    let endDate = new Date()
-    startDate.setDate(startDate.getDate() - 30)
-    startDate.setHours(0)
-    startDate.setMinutes(0)
-    startDate.setSeconds(0)
-    const timeNow = `${endDate.getHours()}:${endDate.getMinutes()}:${endDate.getSeconds()}`
-
-    const counter = await getRepository(InventoryHistory).query(`
-      select outbound_date, count(*) from(
-        select date(ih.created_at) outbound_date, row_number() over(partition by ih.pallet_id order by ih.created_at desc) as rn, ih.*, iv.bizplace_id
-        from inventory_histories ih
-        inner join inventories iv on iv.pallet_id = ih.pallet_id and iv.domain_id = ih.domain_id
-        where ih.domain_id='${domain.id}'
-        and iv.bizplace_id in (${bizplaces}) and ih.status = 'TERMINATED'
-      ) as src 
-      where rn = 1
-      and created_at between '${startDate.toLocaleDateString()} 00:00:00' and '${endDate.toLocaleDateString()} ${timeNow}'
-      group by src.outbound_date
-      order by src.outbound_date
-    `)
-
-    let items = []
-    for (let i = 0; i < 30; i++) {
-      const month = startDate.toLocaleString('default', { month: 'short' })
-      const day = startDate.getDate()
-
-      items.push({
-        date: `${month} ${day.toString().padStart(2, '0')}`,
-        count: '0'
-      })
-      startDate.setDate(startDate.getDate() + 1)
-    }
-
-    let compareDate = new Date()
-    compareDate.setDate(compareDate.getDate() - 30)
-    compareDate.setHours(0)
-    compareDate.setMinutes(0)
-    compareDate.setSeconds(0)
-
-    items = items.map((item: { date: string; count: number }) => {
-      item.count =
-        counter.find(ctr => ctr.outbound_date.toLocaleDateString() === compareDate.toLocaleDateString())?.count || 0
-
-      compareDate.setDate(compareDate.getDate() + 1)
-
-      return item
-    })
-
-    return items
-  }
-}

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

@@ -1,25 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { getRepository, In } from 'typeorm'
-import { Inventory, Movement } from '../../../entities'
-
-export const updateMovement = {
-  async updateMovement(_: any, { id, patch }, context: any) {
-    const movement = await getRepository(Movement).findOne({
-      where: {
-        domain: context.state.domain,
-        id,
-        bizplace: In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
-      }
-    })
-
-    if (patch.inventory && patch.inventory.id) {
-      patch.inventory = await getRepository(Inventory).findOne(patch.inventory.id)
-    }
-
-    return await getRepository(Movement).save({
-      ...movement,
-      ...patch,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/movement/weekly-movements-counter.ts

@@ -1,84 +0,0 @@
-import { getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { InventoryHistory } from '../../../entities'
-
-export const weeklyMovementsCounterResolver = {
-  async weeklyMovementsCounter(_: any, { month, year }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    let bizplaces = await getPermittedBizplaceIds(domain, user)
-    bizplaces = bizplaces
-      .map(bizplace => {
-        return "'" + bizplace.trim() + "'"
-      })
-      .join(',')
-
-    if (!month && !year) {
-      // if user didn't specify the month and year, set default as last month
-      var firstOfMonth = new Date()
-      var lastOfMonth = new Date()
-
-      firstOfMonth.setMonth(firstOfMonth.getMonth() - 1)
-      firstOfMonth.setDate(1)
-      lastOfMonth.setDate(0)
-    } else {
-      var firstOfMonth = new Date(year, month - 1, 1)
-      var lastOfMonth = new Date(year, month, 0)
-    }
-
-    // get data from database
-    const data = await getRepository(InventoryHistory).query(`
-			select movement_date, sum(outbound_count) as outbound_count, sum(inbound_count) as inbound_count from (
-				select movement_date, count(*) as outbound_count, 0 as inbound_count from(
-					select date(ih.created_at) movement_date, row_number() over(partition by ih.pallet_id order by ih.created_at desc) as rn, ih.*, iv.bizplace_id
-					from inventory_histories ih
-					inner join inventories iv on iv.pallet_id = ih.pallet_id and iv.domain_id = ih.domain_id
-					where ih.domain_id = '${domain.id}'
-					and iv.bizplace_id in (${bizplaces}) and ih.status = 'TERMINATED'
-				) as src 
-				where rn = 1
-				and created_at between '${firstOfMonth.toLocaleDateString()} 00:00:00' and '${lastOfMonth.toLocaleDateString()} 23:59:59'
-				group by movement_date
-				union all
-				select movement_date, 0 as outbound_count, count(*) as inbound_count from(
-						select date(ih.created_at) movement_date from inventory_histories ih
-						where ih.bizplace_id in (${bizplaces})
-						and ih.transaction_type in ('NEW', 'PUTAWAY')
-						and created_at between '${firstOfMonth.toLocaleDateString()} 00:00:00' and '${lastOfMonth.toLocaleDateString()} 23:59:59'
-					and domain_id = '${domain.id}'
-				) as foo
-				group by movement_date
-				order by movement_date
-			) src
-			group by movement_date
-		`)
-
-    let movements = [
-      { week: 'Week 01', ...getMovementByWeek(data, [0, 7]) },
-      { week: 'Week 02', ...getMovementByWeek(data, [8, 14]) },
-      { week: 'Week 03', ...getMovementByWeek(data, [15, 21]) },
-      { week: 'Week 04', ...getMovementByWeek(data, [21, 31]) }
-    ]
-
-    // return total 4 weeks of in/outbound movements for a specific month
-    return movements
-  }
-}
-
-function getMovementByWeek(data, range): { inbound: number; outbound: number } {
-  return data
-    .filter(item => item.movement_date.getDate() > range[0] && item.movement_date.getDate() <= range[1])
-    .reduce(
-      (inout: { inbound: number; outbound: number }, curr) => {
-        inout.inbound += Number(curr.inbound_count)
-        inout.outbound += Number(curr.outbound_count)
-
-        return inout
-      },
-      { inbound: 0, outbound: 0 }
-    )
-}