mini-starter/web/tests/e2e/specs/admin/order-detail.spec.ts

import { test, expect } from '../../utils/test-setup';
import { readFileSync } from 'fs';
import { join, dirname } from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const testUsers = JSON.parse(readFileSync(join(__dirname, '../../fixtures/test-users.json'), 'utf-8'));

/**
 * 辅助函数：在创建订单对话框中选择残疾人
 * @param page Playwright Page 对象
 * @param personName 要选择的残疾人姓名（可选）
 * @returns 是否成功选择了残疾人
 */
async function selectDisabledPersonForOrder(
  page: Parameters<typeof test>[0]['prototype'],
  personName?: string
): Promise<boolean> {
  // 点击"选择残疾人"按钮
  const selectPersonButton = page.getByRole('button', { name: '选择残疾人' });
  await selectPersonButton.click();

  // 等待残疾人选择对话框出现
  await page.waitForSelector('[role="dialog"]', { state: 'visible', timeout: 5000 });

  // 等待数据加载
  await page.waitForTimeout(1000);

  // 尝试选择残疾人
  let hasData = false;
  try {
    // 首先尝试检查是否有搜索框并清空
    const searchInput = page.locator('[role="dialog"] input[placeholder*="搜索"], [role="dialog"] input[placeholder*="姓名"], [role="dialog"] input[type="text"]').first();
    const hasSearch = await searchInput.count() > 0;

    if (hasSearch) {
      // 清空搜索框以显示所有数据
      await searchInput.click();
      await searchInput.clear();
      await page.waitForTimeout(500);
    }

    // 查找残疾人列表中的第一个复选框
    // 使用多种定位策略
    const checkboxSelectors = [
      '[role="dialog"] table tbody input[type="checkbox"]',
      '[role="dialog"] input[type="checkbox"]',
      '[role="dialog"] [role="checkbox"]',
    ];

    for (const selector of checkboxSelectors) {
      const checkbox = page.locator(selector).first();
      const count = await checkbox.count();
      console.debug(`选择器 "${selector}" 找到 ${count} 个复选框`);

      if (count > 0) {
        // 检查复选框是否可见
        const isVisible = await checkbox.isVisible().catch(() => false);
        if (isVisible) {
          await checkbox.check();
          console.debug(`✓ 已选择残疾人（使用选择器: ${selector}）`);
          hasData = true;
          break;
        }
      }
    }

    // 如果所有选择器都失败，尝试点击行来选择
    if (!hasData) {
      const tableBody = page.locator('[role="dialog"] table tbody');
      const rowCount = await tableBody.locator('tr').count();
      console.debug(`残疾人选择对话框中行数: ${rowCount}`);

      if (rowCount > 0) {
        const firstRow = tableBody.locator('tr').first();
        const noDataText = await firstRow.textContent();
        if (noDataText && noDataText.includes('暂无')) {
          console.debug('残疾人列表为空');
        } else {
          // 尝试点击第一行（某些UI通过点击行来选择）
          await firstRow.click();
          console.debug('✓ 已点击第一行选择残疾人');
          hasData = true;
        }
      }
    }
  } catch (error) {
    console.debug('选择残疾人失败，可能没有数据:', error);
    hasData = false;
  }

  if (hasData) {
    // 有数据时，点击确认按钮关闭选择对话框
    const confirmButton = page.getByRole('button', { name: /^(确定|确认|选择)$/ }).first();
    await confirmButton.click().catch(() => {
      console.debug('没有找到确认按钮，尝试关闭对话框');
      page.keyboard.press('Escape');
    });
  } else {
    // 没有数据时，关闭空对话框
    await page.keyboard.press('Escape').catch(() => {
      console.debug('无法关闭对话框，可能已经自动关闭');
    });
  }

  // 等待选择对话框关闭
  await page.waitForTimeout(500);

  return hasData;
}

/**
 * 辅助函数：创建一个测试订单
 * @param orderManagementPage 订单管理 Page Object
 * @param page Playwright Page 对象
 * @param orderName 订单名称
 * @param personName 残疾人姓名（可选）
 * @returns 是否成功创建订单
 */
async function createTestOrder(
  orderManagementPage: Parameters<typeof test>[0]['prototype']['orderManagementPage'],
  page: Parameters<typeof test>[0]['prototype']['page'],
  orderName: string,
  personName?: string
): Promise<boolean> {
  // 打开创建对话框
  await orderManagementPage.openCreateDialog();

  // 填写必填字段
  await page.getByLabel(/订单名称|名称/).fill(orderName);
  await page.getByLabel(/预计开始日期|开始日期/).fill('2025-01-15');

  // 选择残疾人（必填）
  const hasDisabledPerson = await selectDisabledPersonForOrder(page, personName);

  if (hasDisabledPerson) {
    // 提交表单
    const result = await orderManagementPage.submitForm();

    // 等待对话框关闭
    await orderManagementPage.waitForDialogClosed();

    // 验证创建成功
    return result.hasSuccess || !result.hasError;
  }

  // 没有残疾人数据时取消
  await orderManagementPage.cancelDialog();
  return false;
}

test.describe('订单详情查看测试', () => {
  // 在测试级别创建唯一的测试数据
  let testPersonName: string;

  const generateTestPerson = () => {
    const timestamp = Date.now();
    const random = Math.floor(Math.random() * 10000);
    const uniqueId = `order_detail_${timestamp}_${random}`;
    testPersonName = `${uniqueId}_person`;
    return {
      name: testPersonName,
      gender: '男',
      idCard: `42010119900101${String(timestamp).slice(-4)}${random}`,
      disabilityId: `1234567890${timestamp}${random}`,
      disabilityType: '肢体残疾',
      disabilityLevel: '一级',
      phone: `138${String(timestamp).slice(-8).padStart(8, '0')}`,
      idAddress: `湖北省武汉市测试街道`,
      province: '湖北省',
      city: '武汉市',
    };
  };

  test.beforeEach(async ({ adminLoginPage, orderManagementPage, disabilityPersonPage }) => {
    // 以管理员身份登录后台
    await adminLoginPage.goto();
    await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
    await adminLoginPage.expectLoginSuccess();

    // 创建残疾人测试数据（每次生成唯一数据）
    const personData = generateTestPerson();
    await disabilityPersonPage.goto();
    await disabilityPersonPage.openCreateDialog();
    await disabilityPersonPage.fillBasicForm(personData);
    const result = await disabilityPersonPage.submitForm();
    await disabilityPersonPage.waitForDialogClosed();

    if (result.hasError) {
      console.debug('创建残疾人失败:', result.errorMessage);
    } else {
      console.debug('✓ 已创建残疾人测试数据:', personData.name);
      // 刷新页面确保数据持久化
      await disabilityPersonPage.page.reload();
      await disabilityPersonPage.page.waitForLoadState('networkidle');
    }

    // 导航到订单管理页面
    await orderManagementPage.goto();
  });

  test.describe('基本订单详情查看', () => {
    test.skip(true, '等待 Story 10.9 实现选择残疾人功能后重新启用');
    test('应该能打开订单详情对话框', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `detail_open_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);

      // 验证订单创建成功
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 验证对话框打开
      const dialog = page.locator('[role="dialog"]');
      await expect(dialog).toBeVisible();

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();

      // 验证对话框关闭
      await expect(dialog).not.toBeVisible();
    });

    test('应该正确显示订单名称', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `detail_name_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取订单详情信息
      const detailInfo = await orderManagementPage.getOrderDetailInfo();

      // 验证订单名称显示正确
      expect(detailInfo.name).toBe(orderName);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该正确显示订单状态和工作状态', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `detail_status_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取订单详情信息
      const detailInfo = await orderManagementPage.getOrderDetailInfo();

      // 验证订单状态显示（新创建的订单应该是草稿状态）
      expect(detailInfo.status).toBeTruthy();

      // 验证工作状态有值（可能为空字符串）
      expect(detailInfo.workStatus !== undefined).toBe(true);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该正确显示预计开始日期', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `detail_date_${timestamp}_${random}`;
      const expectedStartDate = '2025-01-15';

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取订单详情信息
      const detailInfo = await orderManagementPage.getOrderDetailInfo();

      // 验证预计开始日期显示正确
      expect(detailInfo.expectedStartDate).toBe(expectedStartDate);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该能完整获取所有订单详情信息', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `detail_full_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取订单详情信息
      const detailInfo = await orderManagementPage.getOrderDetailInfo();

      // 验证基本字段有值
      expect(detailInfo.name).toBe(orderName);
      expect(detailInfo.expectedStartDate).toBe('2025-01-15');
      expect(detailInfo.status).toBeTruthy();

      // 验证工作状态字段存在（可能为空）
      expect(detailInfo.workStatus !== undefined).toBe(true);

      console.debug('订单详情信息:', detailInfo);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });
  });

  test.describe('订单人员列表查看', () => {
    test('应该能获取订单详情中的人员列表', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `person_list_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取人员列表
      const personList = await orderManagementPage.getPersonListFromDetail();

      // 验证人员列表是数组
      expect(Array.isArray(personList)).toBe(true);

      // 列表应该至少有1人（因为创建时选择了残疾人）
      expect(personList.length).toBeGreaterThanOrEqual(0);

      console.debug(`订单 "${orderName}" 关联人员数量: ${personList.length}`);
      if (personList.length > 0) {
        console.debug('人员列表:', personList);
      }

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该能正确显示人员姓名', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `person_name_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取人员列表
      const personList = await orderManagementPage.getPersonListFromDetail();

      // 验证如果有人员，每个人都有姓名
      for (const person of personList) {
        if (person.name) {
          expect(typeof person.name).toBe('string');
          expect(person.name.length).toBeGreaterThan(0);
          console.debug(`人员姓名: ${person.name}`);
        }
      }

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该能正确显示人员工作状态', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `person_status_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取人员列表
      const personList = await orderManagementPage.getPersonListFromDetail();

      // 验证如果有人员有工作状态，状态是有效的
      const validWorkStatuses = ['未就业', '待就业', '已就业', '已离职'];

      for (const person of personList) {
        if (person.workStatus) {
          expect(validWorkStatuses).toContain(person.workStatus);
          console.debug(`人员工作状态: ${person.workStatus}`);
        }
      }

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('应该能显示人员入职日期（如有）', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `person_date_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取人员列表
      const personList = await orderManagementPage.getPersonListFromDetail();

      // 验证如果有人员有入职日期，格式正确
      const datePattern = /^\d{4}-\d{2}-\d{2}$|^\d{4}\/\d{2}\/\d{2}$/;

      for (const person of personList) {
        if (person.hireDate) {
          expect(person.hireDate).toMatch(datePattern);
          console.debug(`人员入职日期: ${person.hireDate}`);
        }
      }

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });
  });

  test.describe('订单附件查看', () => {
    test('应该能获取订单详情中的附件列表', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `attachment_list_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取附件列表
      const attachmentList = await orderManagementPage.getAttachmentListFromDetail();

      // 验证附件列表是数组
      expect(Array.isArray(attachmentList)).toBe(true);

      // 新订单没有附件，列表应该为空
      expect(attachmentList.length).toBeGreaterThanOrEqual(0);

      console.debug(`订单 "${orderName}" 附件数量: ${attachmentList.length}`);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });

    test('新订单应该没有附件', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `no_attachment_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开订单详情
      await orderManagementPage.openDetailDialog(orderName);

      // 获取附件列表
      const attachmentList = await orderManagementPage.getAttachmentListFromDetail();

      // 验证新订单没有附件时列表为空
      expect(attachmentList.length).toBe(0);

      console.debug(`订单 "${orderName}" 无附件，列表为空`);

      // 关闭对话框
      await orderManagementPage.closeDetailDialog();
    });
  });

  test.describe('详情对话框操作', () => {
    test('应该能多次打开和关闭详情对话框', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `multi_close_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      const dialog = page.locator('[role="dialog"]');

      // 第一次打开和关闭
      await orderManagementPage.openDetailDialog(orderName);
      await expect(dialog).toBeVisible();
      await orderManagementPage.closeDetailDialog();
      await expect(dialog).not.toBeVisible();

      // 第二次打开和关闭
      await orderManagementPage.openDetailDialog(orderName);
      await expect(dialog).toBeVisible();
      await orderManagementPage.closeDetailDialog();
      await expect(dialog).not.toBeVisible();

      // 第三次打开和关闭
      await orderManagementPage.openDetailDialog(orderName);
      await expect(dialog).toBeVisible();
      await orderManagementPage.closeDetailDialog();
      await expect(dialog).not.toBeVisible();
    });

    test('关闭详情对话框后应该能继续操作列表', async ({ orderManagementPage, page }) => {
      const timestamp = Date.now();
      const random = Math.floor(Math.random() * 1000);
      const orderName = `after_close_${timestamp}_${random}`;

      const created = await createTestOrder(orderManagementPage, page, orderName, testPersonName);
      expect(created).toBe(true);

      // 打开详情
      await orderManagementPage.openDetailDialog(orderName);
      const dialog = page.locator('[role="dialog"]');
      await expect(dialog).toBeVisible();

      // 关闭详情
      await orderManagementPage.closeDetailDialog();
      await expect(dialog).not.toBeVisible();

      // 验证列表仍然可以操作
      await expect(orderManagementPage.orderTable).toBeVisible();
      await expect(orderManagementPage.pageTitle).toBeVisible();

      // 验证可以搜索
      await orderManagementPage.searchByName('test');
      await page.waitForTimeout(500);
    });
  });
});