feat(charge-points): add pricing mode for charge points with validation

feat(pricing): implement tariff management with peak, valley, and flat pricing
feat(api): add tariff API for fetching and updating pricing configurations
feat(tariff-schema): create database schema for tariff configuration
feat(pricing-page): create UI for displaying and managing pricing tiers
fix(sidebar): update sidebar to include pricing settings link

apps/csms/drizzle/0003_milky_supreme_intelligence.sql

@@ -0,0 +1,17 @@
+CREATE TABLE "tariff" (
+	"id" varchar PRIMARY KEY NOT NULL,
+	"slots" jsonb NOT NULL,
+	"peak_electricity_price" integer DEFAULT 0 NOT NULL,
+	"peak_service_fee" integer DEFAULT 0 NOT NULL,
+	"valley_electricity_price" integer DEFAULT 0 NOT NULL,
+	"valley_service_fee" integer DEFAULT 0 NOT NULL,
+	"flat_electricity_price" integer DEFAULT 0 NOT NULL,
+	"flat_service_fee" integer DEFAULT 0 NOT NULL,
+	"is_active" boolean DEFAULT true NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "charge_point" ADD COLUMN "pricing_mode" varchar DEFAULT 'fixed' NOT NULL;--> statement-breakpoint
+ALTER TABLE "transaction" ADD COLUMN "electricity_fee" integer;--> statement-breakpoint
+ALTER TABLE "transaction" ADD COLUMN "service_fee" integer;

apps/csms/drizzle/meta/_journal.json

@@ -22,6 +22,13 @@
       "when": 1773293422460,
       "tag": "0002_sweet_the_professor",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1773307380017,
+      "tag": "0003_milky_supreme_intelligence",
+      "breakpoints": true
     }
   ]
 }

apps/csms/src/db/ocpp-schema.ts

@@ -69,9 +69,17 @@ export const chargePoint = pgTable('charge_point', {
   /**
    * 电价（单位：分/kWh，即 0.01 CNY/kWh）
    * 交易结束时按实际用电量从储值卡扣费：fee = ceil(energyWh * feePerKwh / 1000)
-   * 默认为 0，即不计费
+   * 默认为 0，即不计费。仅在 pricingMode = 'fixed' 时生效。
    */
   feePerKwh: integer('fee_per_kwh').notNull().default(0),
+  /**
+   * 计费模式
+   * fixed = 使用本桩固定电价 feePerKwh
+   * tou   = 使用系统峰谷电价配置
+   */
+  pricingMode: varchar('pricing_mode', { enum: ['fixed', 'tou'] })
+    .notNull()
+    .default('fixed'),
   createdAt: timestamp('created_at', { withTimezone: true })
     .notNull()
     .defaultNow(),
@@ -385,6 +393,15 @@ export const transaction = pgTable(
      * null 表示未计费（如免费充电桩或交易异常终止）
      */
     chargeAmount: integer('charge_amount'),
+    /**
+     * 电费部分（单位：分）= 各时段（电价 × 用电量）之和
+     * 注：chargeAmount = electricityFee + serviceFee
+     */
+    electricityFee: integer('electricity_fee'),
+    /**
+     * 服务费部分（单位：分）= 各时段（服务费 × 用电量）之和
+     */
+    serviceFee: integer('service_fee'),
     /**
      * 关联的预约 ID（若本次充电由预约触发）
      * StartTransaction.req.reservationId（optional）

apps/csms/src/db/schema.ts

@@ -1,2 +1,4 @@
 export * from './auth-schema.ts'
 export * from './ocpp-schema.ts'
+export * from './tariff-schema.ts'
+export * from './tariff-schema.ts'

apps/csms/src/db/tariff-schema.ts

@@ -0,0 +1,58 @@
+import { pgTable, timestamp, varchar, integer, jsonb, boolean } from "drizzle-orm/pg-core";
+
+// ---------------------------------------------------------------------------
+// 峰谷电价配置 / Time-of-Use Tariff
+// ---------------------------------------------------------------------------
+
+/**
+ * 时段-电价类型映射
+ * "peak" 峰时 | "valley" 谷时 | "flat" 平时
+ */
+export type PriceTier = "peak" | "valley" | "flat";
+
+/**
+ * 电价时段（紧凑格式）
+ * start：起始小时（含，0–23）
+ * end：结束小时（不含，1–24）
+ * 示例：{ start: 8, end: 12, tier: "peak" } 表示 08:00–12:00 为峰时
+ */
+export type TariffSlot = {
+  start: number;
+  end: number;
+  tier: PriceTier;
+};
+
+/**
+ * 峰谷电价配置表（单例，通过 isActive 标记当前生效的版本）
+ *
+ * 价格以整数"分"存储（1 分 = 0.01 CNY），精度 0.01 元/kWh：
+ *   fen = Math.round(CNY * 100)
+ *   CNY = fen / 100
+ *
+ * 时段列表存储为 JSONB（TariffSlot[]）。
+ * 若无任何 isActive=true 的记录，计费逻辑将回退到 chargePoint.feePerKwh 平均电价。
+ */
+export const tariff = pgTable("tariff", {
+  id: varchar("id").primaryKey(),
+  /** 24 小时时段列表（紧凑格式，TariffSlot[]） */
+  slots: jsonb("slots").notNull().$type<TariffSlot[]>(),
+  /** 峰时电价（分/kWh） */
+  peakElectricityPrice: integer("peak_electricity_price").notNull().default(0),
+  /** 峰时服务费（分/kWh） */
+  peakServiceFee: integer("peak_service_fee").notNull().default(0),
+  /** 谷时电价（分/kWh） */
+  valleyElectricityPrice: integer("valley_electricity_price").notNull().default(0),
+  /** 谷时服务费（分/kWh） */
+  valleyServiceFee: integer("valley_service_fee").notNull().default(0),
+  /** 平时电价（分/kWh） */
+  flatElectricityPrice: integer("flat_electricity_price").notNull().default(0),
+  /** 平时服务费（分/kWh） */
+  flatServiceFee: integer("flat_service_fee").notNull().default(0),
+  /** 是否为当前生效配置（同时只允许一条 isActive=true） */
+  isActive: boolean("is_active").notNull().default(true),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true })
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => new Date()),
+});

apps/csms/src/index.ts

@@ -15,6 +15,7 @@ import transactionRoutes from './routes/transactions.ts'
 import idTagRoutes from './routes/id-tags.ts'
 import userRoutes from './routes/users.ts'
 import setupRoutes from './routes/setup.ts'
+import tariffRoutes from './routes/tariff.ts'
 
 import type { HonoEnv } from './types/hono.ts'
 
@@ -41,7 +42,7 @@ app.use(
   '/api/*',
   cors({
     origin: process.env.WEB_ORIGIN ?? '*',
-    allowMethods: ['GET', 'POST', 'PATCH', 'DELETE', 'OPTIONS'],
+    allowMethods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
     allowHeaders: ['Content-Type', 'Authorization'],
     exposeHeaders: ['Content-Length'],
     credentials: true,
@@ -58,6 +59,7 @@ app.route('/api/transactions', transactionRoutes)
 app.route('/api/id-tags', idTagRoutes)
 app.route('/api/users', userRoutes)
 app.route('/api/setup', setupRoutes)
+app.route('/api/tariff', tariffRoutes)
 
 app.get('/api', (c) => {
   const user = c.get('user')

apps/csms/src/ocpp/actions/stop-transaction.ts

@@ -1,7 +1,10 @@
-import { eq, sql } from "drizzle-orm";
+import { asc, eq, sql } from "drizzle-orm";
 import dayjs from "dayjs";
 import { useDrizzle } from "@/lib/db.js";
 import { chargePoint, connector, idTag, meterValue, transaction } from "@/db/schema.js";
+import { tariff } from "@/db/schema.js";
+import type { SampledValue } from "@/db/schema.js";
+import type { TariffSlot, PriceTier } from "@/db/tariff-schema.ts";
 import type {
   StopTransactionRequest,
   StopTransactionResponse,
@@ -64,20 +67,103 @@ export async function handleStopTransaction(
 
   const energyWh = payload.meterStop - tx.startMeterValue;
 
-  // Deduct balance from the idTag based on actual energy consumed
+  // Load active tariff and charge point fee
   const [cp] = await db
-    .select({ feePerKwh: chargePoint.feePerKwh })
+    .select({ feePerKwh: chargePoint.feePerKwh, pricingMode: chargePoint.pricingMode })
     .from(chargePoint)
     .where(eq(chargePoint.id, tx.chargePointId))
     .limit(1);
 
-  const feeFen =
-    cp && cp.feePerKwh > 0 && energyWh > 0 ? Math.ceil((energyWh * cp.feePerKwh) / 1000) : 0;
+  const [activeTariff] = await db.select().from(tariff).where(eq(tariff.isActive, true)).limit(1);
+
+  let electricityFen: number | null = null;
+  let serviceFeeFen: number | null = null;
+  let feeFen = 0;
+
+  if (activeTariff && cp?.pricingMode === 'tou' && energyWh > 0 && tx.startTimestamp) {
+    const stopTs = dayjs(payload.timestamp).toDate();
+    const slots = activeTariff.slots as TariffSlot[];
+
+    const priceMap: Record<PriceTier, { electricity: number; service: number }> = {
+      peak: {
+        electricity: activeTariff.peakElectricityPrice,
+        service: activeTariff.peakServiceFee,
+      },
+      valley: {
+        electricity: activeTariff.valleyElectricityPrice,
+        service: activeTariff.valleyServiceFee,
+      },
+      flat: {
+        electricity: activeTariff.flatElectricityPrice,
+        service: activeTariff.flatServiceFee,
+      },
+    };
+
+    // Build checkpoints from intermediate meter value readings.
+    // Each checkpoint is (timestamp, cumulativeWh), sorted ascending.
+    // Using actual intermediate readings lets each interval's known energy delta
+    // be assigned to its true time slot rather than assuming uniform charging rate.
+    const intervalReadings = await db
+      .select({ timestamp: meterValue.timestamp, sampledValues: meterValue.sampledValues })
+      .from(meterValue)
+      .where(eq(meterValue.transactionId, tx.id))
+      .orderBy(asc(meterValue.timestamp));
+
+    const checkpoints: { ts: Date; wh: number }[] = [
+      { ts: tx.startTimestamp, wh: tx.startMeterValue },
+    ];
+    for (const mv of intervalReadings) {
+      const svList = mv.sampledValues as SampledValue[];
+      // Per OCPP 1.6 §7.17: absent measurand defaults to Energy.Active.Import.Register
+      const energySv = svList.find(
+        (sv) => (!sv.measurand || sv.measurand === "Energy.Active.Import.Register") && !sv.phase,
+      );
+      if (!energySv) continue;
+      const rawVal = parseFloat(energySv.value);
+      if (isNaN(rawVal)) continue;
+      const wh = (energySv.unit ?? "Wh") === "kWh" ? rawVal * 1000 : rawVal;
+      checkpoints.push({ ts: mv.timestamp, wh });
+    }
+    checkpoints.push({ ts: stopTs, wh: payload.meterStop });
+
+    // For each interval, compute actual energy delta and distribute across tiers
+    // by walking minute-by-minute only within that interval.
+    const tierEnergyWh: Record<PriceTier, number> = { peak: 0, valley: 0, flat: 0 };
+    for (let i = 0; i + 1 < checkpoints.length; i++) {
+      const { ts: t1, wh: wh1 } = checkpoints[i];
+      const { ts: t2, wh: wh2 } = checkpoints[i + 1];
+      const deltaWh = Math.max(0, wh2 - wh1);
+      if (deltaWh === 0) continue;
+      const fractions = calcTierFractions(t1, t2, slots);
+      for (const tier of ["peak", "valley", "flat"] as PriceTier[]) {
+        tierEnergyWh[tier] += deltaWh * fractions[tier];
+      }
+    }
+
+    let elecFen = 0;
+    let svcFen = 0;
+    for (const tier of ["peak", "valley", "flat"] as PriceTier[]) {
+      const energyKwh = tierEnergyWh[tier] / 1000;
+      elecFen += energyKwh * priceMap[tier].electricity;
+      svcFen += energyKwh * priceMap[tier].service;
+    }
+    electricityFen = Math.ceil(elecFen);
+    serviceFeeFen = Math.ceil(svcFen);
+    feeFen = electricityFen + serviceFeeFen;
+  } else if (cp && cp.feePerKwh > 0 && energyWh > 0) {
+    // Fallback: flat rate per charge point
+    feeFen = Math.ceil((energyWh * cp.feePerKwh) / 1000);
+  }
 
   // Always record the charge amount (0 if free)
   await db
     .update(transaction)
-    .set({ chargeAmount: feeFen, updatedAt: dayjs().toDate() })
+    .set({
+      chargeAmount: feeFen,
+      electricityFee: electricityFen,
+      serviceFee: serviceFeeFen,
+      updatedAt: dayjs().toDate(),
+    })
     .where(eq(transaction.id, tx.id));
 
   if (feeFen > 0) {
@@ -92,7 +178,8 @@ export async function handleStopTransaction(
 
   console.log(
     `[OCPP] StopTransaction txId=${payload.transactionId} ` +
-      `reason=${payload.reason ?? "none"} energyWh=${energyWh} feeFen=${feeFen}`,
+      `reason=${payload.reason ?? "none"} energyWh=${energyWh} ` +
+      `feeFen=${feeFen} (elec=${electricityFen ?? "flat"} svc=${serviceFeeFen ?? "-"})`,
   );
 
   // Resolve idTagInfo for the stop tag if provided (no balance check — charging already occurred)
@@ -100,3 +187,48 @@ export async function handleStopTransaction(
 
   return { idTagInfo };
 }
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Given a charging session's start/stop timestamps and the active tariff slots,
+ * returns the fraction of total session duration spent in each price tier.
+ * Fractions sum to 1.0.
+ *
+ * Strategy: walk minute-by-minute over the session and bucket each minute into
+ * its tier. Using minutes keeps the implementation simple and introduces at most
+ * 1 minute of rounding error (negligible for billing amounts in fen).
+ */
+function calcTierFractions(
+  start: Date,
+  stop: Date,
+  slots: TariffSlot[],
+): Record<PriceTier, number> {
+  const totals: Record<PriceTier, number> = { peak: 0, valley: 0, flat: 0 };
+
+  // Build a 24-element hour → tier lookup
+  const hourTier: PriceTier[] = [];
+  for (let i = 0; i < 24; i++) hourTier.push("flat");
+  for (const slot of slots) {
+    for (let h = slot.start; h < slot.end; h++) {
+      hourTier[h] = slot.tier;
+    }
+  }
+
+  const startMs = start.getTime();
+  const stopMs = stop.getTime();
+  const totalMinutes = Math.max(1, Math.round((stopMs - startMs) / 60_000));
+
+  for (let m = 0; m < totalMinutes; m++) {
+    const t = new Date(startMs + m * 60_000);
+    // 北京时间 = UTC + 8h，峰谷时段以北京时间为准
+    const hourBeijing = Math.floor((t.getUTCHours() * 60 + t.getUTCMinutes() + 480) / 60) % 24;
+    totals[hourTier[hourBeijing]]++;
+  }
+
+  return {
+    peak: totals.peak / totalMinutes,
+    valley: totals.valley / totalMinutes,
+    flat: totals.flat / totalMinutes,
+  };
+}

apps/csms/src/routes/charge-points.ts

@@ -69,6 +69,7 @@ app.post("/", async (c) => {
     chargePointModel?: string;
     registrationStatus?: "Accepted" | "Pending" | "Rejected";
     feePerKwh?: number;
+    pricingMode?: "fixed" | "tou";
   }>();
 
   if (!body.chargePointIdentifier?.trim()) {
@@ -77,6 +78,9 @@ app.post("/", async (c) => {
   if (body.feePerKwh !== undefined && (!Number.isInteger(body.feePerKwh) || body.feePerKwh < 0)) {
     return c.json({ error: "feePerKwh must be a non-negative integer" }, 400);
   }
+  if (body.pricingMode !== undefined && !['fixed', 'tou'].includes(body.pricingMode)) {
+    return c.json({ error: "pricingMode must be 'fixed' or 'tou'" }, 400);
+  }
 
   const [created] = await db
     .insert(chargePoint)
@@ -87,6 +91,7 @@ app.post("/", async (c) => {
       chargePointModel: body.chargePointModel?.trim() || "Unknown",
       registrationStatus: body.registrationStatus ?? "Pending",
       feePerKwh: body.feePerKwh ?? 0,
+      pricingMode: body.pricingMode ?? "fixed",
     })
     .returning()
     .catch((err: Error) => {
@@ -125,6 +130,7 @@ app.patch("/:id", async (c) => {
   const id = c.req.param("id");
   const body = await c.req.json<{
     feePerKwh?: number;
+    pricingMode?: "fixed" | "tou";
     registrationStatus?: string;
     chargePointVendor?: string;
     chargePointModel?: string;
@@ -132,6 +138,7 @@ app.patch("/:id", async (c) => {
 
   const set: {
     feePerKwh?: number;
+    pricingMode?: "fixed" | "tou";
     registrationStatus?: "Accepted" | "Pending" | "Rejected";
     chargePointVendor?: string;
     chargePointModel?: string;
@@ -152,6 +159,12 @@ app.patch("/:id", async (c) => {
   }
   if (body.chargePointVendor !== undefined) set.chargePointVendor = body.chargePointVendor.trim() || "Unknown";
   if (body.chargePointModel !== undefined) set.chargePointModel = body.chargePointModel.trim() || "Unknown";
+  if (body.pricingMode !== undefined) {
+    if (!['fixed', 'tou'].includes(body.pricingMode)) {
+      return c.json({ error: "pricingMode must be 'fixed' or 'tou'" }, 400);
+    }
+    set.pricingMode = body.pricingMode;
+  }
 
   const [updated] = await db
     .update(chargePoint)

apps/csms/src/routes/tariff.ts

@@ -0,0 +1,98 @@
+import { Hono } from "hono";
+import { eq } from "drizzle-orm";
+import { useDrizzle } from "@/lib/db.js";
+import { tariff } from "@/db/schema.js";
+import type { HonoEnv } from "@/types/hono.ts";
+import type { PriceTier, TariffSlot } from "@/db/tariff-schema.ts";
+
+const app = new Hono<HonoEnv>();
+
+/** GET /api/tariff  —  返回当前生效的电价配置（任何已登录用户） */
+app.get("/", async (c) => {
+  const db = useDrizzle();
+  const [row] = await db.select().from(tariff).where(eq(tariff.isActive, true)).limit(1);
+
+  if (!row) return c.json(null);
+
+  return c.json(rowToPayload(row));
+});
+
+/** PUT /api/tariff  —  更新/初始化电价配置（仅管理员） */
+app.put("/", async (c) => {
+  const currentUser = c.get("user");
+  if (currentUser?.role !== "admin") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+
+  type TierPricing = { electricityPrice: number; serviceFee: number };
+  type TariffBody = {
+    slots: TariffSlot[];
+    prices: Record<PriceTier, TierPricing>;
+  };
+
+  let body: TariffBody;
+  try {
+    body = await c.req.json<TariffBody>();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+
+  const { slots, prices } = body;
+  if (!Array.isArray(slots) || !prices) {
+    return c.json({ error: "Missing slots or prices" }, 400);
+  }
+
+  const db = useDrizzle();
+
+  // 停用旧配置
+  await db.update(tariff).set({ isActive: false });
+
+  const [row] = await db
+    .insert(tariff)
+    .values({
+      id: crypto.randomUUID(),
+      slots,
+      peakElectricityPrice: fenFromCny(prices.peak?.electricityPrice),
+      peakServiceFee: fenFromCny(prices.peak?.serviceFee),
+      valleyElectricityPrice: fenFromCny(prices.valley?.electricityPrice),
+      valleyServiceFee: fenFromCny(prices.valley?.serviceFee),
+      flatElectricityPrice: fenFromCny(prices.flat?.electricityPrice),
+      flatServiceFee: fenFromCny(prices.flat?.serviceFee),
+      isActive: true,
+    })
+    .returning();
+
+  return c.json(rowToPayload(row));
+});
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function fenFromCny(cny: number | undefined): number {
+  if (typeof cny !== "number" || isNaN(cny)) return 0;
+  return Math.round(cny * 100);
+}
+
+function rowToPayload(row: typeof tariff.$inferSelect) {
+  return {
+    id: row.id,
+    slots: row.slots as TariffSlot[],
+    prices: {
+      peak: {
+        electricityPrice: row.peakElectricityPrice / 100,
+        serviceFee: row.peakServiceFee / 100,
+      },
+      valley: {
+        electricityPrice: row.valleyElectricityPrice / 100,
+        serviceFee: row.valleyServiceFee / 100,
+      },
+      flat: {
+        electricityPrice: row.flatElectricityPrice / 100,
+        serviceFee: row.flatServiceFee / 100,
+      },
+    },
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export default app;