Codex
215 lines
9.8 KiB
TypeScript
215 lines
9.8 KiB
TypeScript
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(''),
|
|
city: z.string().trim().max(64).default(''),
|
|
district: z.string().trim().max(64).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),
|
|
fullDayPriceCents: z.number().int().min(0).max(10000000).default(0),
|
|
minimumSpendCents: z.number().int().min(0).max(10000000).default(0),
|
|
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
|
|
});
|
|
}
|