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

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

@@ -1,68 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-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 => {
-      for (let x = 0; x < counter.length; x++) {
-        if (counter[x].inbound_date.toLocaleDateString() === compareDate.toLocaleDateString()) {
-          item.count = counter[x].count
-        }
-      }
-      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,70 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-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 => {
-      for (let x = 0; x < counter.length; x++) {
-        if (counter[x].outbound_date.toLocaleDateString() === compareDate.toLocaleDateString()) {
-          item.count = counter[x].count
-        }
-      }
-      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,94 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-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
-		`)
-
-    // pre-set the movements accordingly with initial value of in/outbound = 0
-    let movements = [
-      { week: 'Week 01', inbound: 0, outbound: 0 },
-      { week: 'Week 02', inbound: 0, outbound: 0 },
-      { week: 'Week 03', inbound: 0, outbound: 0 },
-      { week: 'Week 04', inbound: 0, outbound: 0 }
-    ]
-
-    // loop through all date that were retrieved from database
-    for (let i = 0; i < data.length; i++) {
-      // asign data based on week number
-      movements = movements.map(movement => {
-        const compareDate = data[i].movement_date
-        const inboundCount = parseInt(data[i].inbound_count)
-        const outboundCount = parseInt(data[i].outbound_count)
-
-        if (movement.week === 'Week 01' && compareDate.getDate() > 0 && compareDate.getDate() <= 7) {
-          movement.inbound += inboundCount
-          movement.outbound += outboundCount
-        } else if (movement.week === 'Week 02' && compareDate.getDate() > 7 && compareDate.getDate() <= 14) {
-          movement.inbound += inboundCount
-          movement.outbound += outboundCount
-        } else if (movement.week === 'Week 03' && compareDate.getDate() > 14 && compareDate.getDate() <= 21) {
-          movement.inbound += inboundCount
-          movement.outbound += outboundCount
-        } else if (movement.week === 'Week 04' && compareDate.getDate() > 21) {
-          movement.inbound += inboundCount
-          movement.outbound += outboundCount
-        }
-        return movement
-      })
-    }
-
-    // return total 4 weeks of in/outbound movements for a specific month
-    return movements
-  }
-}

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

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

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

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

package/server/graphql/resolvers/pallet/delete-pallets.ts

@@ -1,44 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { Pallet, PalletHistory } from '../../../entities'
-
-export const deletePallets = {
-  async deletePallets(_: any, { id }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx:EntityManager } = context.state
-    
-    const pallets = await tx.getRepository(Pallet).find({
-      where: {
-        domain: domain,
-        id: In(id)
-      },
-      relations: ['owner', 'holder']
-    })
-
-    await Promise.all(
-      pallets.map(async (pallet: Pallet) => {
-        let seq = pallet.seq + 1
-        await tx.getRepository(Pallet).save({
-          ...pallet,
-          status: 'TERMINATED',
-          seq,
-          updater: user
-        })
-
-        await tx.getRepository(PalletHistory).save({
-          pallet: pallet,
-          name: pallet.name,
-          owner: pallet.owner,
-          holder: pallet.holder,
-          seq,
-          domain: domain,
-          creator: user,
-          updater: user,
-          status: 'TERMINATED',
-          transactionType: 'UPDATE'
-        })
-      })
-    )
-    return true
-  }
-}

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

@@ -1,29 +0,0 @@
-import { palletResolver } from './pallet'
-import { palletsResolver } from './pallets'
-import { palletInboundValidateResolver } from './pallet-inbound-validate'
-import { palletOutboundValidateResolver } from './pallet-outbound-validate'
-import { palletByStatusResolver } from './pallet-by-status'
-
-import { updatePallet } from './update-pallet'
-import { updateMultiplePallet } from './update-multiple-pallet'
-import { createPallet } from './create-pallet'
-import { deletePallet } from './delete-pallet'
-import { deletePallets } from './delete-pallets'
-import { palletReturn } from './pallet-return'
-
-export const Query = {
-  ...palletsResolver,
-  ...palletResolver,
-  ...palletInboundValidateResolver,
-  ...palletOutboundValidateResolver,
-  ...palletByStatusResolver
-}
-
-export const Mutation = {
-  ...updatePallet,
-  ...updateMultiplePallet,
-  ...createPallet,
-  ...deletePallet,
-  ...deletePallets,
-  ...palletReturn
-}

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

@@ -1,16 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Pallet } from '../../../entities'
-
-export const palletByStatusResolver = {
-  async palletByStatus(_: any, { name, status }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    let records = await getRepository(Pallet).findOne({
-      where: { domain: domain, name, status },
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-
-    return records
-  }
-}

package/server/graphql/resolvers/pallet/pallet-inbound-validate.ts

@@ -1,21 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Pallet } from '../../../entities'
-
-export const palletInboundValidateResolver = {
-  async palletInboundValidate(_: any, { name }, context: any) {
-    try {
-      const { domain }: { domain: Domain } = context.state
-
-      let item = await getRepository(Pallet).findOne({
-        where: { domain: domain, name },
-        relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-      })
-      if (!item || item?.status != 'ACTIVE') return { error: 'Not found' }
-      if (item?.owner?.id === item?.holder?.id) return { error: 'Pallet already in warehouse!' }
-      return { item }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/pallet/pallet-outbound-validate.ts

@@ -1,21 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Pallet } from '../../../entities'
-
-export const palletOutboundValidateResolver = {
-  async palletOutboundValidate(_: any, { name }, context: any) {
-    try {
-      const { domain }: { domain: Domain } = context.state
-
-      let item = await getRepository(Pallet).findOne({
-        where: { domain: domain, name },
-        relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-      })
-      if (!item || item?.status != 'ACTIVE') return { error: 'Not found' }
-      if (item?.owner?.id != item?.holder?.id) return { error: 'Pallet not in warehouse!' }
-      return { item }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/pallet/pallet-return.ts

@@ -1,57 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { Pallet, PalletHistory } from '../../../entities'
-
-export const palletReturn = {
-  async palletReturn(_: any, { patches }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    let results = []
-    const _updateRecords = patches
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const pallet = await tx.getRepository(Pallet).findOne({
-          where: { id: newRecord.id },
-          relations: ['owner', 'holder']
-        })
-        const seq = pallet.seq + 1
-
-        newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
-        newRecord.holder = newRecord.owner
-
-        const result = await tx.getRepository(Pallet).save({
-          ...pallet,
-          ...newRecord,
-          seq,
-          updater: user,
-          refOrderNo: null
-        })
-
-        let newHistory = {
-          ...pallet,
-          ...newRecord,
-          pallet: result,
-          seq,
-          domain: domain,
-          creator: user,
-          updater: user,
-          transactionType: 'RETURN'
-        }
-
-        delete newHistory.id
-
-        await tx.getRepository(PalletHistory).save({
-          ...newHistory
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/pallet/pallet.ts

@@ -1,15 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Pallet } from '../../../entities'
-
-export const palletResolver = {
-  async pallet(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    let records = await getRepository(Pallet).findOne({
-      where: { domain: domain, name },
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-    return records
-  }
-}

package/server/graphql/resolvers/pallet/pallets.ts

@@ -1,22 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Pallet } from '../../../entities'
-
-export const palletsResolver = {
-  async pallets(_: any, params: ListParam, context: any) {
-    if (!params.filters.find((filter: any) => filter.name === 'status')) {
-      params.filters.push({
-        name: 'status',
-        operator: 'noteq',
-        value: 'TERMINATED'
-      })
-    }
-
-    const convertedParams = convertListParams(params, context.state.domain.id)
-    const [items, total] = await getRepository(Pallet).findAndCount({
-      ...convertedParams,
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}