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

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

@@ -1,102 +0,0 @@
-import { Bizplace } from '@things-factory/biz-base'
-import { EntityManager, In } from 'typeorm'
-import { Claim, ClaimDetail, ClaimOrder, CollectionOrder, DeliveryOrder } from '../../../entities'
-
-export const updateClaim = {
-  async updateClaim(_: any, { id, patch }, context: any) {
-    try {
-      const { tx }: { tx: EntityManager } = context.state
-      const targetClaim: Claim = await tx.getRepository(Claim).findOne({
-        where: { domain: context.state.domain, id },
-        relations: ['claimDetails', 'claimOrders', 'bizplace', 'updater']
-      })
-      if (!targetClaim) throw new Error('claim not exists')
-
-      let bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          domain: context.state.domain,
-          id: patch.bizplace
-        }
-      })
-
-      tx.query(`
-          DELETE FROM
-            claim_orders
-          WHERE
-            claim_id = '${targetClaim.id}'
-        `)
-      tx.query(`
-          DELETE FROM
-            claim_details
-          WHERE
-            claim_id = '${targetClaim.id}'
-        `)
-
-      let arrClaimOrdersName = patch.claimOrders.map(item => {
-        return item.name
-      })
-
-      let newClaimOrders = []
-      let deliveryOrder = await tx.getRepository(DeliveryOrder).find({
-        where: { name: In(arrClaimOrdersName), domain: context.state.domain }
-      })
-
-      let collectionOrder = await tx.getRepository(CollectionOrder).find({
-        where: { name: In(arrClaimOrdersName), domain: context.state.domain }
-      })
-
-      deliveryOrder.map(order => {
-        newClaimOrders.push({
-          name: order.name,
-          deliveryOrder: order
-        })
-      })
-
-      collectionOrder.map(order => {
-        newClaimOrders.push({
-          name: order.name,
-          collectionOrder: order
-        })
-      })
-
-      debugger
-      await tx.getRepository(Claim).save({
-        ...targetClaim,
-        ...patch,
-        bizplace: bizplace,
-        updater: context.state.user
-      })
-
-      const claimOrders = await Promise.all(
-        newClaimOrders.map(async (ClaimOrder: ClaimOrder) => {
-          return {
-            ...ClaimOrder,
-            claim: targetClaim,
-            domain: context.state.domain,
-            creator: context.state.user,
-            updater: context.state.user
-          }
-        })
-      )
-
-      const claimDetails = await Promise.all(
-        patch.claimDetails.map(async (ClaimDetail: ClaimDetail) => {
-          return {
-            ...ClaimDetail,
-            claim: targetClaim,
-            domain: context.state.domain,
-            creator: context.state.user,
-            updater: context.state.user
-          }
-        })
-      )
-
-      await tx.getRepository(ClaimOrder).save(claimOrders)
-      await tx.getRepository(ClaimDetail).save(claimDetails)
-
-      return targetClaim
-    } catch (e) {
-      throw e
-    }
-  }
-}

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

@@ -1,43 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Claim } from '../../../entities'
-
-export const updateMultipleClaim = {
-  async updateMultipleClaim(_: any, { patches }, context: any) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const claimRepo = getRepository(Claim)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await claimRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const claim = await claimRepo.findOne(newRecord.id)
-
-        const result = await claimRepo.save({
-          ...claim,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/claim-detail/claim-detail.ts

@@ -1,13 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimDetail } from '../../../entities'
-
-export const claimDetailResolver = {
-  async claimDetail(_: any, { name }, context: any) {
-    const repository = getRepository(ClaimDetail)
-
-    return await getRepository(ClaimDetail).findOne({
-      where: { domain: context.state.domain, name, relations: ['domain', 'creator', 'updater']}
-    })
-  }
-}
-

package/server/graphql/resolvers/claim-detail/claim-details.ts

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

package/server/graphql/resolvers/claim-detail/create-claim-detail.ts

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

package/server/graphql/resolvers/claim-detail/delete-claim-detail.ts

@@ -1,10 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimDetail } from '../../../entities'
-
-export const deleteClaimDetail = {
-  async deleteClaimDetail(_: any, { name }, context: any) {
-    await getRepository(ClaimDetail).delete({ domain: context.state.domain, name })
-    return true
-  }
-}
-

package/server/graphql/resolvers/claim-detail/delete-claim-details.ts

@@ -1,13 +0,0 @@
-import { getRepository, In } from 'typeorm'
-import { ClaimDetail } from '../../../entities'
-
-export const deleteClaimDetails = {
-  async deleteClaimDetails(_: any, { names }, context: any) {
-    await getRepository(ClaimDetail).delete({ 
-        domain: context.state.domain,
-        name: In(names)
-    })
-    return true
-  }
-}
-

package/server/graphql/resolvers/claim-detail/index.ts

@@ -1,21 +0,0 @@
-import { claimDetailResolver } from './claim-detail'
-import { claimDetailsResolver } from './claim-details'
-
-import { updateClaimDetail } from './update-claim-detail'
-import { updateMultipleClaimDetail } from './update-multiple-claim-detail'
-import { createClaimDetail } from './create-claim-detail'
-import { deleteClaimDetail } from './delete-claim-detail'
-import { deleteClaimDetails } from './delete-claim-details'
-
-export const Query = {
-  ...claimDetailsResolver,
-  ...claimDetailResolver
-}
-
-export const Mutation = {
-  ...updateClaimDetail,
-  ...updateMultipleClaimDetail,
-  ...createClaimDetail,
-  ...deleteClaimDetail,
-  ...deleteClaimDetails
-}

package/server/graphql/resolvers/claim-detail/update-claim-detail.ts

@@ -1,17 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimDetail } from '../../../entities'
-
-export const updateClaimDetail = {
-  async updateClaimDetail(_: any, { name, patch }, context: any) {
-    const repository = getRepository(ClaimDetail)
-    const claimDetail = await repository.findOne({ 
-      where: { domain: context.state.domain, name }
-    })
-
-    return await repository.save({
-      ...claimDetail,
-      ...patch,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/claim-detail/update-multiple-claim-detail.ts

@@ -1,43 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimDetail } from '../../../entities'
-
-export const updateMultipleClaimDetail = {
-  async updateMultipleClaimDetail(_: any, { patches }, context: any) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const claimDetailRepo = getRepository(ClaimDetail)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await claimDetailRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const claimDetail = await claimDetailRepo.findOne(newRecord.id)
-
-        const result = await claimDetailRepo.save({
-          ...claimDetail,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/claim-order/claim-order.ts

@@ -1,13 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimOrder } from '../../../entities'
-
-export const claimOrderResolver = {
-  async claimOrder(_: any, { name }, context: any) {
-    const repository = getRepository(ClaimOrder)
-
-    return await getRepository(ClaimOrder).findOne({
-      where: { domain: context.state.domain, name, relations: ['domain', 'creator', 'updater']}
-    })
-  }
-}
-

package/server/graphql/resolvers/claim-order/claim-orders.ts

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

package/server/graphql/resolvers/claim-order/create-claim-order.ts

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

package/server/graphql/resolvers/claim-order/delete-claim-order.ts

@@ -1,10 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimOrder } from '../../../entities'
-
-export const deleteClaimOrder = {
-  async deleteClaimOrder(_: any, { name }, context: any) {
-    await getRepository(ClaimOrder).delete({ domain: context.state.domain, name })
-    return true
-  }
-}
-

package/server/graphql/resolvers/claim-order/delete-claim-orders.ts

@@ -1,13 +0,0 @@
-import { getRepository, In } from 'typeorm'
-import { ClaimOrder } from '../../../entities'
-
-export const deleteClaimOrders = {
-  async deleteClaimOrders(_: any, { names }, context: any) {
-    await getRepository(ClaimOrder).delete({ 
-        domain: context.state.domain,
-        name: In(names)
-    })
-    return true
-  }
-}
-

package/server/graphql/resolvers/claim-order/index.ts

@@ -1,21 +0,0 @@
-import { claimOrderResolver } from './claim-order'
-import { claimOrdersResolver } from './claim-orders'
-
-import { updateClaimOrder } from './update-claim-order'
-import { updateMultipleClaimOrder } from './update-multiple-claim-order'
-import { createClaimOrder } from './create-claim-order'
-import { deleteClaimOrder } from './delete-claim-order'
-import { deleteClaimOrders } from './delete-claim-orders'
-
-export const Query = {
-  ...claimOrdersResolver,
-  ...claimOrderResolver
-}
-
-export const Mutation = {
-  ...updateClaimOrder,
-  ...updateMultipleClaimOrder,
-  ...createClaimOrder,
-  ...deleteClaimOrder,
-  ...deleteClaimOrders
-}

package/server/graphql/resolvers/claim-order/update-claim-order.ts

@@ -1,17 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimOrder } from '../../../entities'
-
-export const updateClaimOrder = {
-  async updateClaimOrder(_: any, { name, patch }, context: any) {
-    const repository = getRepository(ClaimOrder)
-    const claimOrder = await repository.findOne({ 
-      where: { domain: context.state.domain, name }
-    })
-
-    return await repository.save({
-      ...claimOrder,
-      ...patch,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/claim-order/update-multiple-claim-order.ts

@@ -1,42 +0,0 @@
-import { getRepository } from 'typeorm'
-import { ClaimOrder } from '../../../entities'
-
-export const updateMultipleClaimOrder = {
-  async updateMultipleClaimOrder(_: any, { patches }, context: any) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const claimOrderRepo = getRepository(ClaimOrder)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-        const result = await claimOrderRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const claimOrder = await claimOrderRepo.findOne(newRecord.id)
-
-        const result = await claimOrderRepo.save({
-          ...claimOrder,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/collection-order/check-collected-order.ts

@@ -1,31 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-
-export const checkCollectedOrder = {
-  async checkCollectedOrder(_: any, { name, patch }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
-      })
-
-      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
-      if (collectionOrder.status !== ORDER_STATUS.COLLECTING) throw new Error(`Status is not receivable.`)
-
-      await getRepository(CollectionOrder).save({
-        ...collectionOrder,
-        ...patch,
-        status: ORDER_STATUS.DONE,
-        updater: user
-      })
-
-      return collectionOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/collection-order/collection-order-requests.ts

@@ -1,26 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam, Domain } from '@things-factory/shell'
-import { getRepository, In, Not } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-
-export const collectionOrderRequestsResolver = {
-  async collectionOrderRequests(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const convertedParams = convertListParams(params)
-
-    if (!convertedParams.where || !convertedParams.where.status) {
-      convertedParams.where.status = Not(In([ORDER_STATUS.PENDING, ORDER_STATUS.EDITING]))
-    }
-    convertedParams.bizplace = In(await getPermittedBizplaceIds(domain, user))
-
-    const [items, total] = await getRepository(CollectionOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/collection-order/collection-order.ts

@@ -1,30 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { CollectionOrder } from '../../../entities'
-
-export const collectionOrderResolver = {
-  async collectionOrder(_: any, { name }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const foundCO = await getRepository(CollectionOrder).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      },
-      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    })
-
-    const foundAttachments = await getRepository(Attachment).find({
-      where: {
-        domain,
-        refBy: foundCO.id
-      }
-    })
-
-    return { ...foundCO, attachments: foundAttachments }
-  }
-}

package/server/graphql/resolvers/collection-order/collection-orders.ts

@@ -1,21 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { CollectionOrder } from '../../../entities'
-
-export const collectionOrdersResolver = {
-  async collectionOrders(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const convertedParams = convertListParams(params)
-    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-
-    const [items, total] = await getRepository(CollectionOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'arrivalNotice', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/collection-order/confirm-collection-order.ts

@@ -1,29 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-
-export const confirmCollectionOrder = {
-  async confirmCollectionOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-      where: { domain, name },
-      relations: ['creator', 'updater']
-    })
-
-    let collectionOrder: CollectionOrder
-    if (!foundCollectionOrder) throw new Error(`Collection Order doesn't exists.`)
-    if (foundCollectionOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
-
-    // Collection Order Status change (PENDING => PENDING_RECEIVE)
-    collectionOrder = await tx.getRepository(CollectionOrder).save({
-      ...foundCollectionOrder,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-
-    return collectionOrder
-  }
-}

package/server/graphql/resolvers/collection-order/delete-collection-order.ts

@@ -1,22 +0,0 @@
-import { Attachment, deleteAttachment } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { CollectionOrder } from '../../../entities'
-
-export const deleteCollectionOrder = {
-  async deleteCollectionOrder(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    const foundCO = await tx.getRepository(CollectionOrder).findOne({
-      where: { domain, name }
-    })
-    if (foundCO) {
-      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain, refBy: foundCO.id }
-      })
-      if (previousAttachment) await deleteAttachment(_, { id: previousAttachment.id }, context)
-      await tx.getRepository(CollectionOrder).delete({ domain, name })
-    }
-    return true
-  }
-}

package/server/graphql/resolvers/collection-order/dispatch-collection-order.ts

@@ -1,41 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-export const dispatchCollectionOrder = {
-  async dispatchCollectionOrder(_: any, { orderInfo }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-      const foundCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name: orderInfo.name }
-      })
-
-      if (!foundCollectionOrder) throw new Error(`Collection order doesn't exists.`)
-      if (foundCollectionOrder.status !== ORDER_STATUS.READY_TO_DISPATCH) throw new Error(`Status is not receivable.`)
-
-      await tx.getRepository(CollectionOrder).save({
-        ...foundCollectionOrder,
-        name: OrderNoGenerator.collectionOrder(),
-        transportDriver: await tx.getRepository(TransportDriver).findOne({
-          domain,
-          id: foundCollectionOrder.transportDriver.id
-        }),
-        transportVehicle: await tx.getRepository(TransportVehicle).findOne({
-          domain,
-          id: foundCollectionOrder.transportVehicle.id
-        }),
-        status: ORDER_STATUS.COLLECTING,
-        updater: user
-      })
-
-      return foundCollectionOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}