@things-factory/sales-base 4.0.0-y.0 → 4.0.4

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

@@ -1,29 +0,0 @@
-import { confirmReturnOrderResolver } from './confirm-return-order'
-import { returnOrderResolver } from './return-order'
-import { returnOrdersResolver } from './return-orders'
-import { generateReturnOrder } from './generate-return-order'
-import { returnOrderDetailResolver } from './return-order-detail'
-import { returnOrderRequestsResolver } from './return-order-requests'
-
-import { deleteReturnOrderResolver } from './delete-return-order'
-import { deleteReturnOrders } from './delete-return-orders'
-import { receiveReturnOrderResolver } from './receive-return-order'
-import { rejectReturnOrderResolver } from './reject-return-order'
-import { checkReturnOrderResolver } from './check-return-order'
-
-export const Query = {
-  ...returnOrdersResolver,
-  ...returnOrderResolver,
-  ...returnOrderDetailResolver,
-  ...returnOrderRequestsResolver
-}
-
-export const Mutation = {
-  ...deleteReturnOrderResolver,
-  ...deleteReturnOrders,
-  ...confirmReturnOrderResolver,
-  ...generateReturnOrder,
-  ...receiveReturnOrderResolver,
-  ...rejectReturnOrderResolver,
-  ...checkReturnOrderResolver
-}

package/server/graphql/resolvers/return-order/receive-return-order.ts

@@ -1,80 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReturnOrder } from '../../../entities'
-
-export const receiveReturnOrderResolver = {
-  async receiveReturnOrder(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const returnOrder: ReturnOrder = await receiveReturnOrder(tx, name, context)
-
-    return returnOrder
-  }
-}
-
-export async function receiveReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderVass']
-  })
-
-  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
-  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
-  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
-
-  // 1. RO Status change (PENDING_RECEIVE => INTRANSIT)
-  const returnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save({
-    ...foundReturnOrder,
-    status: ORDER_STATUS.INTRANSIT,
-    updater: user,
-    acceptedBy: user,
-    acceptedAt: new Date()
-  })
-
-  // 1. Update status of order inventories
-  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
-    return {
-      ...orderInventory,
-      status: ORDER_INVENTORY_STATUS.INTRANSIT,
-      updater: user
-    }
-  })
-  await tx.getRepository(OrderInventory).save(foundOIs)
-
-  // 2. Update status of order vass
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.INTRANSIT,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  const users: any[] = await getDomainUsers(foundReturnOrder?.bizplace, tx)
-
-  if (users?.length) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${foundReturnOrder.name}`,
-      body: `Your Return Order has been received and processed by ${domain.name}`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return returnOrder
-}

package/server/graphql/resolvers/return-order/reject-return-order.ts

@@ -1,83 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { OrderInventory, OrderVas, ReturnOrder } from '../../../entities'
-
-export const rejectReturnOrderResolver = {
-  async rejectReturnOrder(_: any, { name, patch: { remark } }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const returnOrder: ReturnOrder = await rejectReturnOrder(tx, name, remark, context)
-
-    return returnOrder
-  }
-}
-
-export async function rejectReturnOrder(
-  tx: EntityManager,
-  name: string,
-  remark: string,
-  context: any
-): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-
-  const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderVass']
-  })
-
-  if (!foundReturnOrder) throw new Error(`Return order doesn't exists.`)
-  if (!remark) throw new Error('Remark is not exist.')
-
-  let foundOIs: OrderInventory[] = foundReturnOrder.orderInventories
-  let foundOVs: OrderVas[] = foundReturnOrder.orderVass
-
-  foundReturnOrder.remark = remark
-  foundReturnOrder.status = ORDER_STATUS.REJECTED
-  foundReturnOrder.updater = user
-  await tx.getRepository(ReturnOrder).save(foundReturnOrder)
-
-  // 1. Update status of order inventories
-  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
-    return {
-      ...orderInventory,
-      status: ORDER_INVENTORY_STATUS.REJECTED,
-      updater: user
-    }
-  })
-  await tx.getRepository(OrderInventory).save(foundOIs)
-
-  // 2. Update status of order vass
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.REJECTED,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  const users: any[] = await getDomainUsers(foundReturnOrder?.bizplace, tx)
-
-  if (users?.length) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${foundReturnOrder.name}`,
-      body: `Your Return Order has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return foundReturnOrder
-}

package/server/graphql/resolvers/return-order/return-order-detail.ts

@@ -1,68 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { getRepository } from 'typeorm'
-import { ORDER_INVENTORY_TYPE } from '../../../constants'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { OrderInventory, ReturnOrder } from '../../../entities'
-
-export const returnOrderDetailResolver = {
-  async returnOrderDetail(_: any, { name }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.product',
-        'orderInventories.inventory.product',
-        'orderInventories.inventory.location',
-        'orderVass',
-        'orderVass.vas',
-        'orderVass.targetProduct',
-        'orderVass.inventory',
-        'creator',
-        'updater'
-      ]
-    })
-
-    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-      where: {
-        domain,
-        refBy: returnOrder.id,
-        category: ATTACHMENT_TYPE.RETURN_ORDER
-      }
-    })
-
-    return {
-      ...returnOrder,
-      attachment: foundAttachments,
-      inventoryInfos: returnOrder.orderInventories
-        .filter(orderInv => orderInv.type === ORDER_INVENTORY_TYPE.RETURN_ORDER)
-        .map((orderInv: OrderInventory) => {
-          const inventory: Inventory = orderInv.inventory
-          return {
-            id: inventory.id,
-            name: inventory.name,
-            batchId: inventory.batchId,
-            palletId: inventory.palletId,
-            product: inventory.product,
-            productName: `${inventory.product.name} (${inventory.product.description})`,
-            packingType: inventory.packingType,
-            packingSize: inventory.packingSize,
-            returnQty: orderInv.returnQty,
-            returnUomValue: orderInv.returnUomValue,
-            status: orderInv.status,
-            remark: orderInv.remark
-          }
-        })
-    }
-  }
-}

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

@@ -1,71 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { ReturnOrder } from '../../../entities'
-
-export const returnOrderRequestsResolver = {
-  async returnOrderRequests(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
-
-      const statusFilter = params.filters.some(e => e.name === 'status')
-      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-
-      if (!statusFilter) {
-        params.filters.push({
-          name: 'status',
-          operator: 'notin',
-          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
-          relation: false
-        })
-      }
-
-      if (!bizplaceFilter) {
-        params.filters.push({
-          name: 'bizplaceId',
-          operator: 'in',
-          value: await getPermittedBizplaceIds(domain, user),
-          relation: false
-        })
-      }
-
-      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
-      buildQuery(qb, params, context)
-      qb.addSelect(subQuery => {
-        return subQuery
-          .select('COALESCE("ccd".rank, 99999)', 'rank')
-          .from('common_code_details', 'ccd')
-          .innerJoin('ccd.commonCode', 'cc')
-          .where('"ccd"."name" = "ro"."status"')
-          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
-          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
-      }, 'rank')
-      qb.leftJoinAndSelect('ro.domain', 'domain')
-      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('ro.creator', 'creator')
-      qb.leftJoinAndSelect('ro.updater', 'updater')
-      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
-
-      const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-      )
-
-      qb.orderBy(sort)
-
-      const [items, total] = await qb.getManyAndCount()
-
-      return { items, total }
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

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

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

@@ -1,56 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { ReturnOrder } from '../../../entities'
-
-export const returnOrdersResolver = {
-  async returnOrders(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
-
-      params.filters.push({
-        name: 'bizplaceId',
-        operator: 'in',
-        value: await getPermittedBizplaceIds(domain, user),
-        relation: false
-      })
-
-      const qb: SelectQueryBuilder<ReturnOrder> = getRepository(ReturnOrder).createQueryBuilder('ro')
-      buildQuery(qb, params, context)
-      qb.addSelect(subQuery => {
-        return subQuery
-          .select('COALESCE("ccd".rank, 99999)', 'rank')
-          .from('common_code_details', 'ccd')
-          .innerJoin('ccd.commonCode', 'cc')
-          .where('"ccd"."name" = "ro"."status"')
-          .andWhere('"ccd"."domain_id" = "ro"."domain_id"')
-          .andWhere('"cc"."name" = \'RETURN_LIST_STATUS\'')
-      }, 'rank')
-      qb.leftJoinAndSelect('ro.domain', 'domain')
-      qb.leftJoinAndSelect('ro.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('ro.creator', 'creator')
-      qb.leftJoinAndSelect('ro.updater', 'updater')
-      qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
-
-      const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-      )
-
-      qb.orderBy(sort)
-
-      const [items, total] = await qb.getManyAndCount()
-
-      return { items, total }
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,17 +0,0 @@
-import { EntityManager } from 'typeorm'
-import uuid from 'uuid/v4'
-import { ShippingOrder } from '../../../entities'
-
-export const createShippingOrder = {
-  async createShippingOrder(_, { shippingOrder: attrs }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(ShippingOrder)
-    const newShippingOrder = {
-      id: uuid(),
-      ...attrs
-    }
-
-    return await repository.save(newShippingOrder)
-  }
-}

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

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

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

@@ -1,16 +0,0 @@
-import { createShippingOrder } from './create-shipping-order'
-import { deleteShippingOrder } from './delete-shipping-order'
-import { shippingOrderResolver } from './shipping-order'
-import { shippingOrdersResolver } from './shipping-orders'
-import { updateShippingOrder } from './update-shipping-order'
-
-export const Query = {
-  ...shippingOrdersResolver,
-  ...shippingOrderResolver
-}
-
-export const Mutation = {
-  ...updateShippingOrder,
-  ...createShippingOrder,
-  ...deleteShippingOrder
-}

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

@@ -1,20 +0,0 @@
-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 { ShippingOrder } from '../../../entities'
-
-export const shippingOrderResolver = {
-  async shippingOrder(_: any, { name }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    return await getRepository(ShippingOrder).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      },
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/shipping-order/shipping-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 { ShippingOrder } from '../../../entities'
-
-export const shippingOrdersResolver = {
-  async shippingOrders(_: 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(ShippingOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

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

@@ -1,25 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { ShippingOrder } from '../../../entities'
-
-export const updateShippingOrder = {
-  async updateShippingOrder(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const shippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      }
-    })
-
-    return await tx.getRepository(ShippingOrder).save({
-      ...shippingOrder,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/transfer-order/add-tranfer-order-inventories.ts

@@ -1,63 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ORDER_TYPES } from '../../../constants'
-import { OrderInventory, TransferOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-export const addTransferOrderInventoriesResolver = {
-  async addTransferOrderInventories(_: any, { toNo, orderInventories }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { name: toNo },
-      relations: ['bizplace', 'orderInventory']
-    })
-
-    await addTransferOrderInventories(domain, transferOrder, orderInventories, user, tx)
-  }
-}
-
-export async function addTransferOrderInventories(
-  domain: Domain,
-  transferOrder: TransferOrder,
-  orderInventories: OrderInventory[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const orderInventoryRepo: Repository<OrderInventory> =
-    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
-
-  if (!transferOrder?.bizplace || !transferOrder?.orderInventories?.length) {
-    transferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { ...transferOrder },
-      relations: ['bizplace', 'orderInventories']
-    })
-  }
-
-  orderInventories = await Promise.all(
-    orderInventories.map(async (oi: OrderInventory) => {
-      const foundProduct: Product = await productRepo.findOne({ domain, sku: oi.product.sku, name: oi.product.name })
-      return {
-        ...oi,
-        domain,
-        bizplace: transferOrder.bizplace,
-        name: OrderNoGenerator.orderInventory(),
-        product: foundProduct,
-        productName: foundProduct.name,
-        releaseWeight: foundProduct.weight * oi.releaseQty,
-        packingType: foundProduct.packingType,
-        type: ORDER_TYPES.TRANSFER_ORDER,
-        transferOrder,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  //add lock qty
-
-  await orderInventoryRepo.save(orderInventories)
-}

package/server/graphql/resolvers/transfer-order/cancel-transfer-order.ts

@@ -1,42 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { OrderInventory, TransferOrder } from '../../../entities'
-
-export const cancelTransferOrderResolver = {
-  async cancelTransferOrder(_: any, { patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-
-    const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { domain, bizplace, name: patch.name },
-      relations: ['bizplace', 'orderInventories']
-    })
-
-    if (!transferOrder) throw new Error(`Transfer order does not exist.`)
-    if (!patch.status) throw new Error('Status was not specified.')
-    // if (patch.status && (patch.status !== ORDER_STATUS.PENDING_CANCEL || patch.status !== ORDER_STATUS.CANCELLED))
-    // throw new Error(`Status provided was invalid.`)
-
-    let foundOIs: OrderInventory[] = transferOrder.orderInventories
-
-    // 1. Update status of order inventories based on status (to PENDING_CANCEL or CANCELLED)
-    if (foundOIs && foundOIs.length) {
-      foundOIs = foundOIs.map((oi: OrderInventory) => {
-        ;(oi.status = patch.status), (oi.updater = user)
-        return oi
-      })
-    }
-    await tx.getRepository(OrderInventory).save(foundOIs)
-
-    // 2. Update transfer order status
-    return await tx.getRepository(TransferOrder).save({
-      ...transferOrder,
-      remark: patch.remark, //think another way if warehouse confirm cancellation > no need to overwrite remark
-      status: patch.status,
-      updater: user
-    })
-  }
-}