feat(M03-A): 完成门店与房间基础管理

2026-06-18 14:55:04 +08:00
parent 47094d5309
commit 15139b3962
17 changed files with 1013 additions and 13 deletions
@@ -0,0 +1,210 @@
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import { z } from 'zod';
+import type { AuthRepository } from '../auth/auth-repository.js';
+import { authenticateAccessToken } from '../auth/authenticate.js';
+import type { AccessProfile } from '../auth/rbac-repository.js';
+import type { ManagementActor } from '../auth/user-management-repository.js';
+import {
+  StoreRoomError,
+  type StoreRoomRepository
+} from '../stores/store-room-repository.js';
+
+const idSchema = z.object({ id: z.string().regex(/^[1-9]\d{0,19}$/) });
+const storeIdSchema = z.object({ storeId: z.string().regex(/^[1-9]\d{0,19}$/) });
+const coordinate = z.number().finite();
+const hoursSchema = z.array(z.object({
+  weekday: z.number().int().min(1).max(7),
+  openMinute: z.number().int().min(0).max(1439),
+  closeMinute: z.number().int().min(0).max(1439),
+  isClosed: z.boolean().default(false)
+})).max(7).refine((items) => new Set(items.map((item) => item.weekday)).size === items.length);
+const storeSchema = z.object({
+  name: z.string().trim().min(1).max(128),
+  address: z.string().trim().max(255).default(''),
+  longitude: coordinate.min(-180).max(180).nullable().optional(),
+  latitude: coordinate.min(-90).max(90).nullable().optional(),
+  contactPhone: z.string().trim().max(32).default(''),
+  timezone: z.string().trim().min(1).max(64).default('Asia/Shanghai'),
+  businessStatus: z.enum(['OPEN', 'CLOSED', 'SUSPENDED']).default('OPEN'),
+  wifiSsid: z.string().trim().max(128).default(''),
+  wifiPassword: z.string().max(255).default(''),
+  notificationUrl: z.union([z.string().url(), z.literal('')]).default(''),
+  sortOrder: z.number().int().min(-100000).max(100000).default(0),
+  businessHours: hoursSchema.default([])
+});
+const roomSchema = z.object({
+  storeId: z.string().regex(/^[1-9]\d{0,19}$/),
+  categoryName: z.string().trim().min(1).max(128),
+  name: z.string().trim().min(1).max(128),
+  roomNo: z.string().trim().min(1).max(64),
+  capacity: z.number().int().min(1).max(100),
+  basePriceCents: z.number().int().min(0).max(10000000),
+  weekdayPriceCents: z.number().int().min(0).max(10000000),
+  holidayPriceCents: z.number().int().min(0).max(10000000),
+  overnightPriceCents: z.number().int().min(0).max(10000000),
+  depositCents: z.number().int().min(0).max(10000000),
+  minimumMinutes: z.number().int().min(15).max(1440),
+  maxAdvanceStartMinutes: z.number().int().min(0).max(1440),
+  maxAdvanceDays: z.number().int().min(0).max(365),
+  configurationStatus: z.enum(['ENABLED', 'DISABLED']),
+  operationalStatus: z.enum([
+    'AVAILABLE', 'MAINTENANCE', 'RESERVED', 'IN_USE', 'CLEANING_REQUIRED'
+  ]),
+  tags: z.array(z.string().trim().min(1).max(32)).max(20).default([]),
+  images: z.array(z.string().url()).max(20).default([]),
+  sortOrder: z.number().int().min(-100000).max(100000).default(0)
+});
+const disabledPeriodSchema = z.object({
+  storeId: z.string().regex(/^[1-9]\d{0,19}$/),
+  startsAt: z.coerce.date(),
+  endsAt: z.coerce.date(),
+  reason: z.string().trim().max(255).default('')
+}).refine((value) => value.endsAt > value.startsAt);
+
+export interface StoreRoomRouteOptions {
+  repository: Pick<StoreRoomRepository,
+    'listStores' | 'createStore' | 'updateStore' | 'archiveStore' | 'listRooms'
+    | 'createRoom' | 'updateRoom' | 'archiveRoom' | 'addDisabledPeriod'>;
+  authRepository: Pick<AuthRepository, 'validateSession'>;
+  accessControl: { getAccessProfile(tenantId: string, userId: string): Promise<AccessProfile> };
+  jwtSecret: string;
+}
+
+export async function registerStoreRoomRoutes(app: FastifyInstance, options: StoreRoomRouteOptions) {
+  app.get('/admin-api/stores', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    if (!actor) return;
+    return { code: 0, data: await options.repository.listStores(actor), traceId: request.traceId };
+  });
+  app.post('/admin-api/stores', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const body = storeSchema.safeParse(request.body);
+    if (!actor || !body.success) return actor ? invalid(reply, request.traceId) : undefined;
+    return mutate(reply, request.traceId, async () => reply.status(201).send({
+      code: 0, data: await options.repository.createStore(actor, body.data),
+      traceId: request.traceId
+    }));
+  });
+  app.put('/admin-api/stores/:id', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = idSchema.safeParse(request.params);
+    const body = storeSchema.safeParse(request.body);
+    if (!actor || !params.success || !body.success) {
+      return actor ? invalid(reply, request.traceId) : undefined;
+    }
+    return mutate(reply, request.traceId, async () => ({
+      code: 0, data: await options.repository.updateStore(actor, params.data.id, body.data),
+      traceId: request.traceId
+    }));
+  });
+  app.delete('/admin-api/stores/:id', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = idSchema.safeParse(request.params);
+    if (!actor || !params.success) return actor ? invalid(reply, request.traceId) : undefined;
+    return mutate(reply, request.traceId, async () => ({
+      code: 0, data: await options.repository.archiveStore(actor, params.data.id),
+      traceId: request.traceId
+    }));
+  });
+  app.get('/admin-api/stores/:storeId/rooms', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = storeIdSchema.safeParse(request.params);
+    if (!actor || !params.success) return actor ? invalid(reply, request.traceId) : undefined;
+    return mutate(reply, request.traceId, async () => ({
+      code: 0, data: await options.repository.listRooms(actor, params.data.storeId),
+      traceId: request.traceId
+    }));
+  });
+  app.post('/admin-api/rooms', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const body = roomSchema.safeParse(request.body);
+    if (!actor || !body.success) return actor ? invalid(reply, request.traceId) : undefined;
+    return mutate(reply, request.traceId, async () => reply.status(201).send({
+      code: 0, data: await options.repository.createRoom(actor, body.data),
+      traceId: request.traceId
+    }));
+  });
+  app.put('/admin-api/rooms/:id', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = idSchema.safeParse(request.params);
+    const body = roomSchema.safeParse(request.body);
+    if (!actor || !params.success || !body.success) {
+      return actor ? invalid(reply, request.traceId) : undefined;
+    }
+    return mutate(reply, request.traceId, async () => ({
+      code: 0, data: await options.repository.updateRoom(actor, params.data.id, body.data),
+      traceId: request.traceId
+    }));
+  });
+  app.delete('/admin-api/rooms/:id', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = idSchema.safeParse(request.params);
+    const query = storeIdSchema.safeParse(request.query);
+    if (!actor || !params.success || !query.success) {
+      return actor ? invalid(reply, request.traceId) : undefined;
+    }
+    return mutate(reply, request.traceId, async () => ({
+      code: 0,
+      data: await options.repository.archiveRoom(actor, params.data.id, query.data.storeId),
+      traceId: request.traceId
+    }));
+  });
+  app.post('/admin-api/rooms/:id/disabled-periods', async (request, reply) => {
+    const actor = await requireOperator(request, reply, options);
+    const params = idSchema.safeParse(request.params);
+    const body = disabledPeriodSchema.safeParse(request.body);
+    if (!actor || !params.success || !body.success) {
+      return actor ? invalid(reply, request.traceId) : undefined;
+    }
+    return mutate(reply, request.traceId, async () => reply.status(201).send({
+      code: 0,
+      data: await options.repository.addDisabledPeriod(actor, params.data.id, body.data),
+      traceId: request.traceId
+    }));
+  });
+}
+
+async function requireOperator(
+  request: FastifyRequest, reply: FastifyReply, options: StoreRoomRouteOptions
+): Promise<ManagementActor | null> {
+  const auth = await authenticateAccessToken(
+    request.headers.authorization, options.authRepository, options.jwtSecret
+  );
+  if (!auth) {
+    reply.status(401).send({ code: 'AUTH_SESSION_INVALID', message: 'Authentication required.',
+      traceId: request.traceId });
+    return null;
+  }
+  const access = await options.accessControl.getAccessProfile(
+    auth.session.tenantId, auth.session.user.id
+  );
+  if (!access.capabilities.some((code) =>
+    code === 'store.operation.read' || code === 'store.operation.write' || code === 'tenant.manage'
+  ) && !access.roles.includes('PLATFORM_ADMIN')) {
+    reply.status(403).send({ code: 'STORE_OPERATION_FORBIDDEN',
+      message: 'Store operation permission is required.', traceId: request.traceId });
+    return null;
+  }
+  return {
+    tenantId: auth.session.tenantId, userId: auth.session.user.id, access,
+    traceId: request.traceId, ip: request.ip, userAgent: request.headers['user-agent'] ?? ''
+  };
+}
+
+async function mutate(reply: FastifyReply, traceId: string, work: () => Promise<unknown>) {
+  try {
+    return await work();
+  } catch (error) {
+    if (!(error instanceof StoreRoomError)) throw error;
+    const forbidden = error.code.endsWith('_FORBIDDEN');
+    return reply.status(forbidden ? 403 : 404).send({
+      code: error.code, message: 'The store or room operation is not allowed.', traceId
+    });
+  }
+}
+
+function invalid(reply: FastifyReply, traceId: string) {
+  return reply.status(400).send({
+    code: 'INVALID_STORE_ROOM_REQUEST', message: 'The store or room request is invalid.', traceId
+  });
+}