2349 lines
89 KiB
TypeScript
2349 lines
89 KiB
TypeScript
import { flushPromises, mount } from '@vue/test-utils'
|
|
import type { DOMWrapper } from '@vue/test-utils'
|
|
import { createPinia, setActivePinia } from 'pinia'
|
|
import PrimeVue from 'primevue/config'
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { createI18n } from 'vue-i18n'
|
|
import { createMemoryHistory, createRouter } from 'vue-router'
|
|
|
|
import taskCardSectionSource from '@/components/reservation/ReservationV4TaskCardSection.vue?raw'
|
|
import zhCN from '@/i18n/locales/zh-CN'
|
|
import { useAuthStore } from '@/stores/authStore'
|
|
import type {
|
|
ReservationV4CatalogLookupResult,
|
|
ReservationV4OrderTaskDetailResult,
|
|
ReservationV4SourceNotificationDetailResult,
|
|
ReservationV4TaskCardResult,
|
|
SourceMessageConversationResult,
|
|
SourceMessageOriginalMedia,
|
|
} from '@/types/reservation'
|
|
import ReservationV4OrderTaskDetailView from '@/views/reservation/ReservationV4OrderTaskDetailView.vue'
|
|
import ReservationV4SourceNotificationDetailView from '@/views/reservation/ReservationV4SourceNotificationDetailView.vue'
|
|
import { ApiError } from '@/services/httpClient'
|
|
|
|
vi.mock('@/services/reservationService', async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import('@/services/reservationService')>()
|
|
return {
|
|
...actual,
|
|
ackReservationV4SourceNotification: vi.fn(),
|
|
confirmReservationV4OrderTaskCard: vi.fn(),
|
|
fetchReservationV4AccountLookups: vi.fn(),
|
|
fetchReservationV4OrderTaskDetail: vi.fn(),
|
|
fetchReservationV4RateCodeLookups: vi.fn(),
|
|
fetchReservationV4RoomTypeLookups: vi.fn(),
|
|
fetchReservationV4SourceNotificationDetail: vi.fn(),
|
|
fetchSourceMessageConversation: vi.fn(),
|
|
resolveReservationV4OrderTaskCardReview: vi.fn(),
|
|
}
|
|
})
|
|
|
|
const service = await import('@/services/reservationService')
|
|
|
|
function findFieldByLabel(wrapper: DOMWrapper<Element>, label: string): DOMWrapper<Element> | undefined {
|
|
return wrapper.findAll('.v4-field').find((field) => field.find('.v4-field__label').text().includes(label))
|
|
}
|
|
|
|
describe('reservation V4 pages', () => {
|
|
beforeEach(() => {
|
|
sessionStorage.clear()
|
|
Object.defineProperty(window, 'matchMedia', {
|
|
configurable: true,
|
|
writable: true,
|
|
value: vi.fn().mockImplementation((query: string) => ({
|
|
matches: false,
|
|
media: query,
|
|
onchange: null,
|
|
addListener: vi.fn(),
|
|
removeListener: vi.fn(),
|
|
addEventListener: vi.fn(),
|
|
removeEventListener: vi.fn(),
|
|
dispatchEvent: vi.fn(),
|
|
})),
|
|
})
|
|
vi.mocked(service.ackReservationV4SourceNotification).mockReset()
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockReset()
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockReset()
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockReset()
|
|
vi.mocked(service.fetchReservationV4RateCodeLookups).mockReset()
|
|
vi.mocked(service.fetchReservationV4RoomTypeLookups).mockReset()
|
|
vi.mocked(service.fetchReservationV4SourceNotificationDetail).mockReset()
|
|
vi.mocked(service.fetchSourceMessageConversation).mockReset()
|
|
vi.mocked(service.resolveReservationV4OrderTaskCardReview).mockReset()
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult())
|
|
mockCatalogLookups()
|
|
})
|
|
|
|
it('renders reservation handling cards, hides default diagnostics and confirms only selected codes', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue({
|
|
...detail,
|
|
basic_information_card: {
|
|
...detail.basic_information_card!,
|
|
card_status: 'CONFIRMED',
|
|
},
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('订单事项办理')
|
|
expect(wrapper.text()).toContain('Booking Request')
|
|
expect(wrapper.text()).toContain('预订基础信息')
|
|
expect(wrapper.text()).toContain('预订事项')
|
|
expect(wrapper.text()).toContain('房型与日期')
|
|
expect(wrapper.text()).not.toContain('V4 订单任务详情')
|
|
expect(wrapper.text()).not.toContain('Backend contract issue')
|
|
expect(wrapper.text()).not.toContain('card-basic')
|
|
expect(wrapper.text()).not.toContain('card-room')
|
|
expect(wrapper.text()).not.toContain('#9001')
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.orderTaskId)
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.displayPayload)
|
|
expect(service.fetchReservationV4AccountLookups).toHaveBeenCalledWith({
|
|
hotel_id: 'HOTEL-TEST',
|
|
page_num: 1,
|
|
page_size: 100,
|
|
})
|
|
expect(service.fetchReservationV4RoomTypeLookups).toHaveBeenCalledWith({
|
|
hotel_id: 'HOTEL-TEST',
|
|
page_num: 1,
|
|
page_size: 100,
|
|
})
|
|
|
|
await wrapper.find('select').setValue('ACC-LIVE')
|
|
await flushPromises()
|
|
const basicCard = wrapper.findAll('.task-card-section')[0]!
|
|
expect(basicCard.find('.v4-field__label em').exists()).toBe(false)
|
|
expect(basicCard.text()).not.toContain('Market 由 Account Code 派生')
|
|
expect(basicCard.text()).not.toContain('Source 由 Account Code 派生')
|
|
expect(basicCard.text()).not.toContain('选择后会带出市场')
|
|
const marketField = findFieldByLabel(basicCard, '市场代码')
|
|
const sourceField = findFieldByLabel(basicCard, '来源代码')
|
|
expect(marketField?.find('input[name="/basic_information/market_code"]').exists()).toBe(true)
|
|
expect(sourceField?.find('input[name="/basic_information/source_code"]').exists()).toBe(true)
|
|
expect((marketField?.find('input[name="/basic_information/market_code"]').element as HTMLInputElement).value)
|
|
.toBe('LEISURE')
|
|
expect((sourceField?.find('input[name="/basic_information/source_code"]').element as HTMLInputElement).value)
|
|
.toBe('TRAVEL_AGENT')
|
|
await marketField?.find('input[name="/basic_information/market_code"]').setValue('MICE')
|
|
await sourceField?.find('input[name="/basic_information/source_code"]').setValue('DIRECT')
|
|
await wrapper.findAll('button').find((button) => button.text().includes('确认卡片'))?.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-basic', {
|
|
version: 7,
|
|
confirmed_payload: {
|
|
basic_information: {
|
|
account_code: 'ACC-LIVE',
|
|
market_code: 'MICE',
|
|
source_code: 'DIRECT',
|
|
},
|
|
},
|
|
})
|
|
})
|
|
|
|
it('keeps task card layout classes and places the primary card action in the card footer', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
detail.business_cards[0]!.card_type = 'VOUCHER'
|
|
detail.business_cards[0]!.display_payload = {
|
|
booking_scenario: 'STANDARD',
|
|
relevant_message_excerpt: 'Please keep this visible.',
|
|
}
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.findAll('.task-card-section')).toHaveLength(2)
|
|
expect(wrapper.find('.task-card-section__header').exists()).toBe(true)
|
|
expect(wrapper.find('.card-meta-grid').exists()).toBe(false)
|
|
expect(wrapper.find('details.safe-payload').exists()).toBe(false)
|
|
expect(wrapper.find('.task-card-section__header .primary-button').exists()).toBe(false)
|
|
const firstCard = wrapper.find('.task-card-section')
|
|
const footer = firstCard.find('.task-card-section__footer')
|
|
expect(footer.exists()).toBe(true)
|
|
const cardChildren = Array.from(firstCard.element.children)
|
|
expect(cardChildren[cardChildren.length - 1]).toBe(footer.element)
|
|
expect(footer.find('.task-card-section__footer-actions .primary-button').text()).toContain(zhCN.taskV4.confirmCard)
|
|
expect(wrapper.find('.card-actions .primary-button').exists()).toBe(false)
|
|
})
|
|
|
|
it('does not render direct attachment URLs from V4 source message payload', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
sourceDisplayPayload: {
|
|
subject: 'Booking Request',
|
|
sender_summary: 'guest@example.test',
|
|
relevant_message_excerpt: 'Please book one twin room.',
|
|
uploaded_media: [
|
|
'https://oss.example/private/booking.pdf',
|
|
'oss://bucket/private-voucher.jpg',
|
|
{
|
|
file_name: 'safe-booking.pdf',
|
|
content_type: 'application/pdf',
|
|
},
|
|
],
|
|
},
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('safe-booking.pdf')
|
|
expect(wrapper.text()).toContain(zhCN.conversation.unnamedAttachment)
|
|
expect(wrapper.text()).not.toContain('https://oss.example')
|
|
expect(wrapper.text()).not.toContain('oss://bucket')
|
|
})
|
|
|
|
it('renders V4 source message display at the bottom with only the current email body collapsed', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
detail.source_message_card!.fields = [
|
|
createField('/source_message/ai_payload_json', {
|
|
display_name: 'AI payload',
|
|
value: 'AI_PAYLOAD_SHOULD_NOT_RENDER',
|
|
}),
|
|
createField('/source_message/raw_evidence', {
|
|
display_name: 'Raw evidence',
|
|
value: 'RAW_EVIDENCE_SHOULD_NOT_RENDER',
|
|
}),
|
|
createField('/source_message/attachment_url', {
|
|
display_name: 'Attachment URL',
|
|
value: 'https://oss.example/private/source-field.pdf',
|
|
}),
|
|
]
|
|
const currentBody = `Current trigger email body opening. ${'Current booking detail. '.repeat(24)}CURRENT_BODY_TAIL`
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult({
|
|
sourceMessageId: '30001',
|
|
currentBody,
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const pageText = wrapper.text()
|
|
const basicIndex = pageText.indexOf(zhCN.taskV4.basicInformationCard)
|
|
const businessIndex = pageText.indexOf(zhCN.taskV4.businessCards)
|
|
expect(basicIndex).toBeGreaterThanOrEqual(0)
|
|
expect(businessIndex).toBeGreaterThan(basicIndex)
|
|
const sections = wrapper.findAll('.th-section')
|
|
expect(sections[sections.length - 1]?.text()).toContain(zhCN.taskV4.sourceMessageCard)
|
|
expect(sections[sections.length - 1]?.text()).toContain(zhCN.taskV4.sourceMessage.bodyCollapsed)
|
|
expect(service.fetchSourceMessageConversation).not.toHaveBeenCalled()
|
|
expect(pageText).not.toContain('Current trigger email body opening.')
|
|
expect(pageText).not.toContain('OLDER_MESSAGE_BODY')
|
|
expect(pageText).not.toContain('REPLY_MESSAGE_BODY')
|
|
expect(pageText).not.toContain('CURRENT_BODY_TAIL')
|
|
expect(pageText).not.toContain('AI_PAYLOAD_SHOULD_NOT_RENDER')
|
|
expect(pageText).not.toContain('RAW_EVIDENCE_SHOULD_NOT_RENDER')
|
|
expect(pageText).not.toContain('https://oss.example/private/source-field.pdf')
|
|
|
|
const expandButton = wrapper
|
|
.findAll('button')
|
|
.find((button) => button.text().includes(zhCN.taskV4.sourceMessage.showFullBody))
|
|
expect(expandButton).toBeTruthy()
|
|
await expandButton!.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.fetchSourceMessageConversation).toHaveBeenCalledWith('30001')
|
|
expect(wrapper.text()).toContain('Current trigger email body opening.')
|
|
expect(wrapper.text()).toContain('CURRENT_BODY_TAIL')
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.sourceMessage.collapseBody)
|
|
})
|
|
|
|
it('falls back to source summary when current source message body cannot be loaded', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockRejectedValue(new ApiError('Forbidden', 403, {
|
|
code: 'SOURCE_MESSAGE_ORIGINAL_READ_FORBIDDEN',
|
|
message: 'Forbidden',
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('Please book one twin room.')
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.sourceMessage.bodyLoadFailed)
|
|
expect(service.fetchSourceMessageConversation).not.toHaveBeenCalled()
|
|
|
|
const expandButton = wrapper
|
|
.findAll('button')
|
|
.find((button) => button.text().includes(zhCN.taskV4.sourceMessage.showFullBody))
|
|
expect(expandButton).toBeTruthy()
|
|
await expandButton!.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.fetchSourceMessageConversation).toHaveBeenCalledWith('30001')
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.sourceMessage.bodyLoadFailed)
|
|
expect(wrapper.text()).toContain(zhCN.task.viewConversation)
|
|
})
|
|
|
|
it('renders only sanitized source message html and never raw html body', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
const sanitizedHtml = `<p>Sanitized current email opening. ${'Sanitized detail. '.repeat(24)}SANITIZED_HTML_TAIL</p>`
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult({
|
|
sourceMessageId: '30001',
|
|
currentBody: '',
|
|
sanitizedHtml,
|
|
rawHtml: '<script>RAW_HTML_SHOULD_NOT_RENDER</script>',
|
|
htmlRenderMode: 'SANITIZED_HTML',
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).not.toContain('Sanitized current email opening.')
|
|
expect(wrapper.text()).not.toContain('SANITIZED_HTML_TAIL')
|
|
expect(wrapper.text()).not.toContain('RAW_HTML_SHOULD_NOT_RENDER')
|
|
|
|
const expandButton = wrapper
|
|
.findAll('button')
|
|
.find((button) => button.text().includes(zhCN.taskV4.sourceMessage.showFullBody))
|
|
expect(expandButton).toBeTruthy()
|
|
await expandButton!.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('Sanitized current email opening.')
|
|
expect(wrapper.text()).toContain('SANITIZED_HTML_TAIL')
|
|
expect(wrapper.html()).toContain('<p>Sanitized current email opening.')
|
|
expect(wrapper.html()).not.toContain('RAW_HTML_SHOULD_NOT_RENDER')
|
|
})
|
|
|
|
it('does not render sanitized html when backend marks the email body as text only', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult({
|
|
sourceMessageId: '30001',
|
|
currentBody: 'Plain text fallback body.',
|
|
sanitizedHtml: '<p>SANITIZED_HTML_SHOULD_NOT_RENDER</p>',
|
|
rawHtml: '<p>RAW_HTML_SHOULD_NOT_RENDER</p>',
|
|
htmlRenderMode: 'TEXT_ONLY',
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).not.toContain('Plain text fallback body.')
|
|
const expandButton = wrapper
|
|
.findAll('button')
|
|
.find((button) => button.text().includes(zhCN.taskV4.sourceMessage.showFullBody))
|
|
expect(expandButton).toBeTruthy()
|
|
await expandButton!.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('Plain text fallback body.')
|
|
expect(wrapper.text()).not.toContain('SANITIZED_HTML_SHOULD_NOT_RENDER')
|
|
expect(wrapper.text()).not.toContain('RAW_HTML_SHOULD_NOT_RENDER')
|
|
})
|
|
|
|
it('renders Payment attachments with image preview and non-image download from current source message media', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
usePaymentBusinessCard(detail)
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult({
|
|
attachments: createPaymentConversationMedia(),
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(service.fetchSourceMessageConversation).toHaveBeenCalledWith('30001')
|
|
const attachmentPreview = wrapper.find('[data-testid="payment-attachment-preview"]')
|
|
expect(attachmentPreview.exists()).toBe(true)
|
|
expect(attachmentPreview.text()).toContain('voucher-image.jpg')
|
|
expect(attachmentPreview.text()).toContain('voucher-document.pdf')
|
|
expect(attachmentPreview.text()).toContain(zhCN.taskV4.paymentAttachments.noMatchedMedia)
|
|
expect(attachmentPreview.text()).not.toContain('https://oss.example')
|
|
|
|
expect(attachmentPreview.findAll('[data-testid="payment-attachment-thumbnail"]')).toHaveLength(1)
|
|
const thumbnail = attachmentPreview.find('[data-testid="payment-attachment-thumbnail"]')
|
|
expect(thumbnail.exists()).toBe(true)
|
|
expect(thumbnail.find('img').attributes('src')).toBe('https://oss.example/private/payment-image.jpg')
|
|
await thumbnail.trigger('click')
|
|
await flushPromises()
|
|
|
|
const modal = wrapper.find('[data-testid="payment-attachment-modal"]')
|
|
expect(modal.exists()).toBe(true)
|
|
expect(modal.find('img').attributes('src')).toBe('https://oss.example/private/payment-image.jpg')
|
|
expect(wrapper.text()).not.toContain('https://oss.example/private/payment-image.jpg')
|
|
|
|
const downloadLink = attachmentPreview.find('[data-testid="payment-attachment-download"]')
|
|
expect(downloadLink.exists()).toBe(true)
|
|
expect(downloadLink.attributes('href')).toBe('https://oss.example/private/payment-document.pdf')
|
|
})
|
|
|
|
it('degrades Payment attachment preview when conversation media cannot be loaded', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
usePaymentBusinessCard(detail)
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockRejectedValue(new ApiError('Forbidden', 403, {
|
|
code: 'SOURCE_MESSAGE_ORIGINAL_READ_FORBIDDEN',
|
|
message: 'Forbidden',
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('voucher-image.jpg')
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.paymentAttachments.loadFailed)
|
|
expect(wrapper.find('[data-testid="payment-attachment-thumbnail"]').exists()).toBe(false)
|
|
expect(wrapper.find('[data-testid="payment-attachment-download"]').exists()).toBe(false)
|
|
})
|
|
|
|
it('confirms Payment cards with version only and never submits attachment ids or attachment URLs', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
usePaymentBusinessCard(detail)
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.fetchSourceMessageConversation).mockResolvedValue(createSourceMessageConversationResult({
|
|
attachments: createPaymentConversationMedia(),
|
|
}))
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue({
|
|
...detail,
|
|
business_cards: [
|
|
{
|
|
...detail.business_cards[0]!,
|
|
card_status: 'CONFIRMED',
|
|
},
|
|
],
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const paymentCard = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.text().includes(zhCN.taskV4.paymentCard))
|
|
expect(paymentCard).toBeTruthy()
|
|
await paymentCard!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-payment', {
|
|
version: 9,
|
|
})
|
|
const submittedRequest = vi.mocked(service.confirmReservationV4OrderTaskCard).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('attachment_ids')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
})
|
|
|
|
it('renders Rooming List cards as lightweight action items without rows, attachments or raw payloads', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(detail)
|
|
useBoundOrder(detail)
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomingListSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="rooming-list-card"]').exists())
|
|
expect(roomingListSection).toBeTruthy()
|
|
const roomingListCard = roomingListSection!.find('[data-testid="rooming-list-card"]')
|
|
expect(roomingListCard.exists()).toBe(true)
|
|
expect(roomingListSection!.text()).toContain(zhCN.taskV4.roomingList.title)
|
|
expect(roomingListCard.text()).toContain(zhCN.taskV4.roomingList.description)
|
|
expect(roomingListCard.text()).toContain('GRP-001')
|
|
expect(roomingListSection!.findAll('a').filter((link) => link.text() === zhCN.task.viewOrder)).toHaveLength(1)
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.sourceMessageCard)
|
|
const sections = wrapper.findAll('.th-section')
|
|
expect(sections[sections.length - 1]?.text()).toContain(zhCN.taskV4.sourceMessageCard)
|
|
|
|
expect(roomingListSection!.find('details.safe-payload').exists()).toBe(false)
|
|
expect(roomingListSection!.text()).not.toContain('ROW_SHOULD_NOT_RENDER')
|
|
expect(roomingListSection!.text()).not.toContain('attachment_ids')
|
|
expect(roomingListSection!.text()).not.toContain('https://oss.example/private/rooming-list.xlsx')
|
|
expect(roomingListSection!.text()).not.toContain('AI_PAYLOAD_SHOULD_NOT_RENDER')
|
|
expect(roomingListSection!.text()).not.toContain('PMS_IMPORT_SHOULD_NOT_RENDER')
|
|
expect(roomingListSection!.text()).not.toContain('OHIP_SHOULD_NOT_RENDER')
|
|
expect(roomingListSection!.text()).not.toContain('Excel')
|
|
expect(wrapper.find('[data-testid="payment-attachment-preview"]').exists()).toBe(false)
|
|
})
|
|
|
|
it('shows an explanatory unbound order label for Rooming List cards without target order clues', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(detail)
|
|
detail.order_task.display_order_key = null
|
|
detail.order_task.order_ref = null
|
|
detail.order_task.target_locator_type = null
|
|
detail.order_task.target_locator_value = null
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomingListCard = wrapper.find('[data-testid="rooming-list-card"]')
|
|
expect(roomingListCard.text()).toContain(zhCN.taskV4.roomingList.unboundOrder)
|
|
})
|
|
|
|
it('confirms Rooming List cards with version only and applies the refreshed backend detail', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(detail)
|
|
const confirmedDetail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(confirmedDetail, 'CONFIRMED')
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue(confirmedDetail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomingListSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="rooming-list-card"]').exists())
|
|
expect(roomingListSection).toBeTruthy()
|
|
await roomingListSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-rooming-list', {
|
|
version: 12,
|
|
})
|
|
const submittedRequest = vi.mocked(service.confirmReservationV4OrderTaskCard).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('confirmed_payload')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('rows')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('attachment_ids')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
expect(wrapper.text()).toContain(zhCN.status.CONFIRMED)
|
|
})
|
|
|
|
it('resolves Rooming List review cards without submitting row or attachment overrides', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(detail, 'REVIEW_REQUIRED')
|
|
detail.order_task.order_id = 'order-2001'
|
|
detail.order_task.target_resolution_status = 'RESOLVED'
|
|
const resolvedDetail = createOrderTaskDetail()
|
|
useRoomingListBusinessCard(resolvedDetail, 'PENDING_CONFIRM')
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.resolveReservationV4OrderTaskCardReview).mockResolvedValue(resolvedDetail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomingListSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="rooming-list-card"]').exists())
|
|
expect(roomingListSection).toBeTruthy()
|
|
expect(roomingListSection!.find('.review-box').exists()).toBe(true)
|
|
expect(roomingListSection!.find('.task-card-section__fields').exists()).toBe(false)
|
|
await roomingListSection!.find('textarea').setValue('handled rooming list')
|
|
await roomingListSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).not.toHaveBeenCalled()
|
|
expect(service.resolveReservationV4OrderTaskCardReview).toHaveBeenCalledWith('9001', 'card-rooming-list', {
|
|
version: 12,
|
|
confirmed_order_id: 'order-2001',
|
|
reason: 'handled rooming list',
|
|
field_overrides: [],
|
|
})
|
|
const submittedRequest = vi.mocked(service.resolveReservationV4OrderTaskCardReview).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('rows')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('attachment_ids')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
})
|
|
|
|
it('renders GENERAL Trace cards with fixed department options and confirms safe trace fields only', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useTraceBusinessCard(detail, 'GENERAL')
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue({
|
|
...detail,
|
|
business_cards: [
|
|
{
|
|
...detail.business_cards[0]!,
|
|
card_status: 'CONFIRMED',
|
|
},
|
|
],
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const traceSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="trace-card"]').exists())
|
|
expect(traceSection).toBeTruthy()
|
|
expect((traceSection!.find('textarea[name="/trace_items/0/text"]').element as HTMLTextAreaElement).value)
|
|
.toBe('Late arrival note')
|
|
expect(traceSection!.text()).not.toContain('CONTENT_SHOULD_NOT_RENDER')
|
|
expect(traceSection!.text()).not.toContain('TARGET_ORDER_SHOULD_NOT_RENDER')
|
|
expect(traceSection!.text()).not.toContain('AI_PAYLOAD_SHOULD_NOT_RENDER')
|
|
expect(traceSection!.text()).not.toContain('https://oss.example/private/trace.pdf')
|
|
expect(traceSection!.find('details.safe-payload').exists()).toBe(false)
|
|
|
|
const departmentOptions = traceSection!
|
|
.find('select[name="/trace_items/0/department_code"]')
|
|
.findAll('option')
|
|
.map((option) => option.attributes('value'))
|
|
expect(departmentOptions).toEqual(['', 'FO', 'HSK', 'FO+HSK'])
|
|
|
|
await traceSection!.find('textarea[name="/trace_items/0/text"]').setValue('Arrange late arrival follow-up')
|
|
await traceSection!.find('select[name="/trace_items/0/department_code"]').setValue('HSK')
|
|
await traceSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-trace', {
|
|
version: 10,
|
|
confirmed_payload: {
|
|
trace_items: [
|
|
{
|
|
text: 'Arrange late arrival follow-up',
|
|
department_code: 'HSK',
|
|
},
|
|
],
|
|
},
|
|
})
|
|
const submittedRequest = vi.mocked(service.confirmReservationV4OrderTaskCard).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('content')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('target_order')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('AI_PAYLOAD_SHOULD_NOT_RENDER')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
})
|
|
|
|
it('renders EXTRA_BED Trace cards with room type lookup, positive count input and confirms safe fields only', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useTraceBusinessCard(detail, 'EXTRA_BED')
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const traceSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="trace-card"]').exists())
|
|
expect(traceSection).toBeTruthy()
|
|
expect(traceSection!.text()).toContain('SET EXTRA BED')
|
|
expect(traceSection!.find('select[name="/trace_items/0/target_room_type_code"]').text()).toContain('RM2')
|
|
const roomCountInput = traceSection!.find('input[name="/trace_items/0/extra_bed_room_count"]')
|
|
expect(roomCountInput.attributes('type')).toBe('number')
|
|
expect(roomCountInput.attributes('min')).toBe('1')
|
|
expect(roomCountInput.attributes('step')).toBe('1')
|
|
|
|
await traceSection!.find('select[name="/trace_items/0/target_room_type_code"]').setValue('RM2')
|
|
await roomCountInput.setValue('0')
|
|
await traceSection!.find('select[name="/trace_items/0/department_code"]').setValue('FO+HSK')
|
|
await traceSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).not.toHaveBeenCalled()
|
|
expect(traceSection!.text()).toContain('Extra Bed Room Count must be a positive integer')
|
|
|
|
await roomCountInput.setValue('2')
|
|
await traceSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-trace', {
|
|
version: 10,
|
|
confirmed_payload: {
|
|
trace_items: [
|
|
{
|
|
target_room_type_code: 'RM2',
|
|
extra_bed_room_count: 2,
|
|
department_code: 'FO+HSK',
|
|
},
|
|
],
|
|
},
|
|
})
|
|
const submittedRequest = vi.mocked(service.confirmReservationV4OrderTaskCard).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('content')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('target_order')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
})
|
|
|
|
it('resolves REVIEW_REQUIRED Trace cards with field errors and safe review overrides', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
useTraceBusinessCard(detail, 'GENERAL', 'REVIEW_REQUIRED')
|
|
detail.order_task.order_id = 'order-2001'
|
|
detail.order_task.target_resolution_status = 'RESOLVED'
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.resolveReservationV4OrderTaskCardReview).mockResolvedValue({
|
|
...detail,
|
|
business_cards: [
|
|
{
|
|
...detail.business_cards[0]!,
|
|
card_status: 'PENDING_CONFIRM',
|
|
review_status: 'RESOLVED',
|
|
},
|
|
],
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const traceSection = wrapper
|
|
.findAll('.task-card-section')
|
|
.find((section) => section.find('[data-testid="trace-card"]').exists())
|
|
expect(traceSection).toBeTruthy()
|
|
expect(traceSection!.find('.trace-field__error').text()).toContain('Department is required')
|
|
|
|
await traceSection!.find('textarea[name="/trace_items/0/text"]').setValue('Confirm trace review text')
|
|
await traceSection!.find('select[name="/trace_items/0/department_code"]').setValue('FO')
|
|
await traceSection!.find('textarea[name="v4_review_reason"]').setValue('confirmed trace note')
|
|
await traceSection!.find('button.primary-button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).not.toHaveBeenCalled()
|
|
expect(service.resolveReservationV4OrderTaskCardReview).toHaveBeenCalledWith('9001', 'card-trace', {
|
|
version: 10,
|
|
confirmed_order_id: 'order-2001',
|
|
reason: 'confirmed trace note',
|
|
field_overrides: [
|
|
{
|
|
field_pointer: '/trace_items/0/text',
|
|
value: 'Confirm trace review text',
|
|
},
|
|
{
|
|
field_pointer: '/trace_items/0/department_code',
|
|
value: 'FO',
|
|
},
|
|
],
|
|
})
|
|
const submittedRequest = vi.mocked(service.resolveReservationV4OrderTaskCardReview).mock.calls[0]?.[2]
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('content')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('target_order')
|
|
expect(JSON.stringify(submittedRequest)).not.toContain('https://oss.example')
|
|
})
|
|
|
|
it('renders New Booking Room Information as a business form and confirms stable final values', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessEventType: 'NEW_BOOKING',
|
|
businessBookingType: 'GROUP',
|
|
})
|
|
detail.business_cards[0]!.fields = [
|
|
...detail.business_cards[0]!.fields,
|
|
createField('/room_information/final_values/adult', {
|
|
display_name: 'Adult',
|
|
value: 2,
|
|
}),
|
|
createField('/room_information/final_values/nights', {
|
|
display_name: 'Nights',
|
|
value: 3,
|
|
}),
|
|
createField('/room_information/final_values/target_order/locator_value', {
|
|
display_name: 'Target Locator',
|
|
value: 'RAW-GRP-001',
|
|
}),
|
|
createField('/room_information/final_values/breakfast_included', {
|
|
display_name: 'Breakfast',
|
|
value: true,
|
|
control_type: 'CHECKBOX',
|
|
}),
|
|
createField('/business_fields/after/room_items/0/room_type_code', {
|
|
display_name: 'Legacy Room Type',
|
|
value: 'LEGACY',
|
|
}),
|
|
]
|
|
const groupStatusField = detail.business_cards[0]!.fields.find((field) =>
|
|
field.field_pointer === '/room_information/final_values/group_booking_status',
|
|
)
|
|
if (groupStatusField) {
|
|
groupStatusField.validation_errors = ['请选择团队预订状态']
|
|
groupStatusField.fixed_options = [
|
|
{
|
|
value: 'TEN',
|
|
label: 'TEN-Tentative',
|
|
},
|
|
{
|
|
value: 'DEF',
|
|
label: 'DEF-Definite',
|
|
},
|
|
{
|
|
value: 'INQ',
|
|
label: 'INQ-Inquiry',
|
|
},
|
|
]
|
|
}
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockResolvedValue({
|
|
...detail,
|
|
business_cards: [
|
|
{
|
|
...detail.business_cards[0]!,
|
|
card_status: 'CONFIRMED',
|
|
},
|
|
],
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
expect(roomCard.exists()).toBe(true)
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.finalValues)
|
|
expect(roomCard.text()).toContain('TEN-Tentative')
|
|
expect(roomCard.text()).toContain('3')
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.confirmationNumber)
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.blockId)
|
|
const confirmationField = findFieldByLabel(roomCard, zhCN.taskV4.roomInformation.confirmationNumber)
|
|
const blockIdField = findFieldByLabel(roomCard, zhCN.taskV4.roomInformation.blockId)
|
|
expect(confirmationField?.find('.v4-field__static').text()).toBe('-')
|
|
expect(blockIdField?.find('.v4-field__static').text()).toBe('-')
|
|
const statusSlot = roomCard.find('.room-information__status-slot')
|
|
const statusSelect = statusSlot.find('select[name="/room_information/final_values/group_booking_status"]')
|
|
expect(statusSlot.text()).toContain(zhCN.taskV4.roomInformation.groupBookingStatus)
|
|
expect(statusSlot.text()).toContain('*')
|
|
expect(statusSlot.text()).toContain('TEN-Tentative')
|
|
expect(statusSelect.attributes('aria-invalid')).toBe('true')
|
|
expect(statusSelect.findAll('option').map((option) => (option.element as HTMLOptionElement).value))
|
|
.toEqual(['', 'TEN', 'DEF', 'INQ'])
|
|
expect(roomCard.find('.room-information__status-error').text()).toContain('请选择团队预订状态')
|
|
expect(roomCard.find('.room-information__derived').exists()).toBe(false)
|
|
expect(roomCard.text()).not.toContain('target_order')
|
|
expect(roomCard.text()).not.toContain('Adult')
|
|
expect(roomCard.text()).not.toContain('Legacy Room Type')
|
|
expect(roomCard.text()).not.toContain('Group Block Name')
|
|
expect(roomCard.text()).not.toContain('Rate Code')
|
|
expect(roomCard.text()).not.toContain('Group Booking Status')
|
|
expect(roomCard.find('input[name="/room_information/final_values/adult"]').exists()).toBe(false)
|
|
expect(roomCard.find('input[name="/room_information/final_values/nights"]').exists()).toBe(false)
|
|
expect(roomCard.find('input[name="/room_information/final_values/target_order/locator_value"]').exists()).toBe(false)
|
|
expect(roomCard.find('input[name="/business_fields/after/room_items/0/room_type_code"]').exists()).toBe(false)
|
|
|
|
const breakfastInputs = roomCard.findAll('input[type="checkbox"][name="/room_information/final_values/breakfast_included"]')
|
|
expect(breakfastInputs).toHaveLength(1)
|
|
const breakfast = breakfastInputs[0]!
|
|
expect((breakfast.element as HTMLInputElement).checked).toBe(true)
|
|
expect((breakfast.element as HTMLInputElement).disabled).toBe(true)
|
|
expect((roomCard.find('input[name="/room_information/final_values/group_block_name"]').element as HTMLInputElement).value)
|
|
.toBe('GRP-V4-RI-GROUP-001')
|
|
expect(roomCard.find('input[name="/room_information/final_values/arrival_date"]').attributes('type')).toBe('text')
|
|
expect((roomCard.find('input[name="/room_information/final_values/arrival_date"]').element as HTMLInputElement).value)
|
|
.toBe('2026-07-26')
|
|
expect(roomCard.find('input[name="/room_information/final_values/departure_date"]').attributes('type')).toBe('text')
|
|
expect((roomCard.find('input[name="/room_information/final_values/departure_date"]').element as HTMLInputElement).value)
|
|
.toBe('2026-07-29')
|
|
const roomInformationText = roomCard.text()
|
|
expect(roomInformationText.indexOf(zhCN.taskV4.roomInformation.departureDate))
|
|
.toBeLessThan(roomInformationText.indexOf(zhCN.taskV4.roomInformation.nights))
|
|
expect(roomInformationText.indexOf(zhCN.taskV4.roomInformation.nights))
|
|
.toBeLessThan(roomInformationText.indexOf(zhCN.taskV4.roomInformation.rateCode))
|
|
expect(roomInformationText.indexOf(zhCN.taskV4.roomInformation.blockId))
|
|
.toBeLessThan(roomInformationText.indexOf(zhCN.taskV4.roomInformation.breakfastIncluded))
|
|
|
|
await roomCard.find('input[name="/room_information/final_values/group_block_name"]').setValue('前端修正团队名')
|
|
await roomCard.find('select[name="/room_information/final_values/group_booking_status"]').setValue('DEF')
|
|
await roomCard.find('button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-room', {
|
|
version: 5,
|
|
confirmed_payload: {
|
|
room_information: {
|
|
final_values: {
|
|
group_block_name: '前端修正团队名',
|
|
arrival_date: '2026-07-26',
|
|
departure_date: '2026-07-29',
|
|
rate_code: 'GRPA2-850UP',
|
|
group_booking_status: 'DEF',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'RM2',
|
|
room_count: 2,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
})
|
|
})
|
|
|
|
it('shows a user-facing empty state when Room Information display data is unavailable', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessDisplayPayload: {},
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.noDisplayModel)
|
|
expect(roomCard.text()).not.toContain('Room Information')
|
|
expect(roomCard.text()).not.toContain('display model')
|
|
expect(roomCard.text()).not.toContain('展示模型')
|
|
})
|
|
|
|
it('keeps backend errors for hidden Room Information fields visible as action messages', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessEventType: 'NEW_BOOKING',
|
|
businessBookingType: 'GROUP',
|
|
})
|
|
detail.business_cards[0]!.fields = [
|
|
...detail.business_cards[0]!.fields,
|
|
createField('/room_information/final_values/nights', {
|
|
display_name: 'Nights',
|
|
value: 3,
|
|
}),
|
|
]
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.confirmReservationV4OrderTaskCard).mockRejectedValue(new ApiError('validation failed', 400, {
|
|
message: '后端校验失败',
|
|
details: [
|
|
'room_information.final_values.nights: 晚数不能由前端提交。',
|
|
'room_information.final_values.group_block_name: 团队名称不能为空。',
|
|
],
|
|
}))
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
await roomCard.find('button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('后端校验失败')
|
|
expect(wrapper.text()).toContain('room_information.final_values.nights: 晚数不能由前端提交。')
|
|
expect(wrapper.text()).toContain('room_information.final_values.group_block_name: 团队名称不能为空。')
|
|
})
|
|
|
|
it('renders readonly Room Information fixed select values with business labels', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessEventType: 'NEW_BOOKING',
|
|
businessBookingType: 'GROUP',
|
|
})
|
|
detail.business_cards[0]!.fields = detail.business_cards[0]!.fields.map((field) =>
|
|
field.field_pointer === '/room_information/final_values/group_booking_status'
|
|
? {
|
|
...field,
|
|
editable: false,
|
|
raw_readonly: true,
|
|
}
|
|
: field,
|
|
)
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
expect(roomCard.text()).toContain('新预订')
|
|
expect(roomCard.text()).not.toContain('NEW_BOOKING')
|
|
expect(roomCard.find('select[name="/room_information/final_values/group_booking_status"]').exists()).toBe(false)
|
|
expect(roomCard.text()).toContain('TEN-Tentative')
|
|
})
|
|
|
|
it('renders Update Booking Room Information change summary before final values', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessEventType: 'UPDATE_BOOKING',
|
|
businessBookingType: 'GROUP',
|
|
businessDisplayPayload: createRoomInformationDisplayPayload({
|
|
event_type: 'UPDATE_BOOKING',
|
|
current_values: {
|
|
group_block_name: 'GRP-V4-RI-UPDATE-001',
|
|
arrival_date: '2026-07-26',
|
|
departure_date: '2026-07-29',
|
|
nights: 3,
|
|
rate_code: 'GRPA2-850UP',
|
|
breakfast_included: true,
|
|
group_booking_status: 'TEN',
|
|
group_booking_status_label: 'TEN-Tentative',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'RM2',
|
|
room_count: 2,
|
|
},
|
|
],
|
|
},
|
|
proposed_values: {
|
|
arrival_date: '2026-07-27',
|
|
departure_date: '2026-07-31',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'RM3',
|
|
room_count: 3,
|
|
},
|
|
],
|
|
},
|
|
final_values: {
|
|
group_block_name: 'GRP-V4-RI-UPDATE-001',
|
|
arrival_date: '2026-07-27',
|
|
departure_date: '2026-07-31',
|
|
nights: 4,
|
|
rate_code: 'GRPA2-850UP',
|
|
breakfast_included: true,
|
|
group_booking_status: 'TEN',
|
|
group_booking_status_label: 'TEN-Tentative',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'RM3',
|
|
room_count: 3,
|
|
},
|
|
],
|
|
},
|
|
change_summary: [
|
|
{
|
|
field: 'arrival_date',
|
|
before: '2026-07-26',
|
|
after: '2026-07-27',
|
|
},
|
|
{
|
|
field: 'nights',
|
|
before: 3,
|
|
after: 4,
|
|
},
|
|
{
|
|
field: 'adult',
|
|
before: 'ADULT-BEFORE-SHOULD-NOT-SHOW',
|
|
after: 'ADULT-AFTER-SHOULD-NOT-SHOW',
|
|
},
|
|
{
|
|
field: 'target_order.locator_value',
|
|
before: 'RAW-BEFORE-SHOULD-NOT-SHOW',
|
|
after: 'RAW-AFTER-SHOULD-NOT-SHOW',
|
|
},
|
|
],
|
|
}),
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
expect(roomCard.text()).toContain('修改预订')
|
|
expect(roomCard.text()).not.toContain('UPDATE_BOOKING')
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.changeSummary)
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.currentValues)
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.proposedValues)
|
|
expect(roomCard.text()).toContain('2026-07-26')
|
|
expect(roomCard.text()).toContain('2026-07-27')
|
|
expect(roomCard.text()).toContain('3')
|
|
expect(roomCard.text()).toContain('4')
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.finalValues)
|
|
expect(roomCard.text()).not.toContain('target_order')
|
|
expect(roomCard.text()).not.toContain('ADULT-BEFORE-SHOULD-NOT-SHOW')
|
|
expect(roomCard.text()).not.toContain('RAW-BEFORE-SHOULD-NOT-SHOW')
|
|
})
|
|
|
|
it('renders Cancel Booking Room Information as readonly current and final values', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessEventType: 'CANCEL_BOOKING',
|
|
businessBookingType: 'GROUP',
|
|
businessFields: [],
|
|
businessDisplayPayload: createRoomInformationDisplayPayload({
|
|
event_type: 'CANCEL_BOOKING',
|
|
current_values: {
|
|
group_block_name: 'GRP-V4-RI-CANCEL-001',
|
|
arrival_date: '2026-08-01',
|
|
departure_date: '2026-08-05',
|
|
nights: 4,
|
|
rate_code: 'GRPA2-850UP',
|
|
breakfast_included: true,
|
|
group_booking_status: 'DEF',
|
|
group_booking_status_label: 'DEF-Definite',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'SU1',
|
|
room_count: 1,
|
|
},
|
|
],
|
|
},
|
|
final_values: {
|
|
group_block_name: 'GRP-V4-RI-CANCEL-001',
|
|
arrival_date: '2026-08-01',
|
|
departure_date: '2026-08-05',
|
|
nights: 4,
|
|
rate_code: 'GRPA2-850UP',
|
|
breakfast_included: true,
|
|
group_booking_status: 'DEF',
|
|
group_booking_status_label: 'DEF-Definite',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'SU1',
|
|
room_count: 1,
|
|
},
|
|
],
|
|
},
|
|
}),
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
expect(roomCard.text()).toContain('取消预订')
|
|
expect(roomCard.text()).not.toContain('CANCEL_BOOKING')
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.currentValues)
|
|
expect(roomCard.text()).toContain(zhCN.taskV4.roomInformation.finalValues)
|
|
expect(roomCard.text()).toContain('GRP-V4-RI-CANCEL-001')
|
|
expect(roomCard.text()).toContain('SU1')
|
|
expect(roomCard.find('input[name="/room_information/final_values/arrival_date"]').exists()).toBe(false)
|
|
expect(roomCard.find('select[name="/room_information/final_values/group_booking_status"]').exists()).toBe(false)
|
|
})
|
|
|
|
it('submits V4 review resolution with Room Information field_pointer overrides from the confirm card button', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessCardStatus: 'REVIEW_REQUIRED',
|
|
businessCardAvailability: {
|
|
confirmable: false,
|
|
reviewable: true,
|
|
},
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
const resolvedBusinessCard = detail.business_cards[0]!
|
|
vi.mocked(service.resolveReservationV4OrderTaskCardReview).mockResolvedValue({
|
|
...detail,
|
|
business_cards: [
|
|
{
|
|
...resolvedBusinessCard,
|
|
card_status: 'PENDING_CONFIRM',
|
|
review_status: 'RESOLVED',
|
|
},
|
|
],
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
const roomCard = wrapper.find('[data-testid="room-information-card"]')
|
|
await roomCard.find('select[name="/room_information/final_values/room_items/0/room_type_code"]').setValue('RM2')
|
|
await wrapper.find('input[name="v4_confirmed_order_id"]').setValue('order-2001')
|
|
await wrapper.find('textarea').setValue('confirmed by email evidence')
|
|
await roomCard.find('button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.resolveReservationV4OrderTaskCardReview).toHaveBeenCalledWith('9001', 'card-room', {
|
|
version: 5,
|
|
confirmed_order_id: 'order-2001',
|
|
reason: 'confirmed by email evidence',
|
|
field_overrides: [
|
|
{
|
|
field_pointer: '/room_information/final_values/room_items/0/room_type_code',
|
|
value: 'RM2',
|
|
},
|
|
],
|
|
})
|
|
})
|
|
|
|
it('shows lookup empty state without catalog technical warnings', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'ACCOUNT',
|
|
catalog_source: 'PMS_SYNC',
|
|
catalog_version: 'stale-v1',
|
|
stale: true,
|
|
items: [],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 0,
|
|
},
|
|
warnings: ['PMS sync is stale'],
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.lookup.empty)
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.lookup.stale)
|
|
expect(wrapper.text()).not.toContain('PMS sync is stale')
|
|
expect(wrapper.text()).not.toContain('PMS_SYNC')
|
|
expect(wrapper.text()).not.toContain('stale-v1')
|
|
})
|
|
|
|
it('does not submit a catalog field value that is missing from the loaded lookup result', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
basicAccountValue: 'UNKNOWN_ACCOUNT',
|
|
basicAccountRequired: true,
|
|
})
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'ACCOUNT',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
catalog_version: 'catalog-v1',
|
|
stale: false,
|
|
items: [],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 0,
|
|
},
|
|
warnings: [],
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('UNKNOWN_ACCOUNT')
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.lookup.currentNotInCatalog.replace('{value}', 'UNKNOWN_ACCOUNT'))
|
|
|
|
await wrapper.findAll('button').find((button) => button.text().includes('确认卡片'))?.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).not.toHaveBeenCalled()
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.validationFailed)
|
|
})
|
|
|
|
it('keeps readonly catalog field values even when active lookup does not contain them', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
basicAccountValue: 'HISTORICAL_ACCOUNT',
|
|
basicCardStatus: 'CONFIRMED',
|
|
basicCardAvailability: {
|
|
editable: false,
|
|
read_only: true,
|
|
confirmable: false,
|
|
},
|
|
})
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockResolvedValue(createCatalogLookupResult('ACCOUNT', []))
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(service.fetchReservationV4AccountLookups).not.toHaveBeenCalled()
|
|
expect(wrapper.text()).toContain('HISTORICAL_ACCOUNT')
|
|
expect(wrapper.text()).not.toContain(
|
|
zhCN.taskV4.lookup.currentNotInCatalog.replace('{value}', 'HISTORICAL_ACCOUNT'),
|
|
)
|
|
})
|
|
|
|
it('keeps a current catalog value found by exact keyword lookup outside the first page', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
basicAccountValue: 'ACC-101',
|
|
basicAccountRequired: true,
|
|
})
|
|
vi.mocked(service.fetchReservationV4AccountLookups)
|
|
.mockResolvedValueOnce(createCatalogLookupResult('ACCOUNT', [
|
|
{
|
|
code: 'ACC-001',
|
|
display_name: 'Account 001',
|
|
market_code: 'LEISURE',
|
|
source_code: 'TRAVEL_AGENT',
|
|
},
|
|
], 101))
|
|
.mockResolvedValueOnce(createCatalogLookupResult('ACCOUNT', [
|
|
{
|
|
code: 'ACC-101',
|
|
display_name: 'Account 101',
|
|
market_code: 'MICE',
|
|
source_code: 'DIRECT',
|
|
},
|
|
], 1, 20))
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
await flushPromises()
|
|
|
|
expect(service.fetchReservationV4AccountLookups).toHaveBeenNthCalledWith(1, {
|
|
hotel_id: 'HOTEL-TEST',
|
|
page_num: 1,
|
|
page_size: 100,
|
|
})
|
|
expect(service.fetchReservationV4AccountLookups).toHaveBeenNthCalledWith(2, {
|
|
hotel_id: 'HOTEL-TEST',
|
|
keyword: 'ACC-101',
|
|
page_num: 1,
|
|
page_size: 20,
|
|
})
|
|
await wrapper.findAll('button').find((button) => button.text().includes('确认卡片'))?.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.confirmReservationV4OrderTaskCard).toHaveBeenCalledWith('9001', 'card-basic', {
|
|
version: 7,
|
|
confirmed_payload: {
|
|
basic_information: {
|
|
account_code: 'ACC-101',
|
|
market_code: 'LEISURE',
|
|
source_code: 'TRAVEL_AGENT',
|
|
},
|
|
},
|
|
})
|
|
})
|
|
|
|
it('hides catalog technical warnings from ordinary V4 business cards', async () => {
|
|
const detail = createOrderTaskDetail()
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'ACCOUNT',
|
|
catalog_source: 'PMS_SYNC',
|
|
catalog_version: 'seed-v1',
|
|
stale: true,
|
|
items: [],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 0,
|
|
},
|
|
warnings: ['固定种子初始化，后续接入真实 PMS。'],
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.lookup.empty)
|
|
expect(wrapper.text()).not.toContain('固定种子初始化')
|
|
expect(wrapper.text()).not.toContain('真实 PMS')
|
|
expect(wrapper.text()).not.toContain('PMS_SYNC')
|
|
expect(wrapper.text()).not.toContain('seed-v1')
|
|
expect(wrapper.text()).not.toContain(zhCN.taskV4.lookup.stale)
|
|
})
|
|
|
|
it('keeps the per-card primary action right aligned on narrow screens', () => {
|
|
expect(taskCardSectionSource).toContain('@media (max-width: 980px)')
|
|
expect(taskCardSectionSource).toContain('.task-card-section__footer-actions')
|
|
expect(taskCardSectionSource).toContain('padding: 0 20px 20px')
|
|
expect(taskCardSectionSource).toContain('justify-content: flex-end')
|
|
expect(taskCardSectionSource).toContain('.task-card-section__footer {\n align-items: flex-end;\n }')
|
|
})
|
|
|
|
it('requires confirmed order id before resolving an unresolved V4 review card', async () => {
|
|
const detail = createOrderTaskDetail({
|
|
businessCardStatus: 'REVIEW_REQUIRED',
|
|
businessCardAvailability: {
|
|
confirmable: false,
|
|
reviewable: true,
|
|
},
|
|
})
|
|
vi.mocked(service.fetchReservationV4OrderTaskDetail).mockResolvedValue(detail)
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4OrderTaskDetailView,
|
|
'/reservation/order-tasks/9001',
|
|
)
|
|
await flushPromises()
|
|
|
|
await wrapper.find('[data-testid="room-information-card"]').find('button').trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.resolveReservationV4OrderTaskCardReview).not.toHaveBeenCalled()
|
|
expect(wrapper.text()).toContain(zhCN.taskV4.confirmedOrderRequired)
|
|
})
|
|
|
|
it('renders V4 source notification detail and acknowledges it without business actions', async () => {
|
|
const detail = createSourceNotificationDetail()
|
|
vi.mocked(service.fetchReservationV4SourceNotificationDetail).mockResolvedValue(detail)
|
|
vi.mocked(service.ackReservationV4SourceNotification).mockResolvedValue({
|
|
...detail,
|
|
notification: {
|
|
...detail.notification,
|
|
notification_status: 'ACKED',
|
|
},
|
|
availability: {
|
|
...detail.availability,
|
|
ackable: false,
|
|
},
|
|
})
|
|
|
|
const wrapper = await mountWithPlugins(
|
|
ReservationV4SourceNotificationDetailView,
|
|
'/reservation/source-notifications/7001',
|
|
)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('来源通知详情')
|
|
expect(wrapper.text()).toContain('FYI only')
|
|
expect(wrapper.text()).toContain('该通知不关联订单、业务卡、字段编辑、复核或 OPERA 操作')
|
|
expect(wrapper.text()).not.toContain('业务任务卡')
|
|
expect(wrapper.text()).not.toContain('确认卡片')
|
|
|
|
await wrapper.find('textarea').setValue('handled')
|
|
await wrapper.findAll('button').find((button) => button.text().includes('确认已读'))?.trigger('click')
|
|
await flushPromises()
|
|
|
|
expect(service.ackReservationV4SourceNotification).toHaveBeenCalledWith('7001', {
|
|
version: 3,
|
|
reason: 'handled',
|
|
})
|
|
})
|
|
})
|
|
|
|
async function mountWithPlugins(component: object, initialPath: string) {
|
|
const pinia = createPinia()
|
|
setActivePinia(pinia)
|
|
const authStore = useAuthStore()
|
|
authStore.applyLoginResult({
|
|
access_token: 'test-token',
|
|
token_type: 'Bearer',
|
|
expires_at: '2026-07-08T04:00:00Z',
|
|
user: {
|
|
id: 'u1',
|
|
username: 'agent',
|
|
display_name: '系统管理员',
|
|
super_admin: false,
|
|
},
|
|
default_hotel_id: 'HOTEL-TEST',
|
|
hotels: [
|
|
{
|
|
hotel_id: 'HOTEL-TEST',
|
|
hotel_name: '测试酒店',
|
|
time_zone: 'Asia/Bangkok',
|
|
default_hotel: true,
|
|
},
|
|
],
|
|
permissions: [
|
|
'RESERVATION_TASK_READ',
|
|
'RESERVATION_TASK_CONFIRM',
|
|
'RESERVATION_MANUAL_REVIEW_RESOLVE',
|
|
'SOURCE_MESSAGE_ORIGINAL_READ',
|
|
],
|
|
menus: [],
|
|
})
|
|
const i18n = createI18n({
|
|
legacy: false,
|
|
locale: 'zh-CN',
|
|
messages: {
|
|
'zh-CN': zhCN,
|
|
},
|
|
})
|
|
const router = createRouter({
|
|
history: createMemoryHistory(),
|
|
routes: [
|
|
{ path: '/', component: { template: '<div />' } },
|
|
{ path: '/reservation/order-tasks/:orderTaskId', component: { template: '<div />' } },
|
|
{ path: '/reservation/source-notifications/:notificationId', component: { template: '<div />' } },
|
|
{ path: '/reservation/source-messages/:sourceMessageId/conversation', component: { template: '<div />' } },
|
|
{ path: '/reservation/orders/:orderId', component: { template: '<div />' } },
|
|
],
|
|
})
|
|
await router.push(initialPath)
|
|
await router.isReady()
|
|
|
|
return mount(component, {
|
|
global: {
|
|
plugins: [pinia, i18n, router, PrimeVue],
|
|
stubs: {
|
|
RouterLink: {
|
|
template: '<a><slot /></a>',
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
function mockCatalogLookups() {
|
|
vi.mocked(service.fetchReservationV4AccountLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'ACCOUNT',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
catalog_version: 'catalog-v1',
|
|
stale: false,
|
|
items: [
|
|
{
|
|
code: 'ACC-LIVE',
|
|
display_name: 'Live Account',
|
|
status: 'ACTIVE',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
market_code: 'LEISURE',
|
|
market_name: 'Leisure',
|
|
source_code: 'TRAVEL_AGENT',
|
|
source_name: 'Travel Agent',
|
|
adult_capacity: null,
|
|
pricing_available: null,
|
|
},
|
|
],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 1,
|
|
},
|
|
warnings: [],
|
|
})
|
|
vi.mocked(service.fetchReservationV4RoomTypeLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'ROOM_TYPE',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
catalog_version: 'catalog-v1',
|
|
stale: false,
|
|
items: [
|
|
{
|
|
code: 'RM2',
|
|
display_name: 'RM2',
|
|
status: 'ACTIVE',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
market_code: null,
|
|
market_name: null,
|
|
source_code: null,
|
|
source_name: null,
|
|
adult_capacity: 2,
|
|
pricing_available: null,
|
|
},
|
|
],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 1,
|
|
},
|
|
warnings: [],
|
|
})
|
|
vi.mocked(service.fetchReservationV4RateCodeLookups).mockResolvedValue({
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type: 'RATE_CODE',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
catalog_version: 'catalog-v1',
|
|
stale: false,
|
|
items: [
|
|
{
|
|
code: 'GRPA2-850UP',
|
|
display_name: 'GRPA2-850UP',
|
|
status: 'ACTIVE',
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
market_code: null,
|
|
market_name: null,
|
|
source_code: null,
|
|
source_name: null,
|
|
adult_capacity: null,
|
|
pricing_available: null,
|
|
},
|
|
],
|
|
page: {
|
|
page_num: 1,
|
|
page_size: 100,
|
|
total: 1,
|
|
},
|
|
warnings: [],
|
|
})
|
|
}
|
|
|
|
function createOrderTaskDetail(options: {
|
|
basicCardStatus?: string
|
|
basicCardAvailability?: Partial<ReservationV4TaskCardResult['availability']>
|
|
businessCardStatus?: string
|
|
businessCardAvailability?: Partial<ReservationV4TaskCardResult['availability']>
|
|
businessEventType?: string
|
|
businessBookingType?: string
|
|
businessDisplayPayload?: ReservationV4TaskCardResult['display_payload']
|
|
businessFields?: ReservationV4TaskCardResult['fields']
|
|
sourceDisplayPayload?: ReservationV4TaskCardResult['display_payload']
|
|
basicAccountValue?: string
|
|
basicMarketCodeValue?: string
|
|
basicSourceCodeValue?: string
|
|
basicAccountRequired?: boolean
|
|
} = {}): ReservationV4OrderTaskDetailResult {
|
|
const sourceCard = createCard('card-source', 'SOURCE_MESSAGE_DISPLAY', 'READONLY', {
|
|
fields: [],
|
|
display_payload: options.sourceDisplayPayload ?? {
|
|
subject: 'Booking Request',
|
|
sender_summary: 'guest@example.test',
|
|
relevant_message_excerpt: 'Please book one twin room.',
|
|
attachments: [
|
|
{
|
|
name: 'booking.pdf',
|
|
content_type: 'application/pdf',
|
|
},
|
|
],
|
|
},
|
|
})
|
|
const basicCard = createCard('card-basic', 'BASIC_INFORMATION', options.basicCardStatus ?? 'PENDING_CONFIRM', {
|
|
version: 7,
|
|
availability: createAvailability(options.basicCardAvailability),
|
|
fields: [
|
|
createField('/basic_information/account_code', {
|
|
display_name: 'Account',
|
|
value: options.basicAccountValue ?? '',
|
|
required: options.basicAccountRequired ?? false,
|
|
options_source: 'RESERVATION_V4_ACCOUNT_CATALOG',
|
|
control_type: 'SELECT',
|
|
}),
|
|
createField('/basic_information/market_code', {
|
|
display_name: 'Market Code',
|
|
value: options.basicMarketCodeValue ?? 'LEISURE',
|
|
editable: false,
|
|
raw_readonly: true,
|
|
control_type: 'READONLY',
|
|
edit_scope: 'NEVER',
|
|
write_target: 'NONE',
|
|
control_hint: 'Market 由 Account Code 派生，前端只读展示。',
|
|
}),
|
|
createField('/basic_information/source_code', {
|
|
display_name: 'Source Code',
|
|
value: options.basicSourceCodeValue ?? 'TRAVEL_AGENT',
|
|
editable: false,
|
|
raw_readonly: true,
|
|
control_type: 'READONLY',
|
|
edit_scope: 'NEVER',
|
|
write_target: 'NONE',
|
|
control_hint: 'Source 由 Account Code 派生，前端只读展示。',
|
|
}),
|
|
createField('/basic_information/read_only_marker', {
|
|
display_name: 'Read only marker',
|
|
value: 'VISIBLE',
|
|
editable: true,
|
|
raw_readonly: true,
|
|
}),
|
|
],
|
|
})
|
|
const businessEventType = options.businessEventType ?? 'NEW_BOOKING'
|
|
const businessBookingType = options.businessBookingType ?? 'GROUP'
|
|
const businessCard = createCard('card-room', 'ROOM_INFORMATION', options.businessCardStatus ?? 'PENDING_CONFIRM', {
|
|
event_type: businessEventType,
|
|
version: 5,
|
|
availability: createAvailability({
|
|
confirmable: options.businessCardAvailability?.confirmable ?? true,
|
|
reviewable: options.businessCardAvailability?.reviewable ?? false,
|
|
}),
|
|
display_payload: options.businessDisplayPayload ?? createRoomInformationDisplayPayload({
|
|
event_type: businessEventType,
|
|
booking_type: businessBookingType,
|
|
}),
|
|
fields: options.businessFields ?? createRoomInformationFields(options.businessCardStatus === 'REVIEW_REQUIRED'),
|
|
})
|
|
return {
|
|
order_task: {
|
|
order_task_id: '9001',
|
|
hotel_id: 'HOTEL-TEST',
|
|
source_message_id: '30001',
|
|
ai_batch_id: 'batch-1',
|
|
order_ref: 'GRP-001',
|
|
order_context_index: 0,
|
|
order_id: null,
|
|
target_booking_type: 'GROUP',
|
|
target_locator_type: 'GROUP_CODE',
|
|
target_locator_value: 'GRP-001',
|
|
target_resolution_status: 'UNRESOLVED',
|
|
order_task_status: 'OPEN',
|
|
display_order_key: 'GRP-001',
|
|
source_received_at: '2026-07-08T03:00:00Z',
|
|
version: 11,
|
|
created_at: '2026-07-08T03:00:00Z',
|
|
updated_at: '2026-07-08T03:00:00Z',
|
|
},
|
|
source_message_summary: {
|
|
source_message_id: '30001',
|
|
hotel_id: 'HOTEL-TEST',
|
|
external_message_id: 'm1',
|
|
external_conversation_id: 'thread-1',
|
|
subject: 'Booking Request',
|
|
sender_summary: 'guest@example.test',
|
|
received_at: '2026-07-08T03:00:00Z',
|
|
source_sent_at: null,
|
|
conversation_message_count: 2,
|
|
},
|
|
bound_order: null,
|
|
source_message_card: sourceCard,
|
|
basic_information_card: basicCard,
|
|
business_cards: [businessCard],
|
|
card_counts: {
|
|
total_count: 3,
|
|
readonly_count: 1,
|
|
pending_confirm_count: 2,
|
|
review_required_count: options.businessCardStatus === 'REVIEW_REQUIRED' ? 1 : 0,
|
|
confirmed_count: 0,
|
|
},
|
|
adapter_contract_errors: [
|
|
{
|
|
transition_id: 'trans-1',
|
|
route_code: 'R02_NEW_GROUP_BLOCK_NORMAL',
|
|
result_type: 'ADAPTER_CONTRACT_ERROR',
|
|
adapter_error_code: 'ADAPTER_CONTRACT_ERROR',
|
|
adapter_error_message: 'Backend contract issue',
|
|
payload_fragment: null,
|
|
},
|
|
],
|
|
availability: createAvailability(),
|
|
}
|
|
}
|
|
|
|
function createSourceMessageConversationResult(options: {
|
|
sourceMessageId?: string
|
|
currentBody?: string
|
|
sanitizedHtml?: string | null
|
|
rawHtml?: string | null
|
|
htmlRenderMode?: SourceMessageConversationResult['messages'][number]['html_render_mode']
|
|
attachments?: SourceMessageOriginalMedia[]
|
|
} = {}): SourceMessageConversationResult {
|
|
const sourceMessageId = options.sourceMessageId ?? '30001'
|
|
const currentBody = options.currentBody ?? 'Current trigger email body.'
|
|
return {
|
|
conversation: {
|
|
hotel_id: 'HOTEL-TEST',
|
|
channel: 'EMAIL',
|
|
external_conversation_id: 'thread-1',
|
|
subject: 'Booking Request',
|
|
message_count: 3,
|
|
first_received_at: '2026-07-08T02:00:00Z',
|
|
last_received_at: '2026-07-08T04:00:00Z',
|
|
},
|
|
messages: [
|
|
createConversationMessage({
|
|
id: '29999',
|
|
text_body: 'OLDER_MESSAGE_BODY',
|
|
received_at: '2026-07-08T02:00:00Z',
|
|
}),
|
|
createConversationMessage({
|
|
id: sourceMessageId,
|
|
text_body: currentBody,
|
|
html_body: options.rawHtml ?? null,
|
|
html_body_sanitized: options.sanitizedHtml ?? null,
|
|
html_render_mode: options.htmlRenderMode,
|
|
received_at: '2026-07-08T03:00:00Z',
|
|
attachments: options.attachments ?? [
|
|
{
|
|
mediaType: 'ATTACHMENT',
|
|
fileName: 'current-message.pdf',
|
|
contentType: 'application/pdf',
|
|
sizeBytes: 2048,
|
|
externalUrl: 'https://oss.example/private/current-message.pdf',
|
|
externalMediaId: 'media-current',
|
|
},
|
|
],
|
|
}),
|
|
createConversationMessage({
|
|
id: '30002',
|
|
text_body: 'REPLY_MESSAGE_BODY',
|
|
received_at: '2026-07-08T04:00:00Z',
|
|
}),
|
|
],
|
|
}
|
|
}
|
|
|
|
function createConversationMessage(
|
|
overrides: Partial<SourceMessageConversationResult['messages'][number]> & { id: string },
|
|
): SourceMessageConversationResult['messages'][number] {
|
|
return {
|
|
id: overrides.id,
|
|
external_message_id: overrides.external_message_id ?? `external-${overrides.id}`,
|
|
external_conversation_id: overrides.external_conversation_id ?? 'thread-1',
|
|
sender_summary: overrides.sender_summary ?? 'guest@example.test',
|
|
subject: overrides.subject ?? 'Booking Request',
|
|
received_at: overrides.received_at ?? '2026-07-08T03:00:00Z',
|
|
source_sent_at: overrides.source_sent_at ?? null,
|
|
text_body: overrides.text_body ?? null,
|
|
html_body: overrides.html_body ?? null,
|
|
html_body_sanitized: overrides.html_body_sanitized ?? null,
|
|
html_sanitize_required: overrides.html_sanitize_required ?? false,
|
|
html_render_mode: overrides.html_render_mode ?? (overrides.html_body_sanitized ? 'SANITIZED_HTML' : 'TEXT_ONLY'),
|
|
inline_images: overrides.inline_images ?? [],
|
|
attachments: overrides.attachments ?? [],
|
|
related_orders: overrides.related_orders ?? [],
|
|
related_tasks: overrides.related_tasks ?? [],
|
|
}
|
|
}
|
|
|
|
function usePaymentBusinessCard(detail: ReservationV4OrderTaskDetailResult): void {
|
|
detail.business_cards = [
|
|
createCard('card-payment', 'PAYMENT', 'PENDING_CONFIRM', {
|
|
version: 9,
|
|
display_payload: {
|
|
payment_attachments: [
|
|
{
|
|
attachment_id: 'att-img-1',
|
|
file_name: 'voucher-image.jpg',
|
|
content_type: 'image/jpeg',
|
|
size_bytes: 123456,
|
|
is_image: true,
|
|
preview_available: true,
|
|
download_available: true,
|
|
external_media_id: 'media-payment-image',
|
|
},
|
|
{
|
|
attachment_id: 'att-pdf-1',
|
|
file_name: 'voucher-document.pdf',
|
|
content_type: 'application/pdf',
|
|
size_bytes: 2048,
|
|
is_image: false,
|
|
preview_available: false,
|
|
download_available: true,
|
|
external_media_id: 'media-payment-document',
|
|
},
|
|
{
|
|
attachment_id: 'att-missing-1',
|
|
file_name: 'missing-voucher.jpg',
|
|
content_type: 'image/jpeg',
|
|
size_bytes: 4096,
|
|
is_image: true,
|
|
preview_available: false,
|
|
download_available: false,
|
|
external_media_id: 'media-payment-missing',
|
|
unavailable_reason_code: 'MEDIA_NOT_AVAILABLE',
|
|
},
|
|
],
|
|
},
|
|
fields: [
|
|
createField('/payment/attachment_ids', {
|
|
display_name: 'attachment_ids',
|
|
value: ['att-img-1', 'att-pdf-1'],
|
|
editable: true,
|
|
raw_readonly: false,
|
|
edit_scope: 'CONFIRM',
|
|
write_target: 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
createField('/payment/payment_note', {
|
|
display_name: 'Payment Note',
|
|
value: 'Should not submit for Payment confirm.',
|
|
editable: true,
|
|
edit_scope: 'CONFIRM',
|
|
write_target: 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
],
|
|
}),
|
|
]
|
|
}
|
|
|
|
function useRoomingListBusinessCard(
|
|
detail: ReservationV4OrderTaskDetailResult,
|
|
cardStatus = 'PENDING_CONFIRM',
|
|
): void {
|
|
const isPendingConfirm = cardStatus === 'PENDING_CONFIRM'
|
|
const isReviewRequired = cardStatus === 'REVIEW_REQUIRED'
|
|
detail.business_cards = [
|
|
createCard('card-rooming-list', 'ROOMING_LIST', cardStatus, {
|
|
version: 12,
|
|
availability: createAvailability({
|
|
confirmable: isPendingConfirm,
|
|
reviewable: isReviewRequired,
|
|
editable: false,
|
|
read_only: !isPendingConfirm,
|
|
}),
|
|
display_payload: {
|
|
rows: [
|
|
{
|
|
guest_name: 'ROW_SHOULD_NOT_RENDER',
|
|
room_no: '1001',
|
|
},
|
|
],
|
|
attachment_ids: ['rooming-list-att-1'],
|
|
attachment_url: 'https://oss.example/private/rooming-list.xlsx',
|
|
ai_payload_json: 'AI_PAYLOAD_SHOULD_NOT_RENDER',
|
|
pms_import_plan: 'PMS_IMPORT_SHOULD_NOT_RENDER',
|
|
ohip_payload: 'OHIP_SHOULD_NOT_RENDER',
|
|
},
|
|
fields: [
|
|
createField('/rooming_list/rows/0/guest_name', {
|
|
display_name: 'Rooming list row',
|
|
value: 'ROW_SHOULD_NOT_RENDER',
|
|
editable: true,
|
|
edit_scope: 'CONFIRM',
|
|
write_target: 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
createField('/rooming_list/attachment_ids', {
|
|
display_name: 'attachment_ids',
|
|
value: ['rooming-list-att-1'],
|
|
editable: true,
|
|
edit_scope: 'CONFIRM',
|
|
write_target: 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
],
|
|
}),
|
|
]
|
|
detail.card_counts = {
|
|
...detail.card_counts,
|
|
pending_confirm_count: cardStatus === 'PENDING_CONFIRM' ? 2 : 1,
|
|
confirmed_count: cardStatus === 'CONFIRMED' ? 1 : 0,
|
|
}
|
|
}
|
|
|
|
function useBoundOrder(detail: ReservationV4OrderTaskDetailResult): void {
|
|
detail.bound_order = {
|
|
order_id: 'order-2001',
|
|
hotel_id: 'HOTEL-TEST',
|
|
order_status: 'ACTIVE',
|
|
temporary_order_no: null,
|
|
confirmation_number: null,
|
|
group_code: 'GRP-001',
|
|
block_code: null,
|
|
allotment_code: null,
|
|
display_name: 'GRP-001',
|
|
created_at: '2026-07-08T03:00:00Z',
|
|
updated_at: '2026-07-08T03:00:00Z',
|
|
}
|
|
}
|
|
|
|
function useTraceBusinessCard(
|
|
detail: ReservationV4OrderTaskDetailResult,
|
|
itemType: 'GENERAL' | 'EXTRA_BED',
|
|
cardStatus = 'PENDING_CONFIRM',
|
|
): void {
|
|
const isReviewRequired = cardStatus === 'REVIEW_REQUIRED'
|
|
detail.business_cards = [
|
|
createCard('card-trace', 'TRACE_RESERVATION_NOTES', cardStatus, {
|
|
event_type: 'TRACE_RESERVATION_NOTES',
|
|
version: 10,
|
|
availability: createAvailability({
|
|
confirmable: cardStatus === 'PENDING_CONFIRM',
|
|
reviewable: isReviewRequired,
|
|
editable: true,
|
|
read_only: false,
|
|
}),
|
|
display_payload: {
|
|
trace_items: [
|
|
itemType === 'EXTRA_BED'
|
|
? {
|
|
item_type: 'EXTRA_BED',
|
|
target_room_type_code: 'RM2',
|
|
extra_bed_room_count: 1,
|
|
department_code: 'FO',
|
|
content: 'CONTENT_SHOULD_NOT_RENDER',
|
|
}
|
|
: {
|
|
item_type: 'GENERAL',
|
|
text: 'Late arrival note',
|
|
department_code: 'FO',
|
|
content: 'CONTENT_SHOULD_NOT_RENDER',
|
|
},
|
|
],
|
|
target_order: 'TARGET_ORDER_SHOULD_NOT_RENDER',
|
|
ai_payload_json: 'AI_PAYLOAD_SHOULD_NOT_RENDER',
|
|
attachment_url: 'https://oss.example/private/trace.pdf',
|
|
},
|
|
fields: itemType === 'EXTRA_BED'
|
|
? [
|
|
createField('/trace_items/0/target_room_type_code', {
|
|
display_name: 'Target Room Type',
|
|
value: 'RM2',
|
|
options_source: 'RESERVATION_V4_ROOM_TYPE_CATALOG',
|
|
control_type: 'SELECT',
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
createField('/trace_items/0/extra_bed_room_count', {
|
|
display_name: 'Extra Bed Room Count',
|
|
value: 1,
|
|
control_type: 'NUMBER',
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
createTraceDepartmentField(isReviewRequired),
|
|
createField('/trace_items/0/content', {
|
|
display_name: 'Legacy content',
|
|
value: 'CONTENT_SHOULD_NOT_RENDER',
|
|
editable: true,
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
]
|
|
: [
|
|
createField('/trace_items/0/text', {
|
|
display_name: 'Trace Text',
|
|
value: 'Late arrival note',
|
|
control_type: 'TEXTAREA',
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
createTraceDepartmentField(isReviewRequired, isReviewRequired ? ['Department is required'] : []),
|
|
createField('/trace_items/0/content', {
|
|
display_name: 'Legacy content',
|
|
value: 'CONTENT_SHOULD_NOT_RENDER',
|
|
editable: true,
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
}),
|
|
],
|
|
}),
|
|
]
|
|
detail.card_counts = {
|
|
...detail.card_counts,
|
|
pending_confirm_count: cardStatus === 'PENDING_CONFIRM' ? 2 : 1,
|
|
review_required_count: isReviewRequired ? 1 : 0,
|
|
}
|
|
}
|
|
|
|
function createTraceDepartmentField(
|
|
isReviewRequired: boolean,
|
|
validationErrors: string[] = [],
|
|
): ReservationV4TaskCardResult['fields'][number] {
|
|
return createField('/trace_items/0/department_code', {
|
|
display_name: 'Department',
|
|
value: 'FO',
|
|
control_type: 'SELECT',
|
|
options_source: 'reservation_v4_trace_department_fixed',
|
|
fixed_options: [
|
|
{
|
|
value: 'FO',
|
|
label: 'FO',
|
|
},
|
|
{
|
|
value: 'HSK',
|
|
label: 'HSK',
|
|
},
|
|
{
|
|
value: 'FO+HSK',
|
|
label: 'FO+HSK',
|
|
},
|
|
],
|
|
edit_scope: isReviewRequired ? 'REVIEW' : 'CONFIRM',
|
|
write_target: isReviewRequired ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON',
|
|
validation_errors: validationErrors,
|
|
})
|
|
}
|
|
|
|
function createPaymentConversationMedia(): SourceMessageOriginalMedia[] {
|
|
return [
|
|
{
|
|
mediaType: 'ATTACHMENT',
|
|
fileName: 'voucher-image.jpg',
|
|
contentType: 'image/jpeg',
|
|
sizeBytes: 123456,
|
|
externalUrl: 'https://oss.example/private/payment-image.jpg',
|
|
externalMediaId: 'media-payment-image',
|
|
},
|
|
{
|
|
mediaType: 'ATTACHMENT',
|
|
fileName: 'voucher-document.pdf',
|
|
contentType: 'application/pdf',
|
|
sizeBytes: 2048,
|
|
externalUrl: 'https://oss.example/private/payment-document.pdf',
|
|
externalMediaId: 'media-payment-document',
|
|
},
|
|
{
|
|
mediaType: 'ATTACHMENT',
|
|
fileName: 'missing-voucher.jpg',
|
|
contentType: 'image/jpeg',
|
|
sizeBytes: 4096,
|
|
externalUrl: 'https://oss.example/private/same-file-name-should-not-match.jpg',
|
|
externalMediaId: 'media-different-same-file-name',
|
|
},
|
|
]
|
|
}
|
|
|
|
function createRoomInformationDisplayPayload(overrides: {
|
|
event_type?: string
|
|
booking_type?: string
|
|
current_values?: Record<string, unknown>
|
|
proposed_values?: Record<string, unknown>
|
|
final_values?: Record<string, unknown>
|
|
change_summary?: Array<Record<string, unknown>>
|
|
} = {}): ReservationV4TaskCardResult['display_payload'] {
|
|
const eventType = overrides.event_type ?? 'NEW_BOOKING'
|
|
const bookingType = overrides.booking_type ?? 'GROUP'
|
|
const finalValues = overrides.final_values ?? {
|
|
group_block_name: 'GRP-V4-RI-GROUP-001',
|
|
arrival_date: '2026-07-26',
|
|
departure_date: '2026-07-29',
|
|
nights: 3,
|
|
rate_code: 'GRPA2-850UP',
|
|
breakfast_included: true,
|
|
group_booking_status: 'TEN',
|
|
group_booking_status_label: 'TEN-Tentative',
|
|
room_items: [
|
|
{
|
|
room_type_code: 'RM2',
|
|
room_count: 2,
|
|
},
|
|
],
|
|
}
|
|
return {
|
|
event_type: eventType,
|
|
source_event_index: 1,
|
|
room_information: {
|
|
event_type: eventType,
|
|
booking_type: bookingType,
|
|
current_values: overrides.current_values ?? {},
|
|
proposed_values: overrides.proposed_values ?? finalValues,
|
|
final_values: finalValues,
|
|
change_summary: overrides.change_summary ?? [],
|
|
group_booking_status_options: [
|
|
{
|
|
code: 'TEN',
|
|
label: 'TEN-Tentative',
|
|
},
|
|
{
|
|
code: 'DEF',
|
|
label: 'DEF-Definite',
|
|
},
|
|
{
|
|
code: 'INQ',
|
|
label: 'INQ-Inquiry',
|
|
},
|
|
],
|
|
},
|
|
}
|
|
}
|
|
|
|
function createRoomInformationFields(reviewMode = false): ReservationV4TaskCardResult['fields'] {
|
|
const edit_scope = reviewMode ? 'MANUAL_REVIEW_ONLY' : 'CONFIRM'
|
|
const write_target = reviewMode ? 'REVIEW_RESOLUTION_FIELD_OVERRIDES' : 'CONFIRMED_PAYLOAD_JSON'
|
|
return [
|
|
createField('/room_information/final_values/group_block_name', {
|
|
display_name: 'Group Block Name',
|
|
value: 'GRP-V4-RI-GROUP-001',
|
|
required: true,
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/arrival_date', {
|
|
display_name: '入住日期',
|
|
value: '2026-07-26',
|
|
required: true,
|
|
control_type: 'DATE',
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/departure_date', {
|
|
display_name: '离店日期',
|
|
value: '2026-07-29',
|
|
required: true,
|
|
control_type: 'DATE',
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/rate_code', {
|
|
display_name: 'Rate Code',
|
|
value: 'GRPA2-850UP',
|
|
required: true,
|
|
control_type: 'SELECT',
|
|
options_source: 'RESERVATION_V4_RATE_CODE_CATALOG',
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/room_items/0/room_type_code', {
|
|
display_name: '房型代码',
|
|
value: reviewMode ? '' : 'RM2',
|
|
required: true,
|
|
control_type: 'SELECT',
|
|
options_source: 'RESERVATION_V4_ROOM_TYPE_CATALOG',
|
|
validation_errors: reviewMode ? ['房型代码不在第一版目录中。'] : [],
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/room_items/0/room_count', {
|
|
display_name: '房间数',
|
|
value: 2,
|
|
required: true,
|
|
control_type: 'NUMBER',
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
createField('/room_information/final_values/group_booking_status', {
|
|
display_name: 'Group Booking Status',
|
|
value: 'TEN',
|
|
required: true,
|
|
control_type: 'SELECT',
|
|
options_source: 'reservation_v4_group_booking_status_fixed',
|
|
editable: !reviewMode,
|
|
edit_scope,
|
|
write_target,
|
|
}),
|
|
]
|
|
}
|
|
|
|
function createSourceNotificationDetail(): ReservationV4SourceNotificationDetailResult {
|
|
return {
|
|
notification: {
|
|
notification_id: '7001',
|
|
hotel_id: 'HOTEL-TEST',
|
|
source_message_id: '30002',
|
|
ai_batch_id: 'batch-2',
|
|
ai_transition_id: 'transition-2',
|
|
route_code: 'S10',
|
|
notification_status: 'ACK_REQUIRED',
|
|
source_received_at: '2026-07-08T03:00:00Z',
|
|
ack_by: null,
|
|
ack_at: null,
|
|
version: 3,
|
|
created_at: '2026-07-08T03:00:00Z',
|
|
updated_at: '2026-07-08T03:00:00Z',
|
|
},
|
|
conversation_summary: {
|
|
source_message_id: '30002',
|
|
hotel_id: 'HOTEL-TEST',
|
|
external_message_id: 'm2',
|
|
external_conversation_id: 'thread-2',
|
|
subject: 'FYI only',
|
|
sender_summary: 'guest@example.test',
|
|
received_at: '2026-07-08T03:00:00Z',
|
|
source_sent_at: null,
|
|
conversation_message_count: 1,
|
|
},
|
|
source_message_card: createCard('card-source-notification', 'SOURCE_MESSAGE_NOTIFICATION', 'ACK_REQUIRED', {
|
|
display_payload: {
|
|
subject: 'FYI only',
|
|
relevant_message_excerpt: 'Thanks for the update.',
|
|
},
|
|
}),
|
|
availability: createAvailability({
|
|
ackable: true,
|
|
confirmable: false,
|
|
editable: false,
|
|
}),
|
|
}
|
|
}
|
|
|
|
function createCatalogLookupResult(
|
|
catalog_type: ReservationV4CatalogLookupResult['catalog_type'],
|
|
items: Array<Partial<ReservationV4CatalogLookupResult['items'][number]> & { code: string }>,
|
|
total = items.length,
|
|
pageSize = 100,
|
|
): ReservationV4CatalogLookupResult {
|
|
return {
|
|
hotel_id: 'HOTEL-TEST',
|
|
catalog_type,
|
|
catalog_source: 'SYSTEM_MANAGED',
|
|
catalog_version: 'catalog-v1',
|
|
stale: false,
|
|
items: items.map((item) => ({
|
|
code: item.code,
|
|
display_name: item.display_name ?? item.code,
|
|
status: item.status ?? 'ACTIVE',
|
|
catalog_source: item.catalog_source ?? 'SYSTEM_MANAGED',
|
|
market_code: item.market_code ?? null,
|
|
market_name: item.market_name ?? null,
|
|
source_code: item.source_code ?? null,
|
|
source_name: item.source_name ?? null,
|
|
adult_capacity: item.adult_capacity ?? null,
|
|
pricing_available: item.pricing_available ?? null,
|
|
})),
|
|
page: {
|
|
page_num: 1,
|
|
page_size: pageSize,
|
|
total,
|
|
},
|
|
warnings: [],
|
|
}
|
|
}
|
|
|
|
function createCard(
|
|
card_id: string,
|
|
card_type: string,
|
|
card_status: string,
|
|
overrides: Partial<ReservationV4TaskCardResult> = {},
|
|
): ReservationV4TaskCardResult {
|
|
return {
|
|
card_id,
|
|
card_type,
|
|
event_type: null,
|
|
source_event_index: null,
|
|
card_sort_order: null,
|
|
card_status,
|
|
review_status: null,
|
|
display_payload: overrides.display_payload ?? null,
|
|
confirmed_payload: null,
|
|
review_resolution: null,
|
|
validation_errors: null,
|
|
fields: overrides.fields ?? [],
|
|
confirmed_by: null,
|
|
confirmed_at: null,
|
|
version: overrides.version ?? 1,
|
|
created_at: '2026-07-08T03:00:00Z',
|
|
updated_at: '2026-07-08T03:00:00Z',
|
|
availability: createAvailability(overrides.availability),
|
|
}
|
|
}
|
|
|
|
function createField(
|
|
field_pointer: string,
|
|
overrides: Partial<ReservationV4TaskCardResult['fields'][number]> = {},
|
|
): ReservationV4TaskCardResult['fields'][number] {
|
|
return {
|
|
field_path: field_pointer.replace(/^\//, '').replace(/\//g, '.'),
|
|
field_pointer,
|
|
display_name: overrides.display_name ?? field_pointer,
|
|
value: overrides.value ?? '',
|
|
editable: overrides.editable ?? true,
|
|
required: overrides.required ?? false,
|
|
control_type: overrides.control_type ?? 'TEXT',
|
|
edit_scope: overrides.edit_scope ?? 'NORMAL_TASK',
|
|
write_target: overrides.write_target ?? 'CONFIRMED_PAYLOAD_JSON',
|
|
options_source: overrides.options_source ?? null,
|
|
fixed_options: overrides.fixed_options ?? null,
|
|
raw_readonly: overrides.raw_readonly ?? false,
|
|
validation_errors: overrides.validation_errors ?? [],
|
|
control_hint: overrides.control_hint ?? null,
|
|
}
|
|
}
|
|
|
|
function createAvailability(
|
|
overrides: Partial<ReservationV4TaskCardResult['availability']> = {},
|
|
): ReservationV4TaskCardResult['availability'] {
|
|
return {
|
|
blocked: overrides.blocked ?? false,
|
|
read_only: overrides.read_only ?? false,
|
|
editable: overrides.editable ?? true,
|
|
confirmable: overrides.confirmable ?? true,
|
|
reviewable: overrides.reviewable ?? false,
|
|
ackable: overrides.ackable ?? false,
|
|
readonly_reason_code: overrides.readonly_reason_code ?? null,
|
|
blocked_by_order_task_id: overrides.blocked_by_order_task_id ?? null,
|
|
blocked_by_card_id: overrides.blocked_by_card_id ?? null,
|
|
blocked_reason: overrides.blocked_reason ?? null,
|
|
}
|
|
}
|