573 lines
19 KiB
JavaScript
573 lines
19 KiB
JavaScript
// @ts-check
|
|
|
|
import { getOrderById } from '../../../repositories/order-repo.js'
|
|
import { updateTask } from '../../../repositories/task-repo.js'
|
|
import { createTaskEvent } from '../../../repositories/task-event-repo.js'
|
|
import {
|
|
buyCloudtentaclesSku,
|
|
getCloudtentaclesAsset,
|
|
listCloudtentaclesSku,
|
|
useCloudtentaclesSku,
|
|
} from '../../platforms/cloudtentacles/catalog-service.js'
|
|
import { getCloudtentaclesKnapsack } from '../../platforms/cloudtentacles/knapsack-service.js'
|
|
import {
|
|
backCloudtentaclesVirtualNumber,
|
|
getCloudtentaclesBindInfo,
|
|
} from '../../platforms/cloudtentacles/virtual-number-service.js'
|
|
import { consumeKuaishouEticket } from '../../platforms/kuaishou-eticket/consume-service.js'
|
|
import {
|
|
getKuaishouEticketSourceConfig,
|
|
resolveKuaishouEticketShopConfig,
|
|
} from '../../platforms/kuaishou-eticket/source-config-service.js'
|
|
import { createHttpError } from '../../../utils/http.js'
|
|
import { nowIso } from '../../../utils/time.js'
|
|
import {
|
|
createAdminViewerContext,
|
|
parseTaskContext,
|
|
} from '../admin-read-shared-helpers.js'
|
|
import {
|
|
getRequiredTask,
|
|
mapTaskActionPayload,
|
|
} from '../admin-task-read-helpers.js'
|
|
import {
|
|
ensureTaskClaimLink,
|
|
getTaskClaimExpiresAt,
|
|
maskCode,
|
|
maskPhone,
|
|
} from './shared.js'
|
|
import {
|
|
isKuaishouCloudTask,
|
|
normalizeKuaishouCloudFlow,
|
|
normalizeKuaishouCloudRoleInfo,
|
|
prepareKuaishouCloudBindResourceWithFallback,
|
|
resolveKuaishouCloudBindUrlExpiresAt,
|
|
resolveKuaishouCloudBindingResources,
|
|
resolveKuaishouCloudVnKeyCandidates,
|
|
resolvePersistedCloudtentaclesContext,
|
|
} from './kuaishou-cloud-helpers.js'
|
|
|
|
/** @typedef {import('../../../types/admin-read-inputs.js').AdminEntityIdInput} AdminEntityIdInput */
|
|
/** @typedef {import('../../../types/admin-read-inputs.js').AdminViewerSessionInput} AdminViewerSessionInput */
|
|
/** @typedef {import('../../../types/admin-write-inputs.js').AdminTaskKuaishouCloudDispatchInput} AdminTaskKuaishouCloudDispatchInput */
|
|
/** @typedef {import('../../../types/admin-write-models.js').AdminTaskActionResponse} AdminTaskActionResponse */
|
|
|
|
/** @returns {Promise<AdminTaskActionResponse>} */
|
|
/** @param {AdminEntityIdInput} taskId */
|
|
/** @param {AdminViewerSessionInput | null} [session] */
|
|
export async function prepareAdminTaskKuaishouCloudFulfillment(taskId, session = null) {
|
|
const task = await getRequiredTask(taskId)
|
|
const now = nowIso()
|
|
const viewerContext = createAdminViewerContext(session)
|
|
|
|
if (!viewerContext.canManageTaskLifecycle) {
|
|
throw createHttpError('当前账号没有权限准备绑定资源', {
|
|
statusCode: 403,
|
|
errorCode: 'admin_task_prepare_kuaishou_cloud_forbidden',
|
|
})
|
|
}
|
|
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_not_kuaishou_cloud',
|
|
})
|
|
}
|
|
|
|
const taskContext = parseTaskContext(task)
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
|
const cloudContext = resolvePersistedCloudtentaclesContext()
|
|
const [knapsack, skuList] = await Promise.all([
|
|
getCloudtentaclesKnapsack(cloudContext),
|
|
listCloudtentaclesSku(cloudContext),
|
|
])
|
|
const resolvedBinding = resolveKuaishouCloudBindingResources(flow, {
|
|
skuItems: Array.isArray(skuList.items) ? skuList.items : [],
|
|
knapsackItems: Array.isArray(knapsack.items) ? knapsack.items : [],
|
|
})
|
|
const vnKeyCandidates = resolveKuaishouCloudVnKeyCandidates({
|
|
flow,
|
|
binding: resolvedBinding,
|
|
})
|
|
|
|
if (!resolvedBinding.skuId || vnKeyCandidates.length === 0) {
|
|
throw createHttpError('当前任务缺少可用 cloud 资源，且无法根据商品名自动解析 SKU / VN Key', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_missing_binding_config',
|
|
})
|
|
}
|
|
|
|
const flowWithResolvedBinding = {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
skuId: resolvedBinding.skuId,
|
|
skuName: resolvedBinding.skuName,
|
|
vnKey: resolvedBinding.vnKey,
|
|
},
|
|
}
|
|
const knapsackItem = resolvedBinding.knapsackItem
|
|
let usedKnapsack = Number(knapsackItem?.count || 0) > 0
|
|
let purchaseTriggered = false
|
|
let assetBefore = 0
|
|
let assetAfter = 0
|
|
const claimLinkState = await ensureTaskClaimLink(task)
|
|
|
|
if (!usedKnapsack) {
|
|
if (!flowWithResolvedBinding.purchase.autoBuyEnabled) {
|
|
throw createHttpError('背包中没有现成库存，且当前配置未开启自动购买', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_auto_buy_disabled',
|
|
})
|
|
}
|
|
|
|
const asset = await getCloudtentaclesAsset(cloudContext)
|
|
const targetSku = resolvedBinding.skuItem
|
|
|
|
if (!targetSku) {
|
|
throw createHttpError(`cloudtentacles 未找到 SKU ${flowWithResolvedBinding.binding.skuId}`, {
|
|
statusCode: 404,
|
|
errorCode: 'admin_task_kuaishou_cloud_sku_not_found',
|
|
})
|
|
}
|
|
|
|
assetBefore = Number(asset.asset || 0) || 0
|
|
const targetPrice = Number(targetSku.price || 0) || 0
|
|
const requiredAsset = targetPrice + flowWithResolvedBinding.purchase.minAssetReserve
|
|
if (assetBefore < requiredAsset) {
|
|
throw createHttpError(`余额不足，当前 ${assetBefore}，至少需要 ${requiredAsset}`, {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_asset_not_enough',
|
|
})
|
|
}
|
|
|
|
await buyCloudtentaclesSku({
|
|
...cloudContext,
|
|
id: flowWithResolvedBinding.binding.skuId,
|
|
count: 1,
|
|
})
|
|
purchaseTriggered = true
|
|
|
|
const assetResult = await getCloudtentaclesAsset(cloudContext)
|
|
assetAfter = Number(assetResult.asset || 0) || 0
|
|
}
|
|
|
|
const preparedBinding = await prepareKuaishouCloudBindResourceWithFallback({
|
|
cloudContext,
|
|
vnKeyCandidates,
|
|
})
|
|
const vnId = preparedBinding.vnId
|
|
const vnPhone = preparedBinding.vnPhone
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flowWithResolvedBinding,
|
|
binding: {
|
|
...flowWithResolvedBinding.binding,
|
|
vnKey: preparedBinding.vnKey,
|
|
prepareStatus: 'ready',
|
|
vnId,
|
|
vnPhone,
|
|
bindUrl: preparedBinding.bindUrl,
|
|
bindPreparedAt: now,
|
|
bindExpiresAt: resolveKuaishouCloudBindUrlExpiresAt(now),
|
|
bindProbeAt: null,
|
|
bindProbeStatus: 'pending',
|
|
bindProbeMessage: '',
|
|
roleName: '',
|
|
roleId: '',
|
|
},
|
|
role: {
|
|
status: 'pending',
|
|
name: '',
|
|
rid: '',
|
|
refreshedAt: null,
|
|
errorMessage: '',
|
|
rawInfo: null,
|
|
},
|
|
purchase: {
|
|
...flowWithResolvedBinding.purchase,
|
|
usedKnapsack,
|
|
purchaseTriggered,
|
|
assetBefore,
|
|
assetAfter,
|
|
purchaseAt: purchaseTriggered ? now : flowWithResolvedBinding.purchase.purchaseAt,
|
|
},
|
|
},
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: 'waiting_binding',
|
|
inventory_status: 'not_required',
|
|
user_action_status: 'pending',
|
|
claim_token: claimLinkState.token || task.claim_token || '',
|
|
claim_expires_at: claimLinkState.expiredAt || getTaskClaimExpiresAt(task),
|
|
last_error: '',
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
})
|
|
|
|
await createTaskEvent(task.id, 'kuaishou_cloud_binding_prepared', {
|
|
skuId: flowWithResolvedBinding.binding.skuId,
|
|
skuName: flowWithResolvedBinding.binding.skuName,
|
|
vnKey: preparedBinding.vnKey,
|
|
vnId,
|
|
vnPhoneMasked: maskPhone(vnPhone),
|
|
bindUrl: preparedBinding.bindUrl,
|
|
purchaseTriggered,
|
|
usedKnapsack,
|
|
resolvedByName: resolvedBinding.resolvedByName,
|
|
}, now)
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
claimUrl: claimLinkState.claimUrl,
|
|
token: claimLinkState.token,
|
|
}
|
|
}
|
|
|
|
/** @returns {Promise<AdminTaskActionResponse>} */
|
|
/** @param {AdminEntityIdInput} taskId */
|
|
/** @param {AdminTaskKuaishouCloudDispatchInput} [payload] */
|
|
/** @param {AdminViewerSessionInput | null} [session] */
|
|
export async function dispatchAdminTaskKuaishouCloudFulfillment(taskId, payload = {}, session = null) {
|
|
const task = await getRequiredTask(taskId)
|
|
const now = nowIso()
|
|
const viewerContext = createAdminViewerContext(session)
|
|
|
|
if (!viewerContext.canManageTaskLifecycle) {
|
|
throw createHttpError('当前账号没有权限执行发货', {
|
|
statusCode: 403,
|
|
errorCode: 'admin_task_dispatch_kuaishou_cloud_forbidden',
|
|
})
|
|
}
|
|
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_not_kuaishou_cloud',
|
|
})
|
|
}
|
|
|
|
const taskContext = parseTaskContext(task)
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
|
const cloudContext = resolvePersistedCloudtentaclesContext()
|
|
|
|
if (!flow.binding.skuId || !flow.binding.vnId || !flow.binding.vnPhone) {
|
|
throw createHttpError('当前任务还没有准备好绑定资源，请先准备绑定资源', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_not_prepared',
|
|
})
|
|
}
|
|
|
|
const ticketCode = String(payload.ticketCode || '').trim()
|
|
const persistedTicketCode = String(flow.ticket.code || '').trim()
|
|
|
|
if (!persistedTicketCode && !ticketCode) {
|
|
throw createHttpError('客户还没有在领取页提交核销码，暂时不能直接发货', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_missing_ticket_code',
|
|
})
|
|
}
|
|
|
|
const dispatchResult = await useCloudtentaclesSku({
|
|
...cloudContext,
|
|
id: flow.binding.skuId,
|
|
virtualNumberId: flow.binding.vnId,
|
|
phone: flow.binding.vnPhone,
|
|
})
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
ticket: {
|
|
...flow.ticket,
|
|
code: ticketCode || persistedTicketCode,
|
|
capturedAt: ticketCode ? now : flow.ticket.capturedAt,
|
|
capturedBy: ticketCode && session
|
|
? {
|
|
userId: Number(session.userId || 0) || 0,
|
|
username: String(session.username || '').trim(),
|
|
role: String(session.role || '').trim(),
|
|
}
|
|
: flow.ticket.capturedBy,
|
|
},
|
|
dispatch: {
|
|
...flow.dispatch,
|
|
status: 'success',
|
|
dispatchAt: now,
|
|
dispatchBy: session
|
|
? {
|
|
userId: Number(session.userId || 0) || 0,
|
|
username: String(session.username || '').trim(),
|
|
role: String(session.role || '').trim(),
|
|
}
|
|
: null,
|
|
sendType: Number(dispatchResult.sendType || 0) || 0,
|
|
note: String(dispatchResult.note || dispatchResult.responseMessage || '').trim(),
|
|
},
|
|
},
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: 'dispatched_pending_return',
|
|
delivery_status: 'delivered',
|
|
result_code: 'kuaishou_cloud_dispatched',
|
|
result_message: String(dispatchResult.responseMessage || dispatchResult.note || 'cloudtentacles 发货成功').trim(),
|
|
last_error: '',
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
})
|
|
|
|
await createTaskEvent(task.id, 'kuaishou_cloud_dispatched', {
|
|
ticketCodeMasked: maskCode(ticketCode || persistedTicketCode),
|
|
skuId: flow.binding.skuId,
|
|
vnId: flow.binding.vnId,
|
|
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
|
sendType: dispatchResult.sendType,
|
|
note: dispatchResult.note,
|
|
}, now)
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|
|
|
|
/** @returns {Promise<AdminTaskActionResponse>} */
|
|
/** @param {AdminEntityIdInput} taskId */
|
|
/** @param {AdminViewerSessionInput | null} [session] */
|
|
export async function refreshAdminTaskKuaishouCloudRoleInfo(taskId, session = null) {
|
|
const task = await getRequiredTask(taskId)
|
|
const now = nowIso()
|
|
const viewerContext = createAdminViewerContext(session)
|
|
|
|
if (!viewerContext.canOperateAssistedTask) {
|
|
throw createHttpError('当前账号没有权限刷新角色信息', {
|
|
statusCode: 403,
|
|
errorCode: 'admin_task_refresh_kuaishou_cloud_role_forbidden',
|
|
})
|
|
}
|
|
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_not_kuaishou_cloud',
|
|
})
|
|
}
|
|
|
|
const taskContext = parseTaskContext(task)
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
|
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
|
throw createHttpError('当前任务还没有可查询的绑定角色信息，请先准备绑定资源', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_missing_bind_info_context',
|
|
})
|
|
}
|
|
|
|
const cloudContext = resolvePersistedCloudtentaclesContext()
|
|
const bindInfoResult = await getCloudtentaclesBindInfo({
|
|
...cloudContext,
|
|
key: flow.binding.vnKey,
|
|
id: flow.binding.vnId,
|
|
})
|
|
|
|
const bindInfo = normalizeKuaishouCloudRoleInfo(bindInfoResult.bindInfo)
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
binding: {
|
|
...flow.binding,
|
|
roleName: bindInfo.name,
|
|
roleId: bindInfo.rid,
|
|
},
|
|
role: {
|
|
status: bindInfo.name || bindInfo.rid ? 'ready' : 'pending',
|
|
name: bindInfo.name,
|
|
rid: bindInfo.rid,
|
|
refreshedAt: now,
|
|
errorMessage: bindInfo.name || bindInfo.rid ? '' : '当前还没有查询到角色信息，请让客户完成绑定后再刷新',
|
|
rawInfo: bindInfo.rawInfo,
|
|
},
|
|
},
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
role_id: bindInfo.rid || '',
|
|
role_name: bindInfo.name || '',
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
})
|
|
|
|
await createTaskEvent(task.id, 'kuaishou_cloud_role_info_refreshed', {
|
|
roleName: bindInfo.name,
|
|
roleId: bindInfo.rid,
|
|
vnId: flow.binding.vnId,
|
|
refreshedBy: session
|
|
? {
|
|
userId: Number(session.userId || 0) || 0,
|
|
username: String(session.username || '').trim(),
|
|
role: String(session.role || '').trim(),
|
|
}
|
|
: null,
|
|
}, now)
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|
|
|
|
/** @returns {Promise<AdminTaskActionResponse>} */
|
|
/** @param {AdminEntityIdInput} taskId */
|
|
/** @param {AdminViewerSessionInput | null} [session] */
|
|
export async function returnNumberAdminTaskKuaishouCloudFulfillment(taskId, session = null) {
|
|
const task = await getRequiredTask(taskId)
|
|
const now = nowIso()
|
|
const viewerContext = createAdminViewerContext(session)
|
|
|
|
if (!viewerContext.canManageTaskLifecycle) {
|
|
throw createHttpError('当前账号没有权限退还号码', {
|
|
statusCode: 403,
|
|
errorCode: 'admin_task_return_kuaishou_cloud_forbidden',
|
|
})
|
|
}
|
|
|
|
if (!isKuaishouCloudTask(task)) {
|
|
throw createHttpError('当前任务不是快手 cloud 履约任务', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_not_kuaishou_cloud',
|
|
})
|
|
}
|
|
|
|
const taskContext = parseTaskContext(task)
|
|
const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment)
|
|
const cloudContext = resolvePersistedCloudtentaclesContext()
|
|
|
|
if (!flow.binding.vnId || !flow.binding.vnKey) {
|
|
throw createHttpError('当前任务缺少可退还的虚拟号信息', {
|
|
statusCode: 409,
|
|
errorCode: 'admin_task_kuaishou_cloud_missing_return_context',
|
|
})
|
|
}
|
|
|
|
await backCloudtentaclesVirtualNumber({
|
|
...cloudContext,
|
|
key: flow.binding.vnKey,
|
|
id: flow.binding.vnId,
|
|
})
|
|
|
|
const order = await getOrderById(task.order_id)
|
|
const ticketCode = String(flow.ticket.code || '').trim()
|
|
const shopId = String(order?.shop_id || '').trim()
|
|
const eticketSource = getKuaishouEticketSourceConfig()
|
|
const shopConfig = resolveKuaishouEticketShopConfig({
|
|
shopId,
|
|
shopName: String(order?.shop_name || '').trim(),
|
|
})
|
|
let consumeStatus = 'pending'
|
|
let consumeErrorMessage = ''
|
|
let consumedAt = null
|
|
let nextTaskStatus = 'completed'
|
|
let nextResultCode = 'kuaishou_cloud_completed'
|
|
let nextResultMessage = 'cloudtentacles 发货、退号并完成快手核销'
|
|
|
|
if (!order) {
|
|
consumeStatus = 'failed'
|
|
consumeErrorMessage = '任务关联订单不存在，无法执行快手核销'
|
|
} else if (!ticketCode) {
|
|
consumeStatus = 'failed'
|
|
consumeErrorMessage = '客户未提交有效核销码，无法执行快手核销'
|
|
} else if (!shopConfig || shopConfig.enabled === false || !String(shopConfig.cookie || '').trim()) {
|
|
consumeStatus = 'failed'
|
|
consumeErrorMessage = '订单对应快手小店缺少可用 Cookie，无法执行快手核销'
|
|
} else {
|
|
try {
|
|
const consumeResult = await consumeKuaishouEticket({
|
|
baseUrl: eticketSource.baseUrl,
|
|
cookie: shopConfig.cookie,
|
|
eTicketId: ticketCode,
|
|
oid: String(flow.ticket.oid || '').trim(),
|
|
formToken: String(flow.ticket.formToken || '').trim(),
|
|
})
|
|
|
|
if (consumeResult.consumed) {
|
|
consumeStatus = 'success'
|
|
consumedAt = now
|
|
} else {
|
|
consumeStatus = 'failed'
|
|
consumeErrorMessage = String(consumeResult.errorMessage || '快手核销失败').trim()
|
|
}
|
|
} catch (error) {
|
|
consumeStatus = 'failed'
|
|
consumeErrorMessage = error instanceof Error ? error.message : '快手核销失败'
|
|
}
|
|
}
|
|
|
|
if (consumeStatus !== 'success') {
|
|
nextTaskStatus = 'manual_review'
|
|
nextResultCode = 'kuaishou_cloud_consume_failed'
|
|
nextResultMessage = consumeErrorMessage || '号码已退还，但快手核销未完成，请人工处理'
|
|
}
|
|
|
|
const nextContext = {
|
|
...taskContext,
|
|
kuaishouCloudFulfillment: {
|
|
...flow,
|
|
returnNumber: {
|
|
...flow.returnNumber,
|
|
status: 'success',
|
|
returnedAt: now,
|
|
returnedBy: session
|
|
? {
|
|
userId: Number(session.userId || 0) || 0,
|
|
username: String(session.username || '').trim(),
|
|
role: String(session.role || '').trim(),
|
|
}
|
|
: null,
|
|
},
|
|
consume: {
|
|
...flow.consume,
|
|
status: consumeStatus,
|
|
shopId: shopId || flow.consume.shopId,
|
|
shopName: String(flow.consume.shopName || order?.shop_name || '').trim(),
|
|
autoConsumeEnabled: flow.consume.autoConsumeEnabled === true,
|
|
consumedAt,
|
|
errorMessage: consumeErrorMessage,
|
|
},
|
|
},
|
|
}
|
|
|
|
const updatedTask = await updateTask(task.id, {
|
|
task_status: nextTaskStatus,
|
|
delivery_status: 'delivered',
|
|
result_code: nextResultCode,
|
|
result_message: nextResultMessage,
|
|
redeemed_at: consumeStatus === 'success' ? now : task.redeemed_at,
|
|
last_error: consumeErrorMessage,
|
|
context_json: JSON.stringify(nextContext),
|
|
updated_at: now,
|
|
})
|
|
|
|
await createTaskEvent(task.id, 'kuaishou_cloud_number_returned', {
|
|
vnId: flow.binding.vnId,
|
|
vnPhoneMasked: maskPhone(flow.binding.vnPhone),
|
|
}, now)
|
|
|
|
await createTaskEvent(
|
|
task.id,
|
|
consumeStatus === 'success' ? 'kuaishou_cloud_consumed' : 'kuaishou_cloud_consume_failed',
|
|
{
|
|
ticketCodeMasked: maskCode(ticketCode),
|
|
shopId,
|
|
consumeStatus,
|
|
errorMessage: consumeErrorMessage,
|
|
},
|
|
now,
|
|
)
|
|
|
|
return {
|
|
task: mapTaskActionPayload(updatedTask),
|
|
}
|
|
}
|