vue2server2 1.0.21

package/src/app.ts

@@ -0,0 +1,88 @@
+import "dotenv/config";
+
+import cors from "cors";
+import express, { NextFunction, Request, Response } from "express";
+import helmet from "helmet";
+import morgan from "morgan";
+import path from "node:path";
+import fs from "node:fs";
+
+import { responseMiddleware } from "./middlewares/response.middleware";
+import router from "./routes/index.route";
+import { HttpError } from "./utils/httpError";
+
+const app = express();
+
+app.set("trust proxy", true);
+
+app.use(helmet());
+app.use(cors({ origin: true }));
+app.use(express.json({ limit: "1mb" }));
+app.use(express.urlencoded({ extended: true }));
+app.use(morgan(process.env.NODE_ENV === "production" ? "combined" : "dev"));
+
+app.use(responseMiddleware);
+app.use(router);
+
+const distPublic = path.join(__dirname, "public");
+const frontDist = path.join(process.cwd(), "frontEnd", "dist");
+const staticDir = fs.existsSync(distPublic) ? distPublic : frontDist;
+if (fs.existsSync(staticDir)) {
+  app.use(express.static(staticDir));
+}
+
+// SPA fallback for non-API GET requests
+app.use((req: Request, res: Response, next: NextFunction) => {
+  if (req.method !== "GET") return next();
+  if (req.path.startsWith("/api")) return next();
+  if (fs.existsSync(path.join(staticDir, "index.html"))) {
+    res.sendFile(path.join(staticDir, "index.html"));
+    return;
+  }
+  next();
+});
+
+app.use((req: Request, res: Response) => {
+  res.status(404).json({
+    error: {
+      code: "NOT_FOUND",
+      message: `Route not found: ${req.method} ${req.path}`
+    }
+  });
+});
+
+app.use((err: unknown, _req: Request, res: Response, _next: NextFunction) => {
+  if (err instanceof HttpError) {
+    res.status(err.status).json({
+      error: {
+        code: err.code,
+        message: err.message,
+        details: err.details ?? null
+      }
+    });
+    return;
+  }
+
+  res.status(500).json({
+    error: {
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Unexpected error"
+    }
+  });
+});
+
+const PORT = normalizePort(process.env.PORT ?? "3000");
+
+if (require.main === module) {
+  app.listen(PORT, () => {
+    console.log(`服务已运行: http://localhost:${PORT}`);
+  });
+}
+
+export default app;
+
+function normalizePort(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) return 3000;
+  return parsed;
+}

package/src/controllers/health.controller.ts

@@ -0,0 +1,14 @@
+import { Request, Response } from "express";
+
+class HealthController {
+  getHealth = (_req: Request, res: Response): void => {
+    res.json({
+      status: "ok",
+      uptimeSeconds: Math.floor(process.uptime()),
+      timestamp: new Date().toISOString(),
+      env: process.env.NODE_ENV ?? "development"
+    });
+  };
+}
+
+export default new HealthController();

package/src/controllers/medal.controller.ts

@@ -0,0 +1,46 @@
+import { Request, Response, NextFunction } from "express";
+import * as medalService from "../services/medal.service";
+
+class MedalController {
+  getMedalList = async (_req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const data = await medalService.getMedalList();
+      res.json({
+        data
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  getMedalUserList = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const { medalNo } = req.query;
+      const data = await medalService.getMedalUserList(medalNo as string);
+      res.json({
+        data
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  getCandidateUserPage = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const { page, pageSize, keyword, excludeUserNos } = req.query;
+      const data = await medalService.getCandidateUserPage({
+        page,
+        pageSize,
+        keyword,
+        excludeUserNos
+      });
+      res.json({
+        data
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default new MedalController();

package/src/controllers/meeting.controller.ts

@@ -0,0 +1,29 @@
+import { Request, Response, NextFunction } from "express";
+
+import * as meetingService from "../services/meeting.service";
+
+class MeetingController {
+  getMeetingList = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const { belOrgNo, meetSubj, meetTypeCd, startDate, endDate, page, pageSize, sortField, sortOrder } = req.query;
+      const data = await meetingService.getMeetingList({
+        belOrgNo,
+        meetSubj,
+        meetTypeCd,
+        startDate,
+        endDate,
+        page,
+        pageSize,
+        sortField,
+        sortOrder
+      });
+      res.json({
+        data
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+export default new MeetingController();

package/src/controllers/mock.controller.ts

@@ -0,0 +1,64 @@
+import { Request, Response } from "express";
+
+import { buildMockUser, buildYearTrend, buildNameList } from "../services/mock.service";
+
+function toInt(value: unknown, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.floor(value);
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+class MockController {
+  getMockUser = (_req: Request, res: Response): void => {
+    res.json({
+      data: buildMockUser()
+    });
+  };
+  getNames = (req: Request, res: Response): void => {
+    const pageSize = Math.max(1, Math.min(200, toInt(req.query.size, 10)));
+    const page = Math.max(1, toInt(req.query.page, 1));
+    const start = (page - 1) * pageSize;
+    const rows = buildNameList(pageSize, start);
+    const total = 100000;
+    res.json({
+      data: {
+        total,
+        rows
+      }
+    });
+  };
+  getTrend = (req: Request, res: Response): void => {
+    const rawYear = (req.body as { year?: unknown })?.year;
+    const year = typeof rawYear === "string" ? Number.parseInt(rawYear, 10) : typeof rawYear === "number" ? rawYear : NaN;
+
+    if (!Number.isInteger(year) || year < 1970 || year > 9999) {
+      res.status(400).json({
+        code: "INVALID_YEAR",
+        message: "year必须是1970-9999之间的整数"
+      });
+      return;
+    }
+
+    const fullData = buildYearTrend(year);
+    const now = new Date();
+    const currentYear = now.getUTCFullYear();
+    if (year === currentYear) {
+      const y = currentYear;
+      //const m = String(now.getUTCMonth() + 1).padStart(2, "0");
+      const m = '02'
+      const d = String(now.getUTCDate()).padStart(2, "0");
+      const today = `${y}-${m}-${d}`;
+      console.log(today);
+      const truncated = fullData.filter((item) => item.label <= today);
+      res.json({ data: truncated });
+      return;
+    }
+
+    res.json({ data: fullData });
+  };
+}
+
+export default new MockController();

package/src/middlewares/response.middleware.ts

@@ -0,0 +1,71 @@
+import { NextFunction, Request, Response } from "express";
+
+type StandardResponse = {
+  code: number | string;
+  msg: string;
+  data: unknown;
+};
+
+function isStandardResponse(value: unknown): value is StandardResponse {
+  if (value === null || typeof value !== "object") return false;
+  return "code" in value && "msg" in value && "data" in value;
+}
+
+function extractSuccessData(body: unknown): unknown {
+  if (body === null || typeof body !== "object") return body;
+  const record = body as Record<string, unknown>;
+  const keys = Object.keys(record);
+  if (keys.length === 1 && keys[0] === "data") return record.data;
+  return body;
+}
+
+function buildErrorResponse(statusCode: number, body: unknown): StandardResponse {
+  let code: number | string = statusCode;
+  let msg = "Request failed";
+  let data: unknown = null;
+
+  if (body && typeof body === "object") {
+    const record = body as Record<string, unknown>;
+    const error = record.error && typeof record.error === "object" ? (record.error as Record<string, unknown>) : null;
+
+    const rawCode = record.code ?? error?.code;
+    if (typeof rawCode === "string" || typeof rawCode === "number") code = rawCode;
+
+    const rawMsg = record.msg ?? record.message ?? error?.message;
+    if (typeof rawMsg === "string" && rawMsg.trim().length > 0) msg = rawMsg;
+
+    if ("data" in record) data = record.data;
+    else if ("details" in record) data = record.details;
+    else if (error && "details" in error) data = error.details;
+  }
+
+  return { code, msg, data };
+}
+
+export function responseMiddleware(_req: Request, res: Response, next: NextFunction): void {
+  const originalJson = res.json.bind(res);
+  const originalSend = res.send.bind(res);
+
+  res.json = ((body: unknown) => {
+    if (isStandardResponse(body)) return originalJson(body);
+
+    if (res.statusCode >= 400) {
+      return originalJson(buildErrorResponse(res.statusCode, body));
+    }
+
+    const wrapped: StandardResponse = {
+      code: 0,
+      msg: "success",
+      data: extractSuccessData(body)
+    };
+    return originalJson(wrapped);
+  }) as Response["json"];
+
+  res.send = ((body?: unknown) => {
+    if (body && typeof body === "object") return res.json(body);
+    return originalSend(body as never);
+  }) as Response["send"];
+
+  next();
+}
+