@things-factory/warehouse-base 3.7.13 → 3.8.1

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

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

@@ -1,95 +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 updateMultiplePallet = {
-  async updateMultiplePallet(_: 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')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
-        }
-
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
-        }
-
-        const result: Pallet = await tx.getRepository(Pallet).save({
-          domain: domain,
-          creator: user,
-          updater: user,
-          ...newRecord
-        })
-
-        await tx.getRepository(PalletHistory).save({
-          ...newRecord,
-          pallet: result,
-          domain: domain,
-          creator: user,
-          updater: user,
-          transactionType: 'NEW'
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    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
-
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
-        }
-
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
-        }
-
-        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: 'UPDATE'
-        }
-
-        delete newHistory.id
-
-        await tx.getRepository(PalletHistory).save({
-          ...newHistory
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

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

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

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-import { palletCountResolver } from './pallet-count'
-import { palletCountsResolver } from './pallet-counts'
-
-import { updatePalletCount } from './update-pallet-count'
-import { updateMultiplePalletCount } from './update-multiple-pallet-count'
-import { createPalletCount } from './create-pallet-count'
-import { deletePalletCount } from './delete-pallet-count'
-import { deletePalletCounts } from './delete-pallet-counts'
-import { updatePalletCountSeq } from './update-pallet-count-seq'
-
-export const Query = {
-  ...palletCountsResolver,
-  ...palletCountResolver,
-}
-
-export const Mutation = {
-  ...updatePalletCount,
-  ...updateMultiplePalletCount,
-  ...createPalletCount,
-  ...deletePalletCount,
-  ...deletePalletCounts,
-  ...updatePalletCountSeq
-}

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

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

package/server/graphql/resolvers/pallet-count/pallet-counts.ts

@@ -1,14 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { PalletCount } from '../../../entities'
-
-export const palletCountsResolver = {
-  async palletCounts(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(PalletCount).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/pallet-count/update-multiple-pallet-count.ts

@@ -1,47 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { PalletCount } from '../../../entities'
-
-export const updateMultiplePalletCount = {
-  async updateMultiplePalletCount(_: 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 palletCountRepo = tx.getRepository(PalletCount)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await palletCountRepo.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 palletCount = await palletCountRepo.findOne(newRecord.id)
-
-        const result = await palletCountRepo.save({
-          ...palletCount,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/pallet-count/update-pallet-count-seq.ts

@@ -1,44 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, MoreThan } from 'typeorm'
-import { PalletCount } from '../../../entities'
-import uuid from 'uuid/v4'
-
-export const updatePalletCountSeq = {
-  async updatePalletCountSeq(_: any, { printQty }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(PalletCount)
-    const todayDate = new Date()
-    todayDate.setHours(0, 0, 0, 0)
-    const palletCount = await repository.findOne({
-      where: { domain: domain, createdAt: MoreThan(todayDate) }
-    })
-
-    if (!palletCount) {
-      let newPallet = {
-        name: uuid(),
-        seq: 0,
-        domain: domain,
-        creator: user,
-        updater: user
-      }
-
-      await tx.getRepository(PalletCount).save({
-        ...newPallet,
-        seq: printQty
-      })
-
-      return {
-        newPallet
-      }
-    } else {
-      await tx.getRepository(PalletCount).save({
-        ...palletCount,
-        seq: printQty + palletCount.seq
-      })
-
-      return palletCount
-    }
-  }
-}

package/server/graphql/resolvers/pallet-count/update-pallet-count.ts

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

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

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

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

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

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

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