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

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

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

@@ -1,21 +0,0 @@
-import { palletHistoryResolver } from './pallet-history'
-import { palletHistoriesResolver } from './pallet-histories'
-
-import { updatePalletHistory } from './update-pallet-history'
-import { updateMultiplePalletHistory } from './update-multiple-pallet-history'
-import { createPalletHistory } from './create-pallet-history'
-import { deletePalletHistory } from './delete-pallet-history'
-import { deletePalletHistories } from './delete-pallet-histories'
-
-export const Query = {
-  ...palletHistoriesResolver,
-  ...palletHistoryResolver
-}
-
-export const Mutation = {
-  ...updatePalletHistory,
-  ...updateMultiplePalletHistory,
-  ...createPalletHistory,
-  ...deletePalletHistory,
-  ...deletePalletHistories
-}

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

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

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

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

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

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

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

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

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

@@ -1,22 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, Repository } from 'typeorm'
-import { Warehouse } from '../../../entities'
-
-export const createWarehouseResolver = {
-  async createWarehouse(_: any, { warehouse }, context: any) {
-    return await createWarehouse(warehouse, context)
-  }
-}
-
-export async function createWarehouse(warehouse: Warehouse, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  return await repository.save({
-    ...warehouse,
-    domain,
-    creator: user,
-    updater: user
-  })
-}

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

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

package/server/graphql/resolvers/warehouse/delete-warehouses.ts

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

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

@@ -1,22 +0,0 @@
-import { createWarehouse, createWarehouseResolver } from './create-warehouse'
-import { deleteWarehouse, deleteWarehouseResolver } from './delete-warehouse'
-import { deleteWarehouses, deleteWarehousesResolver } from './delete-warehouses'
-import { updateMultipleWarehouse } from './update-multiple-warehouse'
-import { updateWarehouse, updateWarehouseResolver } from './update-warehouse'
-import { warehouseResolver } from './warehouse'
-import { warehousesResolver } from './warehouses'
-
-export const Query = {
-  ...warehousesResolver,
-  ...warehouseResolver
-}
-
-export const Mutation = {
-  ...updateWarehouseResolver,
-  ...createWarehouseResolver,
-  ...deleteWarehouseResolver,
-  ...deleteWarehousesResolver,
-  ...updateMultipleWarehouse
-}
-
-export { createWarehouse, updateWarehouse, deleteWarehouses, deleteWarehouse }

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

@@ -1,29 +0,0 @@
-import { Warehouse } from '../../../entities'
-import { createWarehouse } from './create-warehouse'
-import { updateWarehouse } from './update-warehouse'
-
-export const updateMultipleWarehouse = {
-  async updateMultipleWarehouse(_: any, { patches }, context: any): Promise<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: Warehouse = _createRecords[i]
-        const result = await createWarehouse(patch, context)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: Warehouse = _updateRecords[i]
-        const result = await updateWarehouse(patch.id, patch, context)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,23 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, Repository } from 'typeorm'
-import { Warehouse } from '../../../entities'
-
-export const updateWarehouseResolver = {
-  async updateWarehouse(_: any, { id, patch }, context: any) {
-    return await updateWarehouse(id, patch, context)
-  }
-}
-
-export async function updateWarehouse(id: string, patch: Warehouse, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  const warehouse = await repository.findOne(id)
-
-  return await repository.save({
-    ...warehouse,
-    ...patch,
-    updater: user
-  })
-}

package/server/graphql/resolvers/warehouse/warehouse.ts

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