perf: 支持约课以及消息推送能力

packages/app/src/components/BookingConfirmPopup.vue

@@ -105,13 +105,13 @@
         <view class="btn-outline" @tap="handleCancel">
           <text class="btn-outline-text">取消</text>
         </view>
-        <view
+        <button
           class="btn-confirm"
           :class="{ disabled: !selectedMembershipId }"
           @tap="handleConfirm"
         >
           <text class="btn-confirm-text">确认预约</text>
-        </view>
+        </button>
       </view>
     </view>
   </view>
@@ -120,6 +120,7 @@
 <script setup lang="ts">
 import { ref, computed, watch } from 'vue'
 import type { TimeSlotWithBookingStatus, MembershipWithCardType } from '@mp-pilates/shared'
+import { requestBookingCreatedSubscriptionMessage } from '../utils/wechat-subscription'
 
 const props = defineProps<{
   visible: boolean
@@ -134,6 +135,7 @@ const emit = defineEmits<{
 }>()
 
 const selectedMembershipId = ref<string>('')
+const requestingSubscribe = ref(false)
 
 // Auto-select the first membership when popup opens or memberships list changes
 watch(
@@ -150,8 +152,22 @@ const selectedMembership = computed(() =>
   props.memberships.find((m) => m.id === selectedMembershipId.value) ?? null,
 )
 
-function handleConfirm() {
+async function handleConfirm() {
   if (!props.timeSlot || !selectedMembershipId.value) return
+
+  if (requestingSubscribe.value) return
+  requestingSubscribe.value = true
+
+  try {
+    await requestBookingCreatedSubscriptionMessage()
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : '订阅消息授权失败'
+    uni.showToast({ title: message, icon: 'none' })
+    return
+  } finally {
+    requestingSubscribe.value = false
+  }
+
   emit('confirm', {
     timeSlotId: props.timeSlot.id,
     membershipId: selectedMembershipId.value,

packages/app/src/components/QuickEntry.vue

@@ -58,6 +58,7 @@
 import { computed, ref } from 'vue'
 import { useUserStore } from '../stores/user'
 import { CardTypeCategory } from '@mp-pilates/shared'
+import { getErrorMessage } from '../utils/auth'
 
 const emit = defineEmits<{
   (e: 'scroll-to-card-shop'): void
@@ -71,8 +72,8 @@ async function handleLogin() {
   loading.value = true
   try {
     await userStore.loginWithSetup()
-  } catch {
+  } catch (err: unknown) {
-    uni.showToast({ title: '登录失败，请重试', icon: 'none' })
+    uni.showToast({ title: getErrorMessage(err, '登录失败，请重试'), icon: 'none' })
   } finally {
     loading.value = false
   }

packages/app/src/pages/booking/detail.vue

@@ -239,6 +239,7 @@ import type {
 import { BookingStatus, TimeSlotStatus } from '@mp-pilates/shared'
 import { useBookingStore } from '../../stores/booking'
 import { useUserStore } from '../../stores/user'
+import { getErrorMessage } from '../../utils/auth'
 import { getSystemLayout } from '../../utils/system'
 import { isSlotPast } from '../../utils/format'
 import {
@@ -357,8 +358,8 @@ async function handleSlotBook() {
             if (!isNewUser) {
               handleSlotBook()
             }
-          } catch {
+          } catch (err: unknown) {
-            uni.showToast({ title: '登录失败', icon: 'none' })
+            uni.showToast({ title: getErrorMessage(err, '登录失败'), icon: 'none' })
           }
         }
       },

packages/app/src/pages/booking/index.vue

@@ -87,6 +87,7 @@ import type { TimeSlotWithBookingStatus, MembershipWithCardType } from '@mp-pila
 import { TIME_PERIODS } from '@mp-pilates/shared'
 import { useBookingStore } from '../../stores/booking'
 import { useUserStore } from '../../stores/user'
+import { getErrorMessage } from '../../utils/auth'
 import { formatDate } from '../../utils/format'
 import { getSystemLayout } from '../../utils/system'
 import DateSelector from '../../components/DateSelector.vue'
@@ -208,8 +209,8 @@ async function onBookTap(slot: TimeSlotWithBookingStatus) {
             if (!isNewUser) {
               onBookTap(slot)
             }
-          } catch {
+          } catch (err: unknown) {
-            uni.showToast({ title: '登录失败', icon: 'none' })
+            uni.showToast({ title: getErrorMessage(err, '登录失败'), icon: 'none' })
           }
         }
       },

packages/app/src/pages/card/detail.vue

@@ -182,10 +182,12 @@
 import { ref, computed, onMounted } from 'vue'
 import type { CardType, CreateOrderResponse } from '@mp-pilates/shared'
 import { CardTypeCategory } from '@mp-pilates/shared'
+import { getErrorMessage } from '../../utils/auth'
 import { get, post } from '../../utils/request'
 import { formatPrice, getCardTypeLabel, getCardCoverClass } from '../../utils/format'
 import { getSystemLayout } from '../../utils/system'
 import { useUserStore } from '../../stores/user'
+import { requestOrderPaidSubscriptionMessage } from '../../utils/wechat-subscription'
 import CustomNavBar from '../../components/CustomNavBar.vue'
 
 const userStore = useUserStore()
@@ -287,8 +289,8 @@ async function handleBuy() {
             if (!isNewUser) {
               handleBuy()
             }
-          } catch {
+          } catch (err: unknown) {
-            uni.showToast({ title: '登录失败', icon: 'none' })
+            uni.showToast({ title: getErrorMessage(err, '登录失败'), icon: 'none' })
           }
         }
       },
@@ -334,6 +336,7 @@ async function doPurchase() {
     })
 
     // Payment succeeded — refresh memberships then navigate
+    await requestOrderPaidSubscriptionMessage().catch(() => undefined)
     uni.showToast({ title: '购买成功！', icon: 'success' })
     await userStore.fetchMemberships()
     setTimeout(() => {

packages/app/src/pages/flash-sale/detail.vue

@@ -208,12 +208,14 @@ import {
   FlashSaleOrderStatus,
 } from '@mp-pilates/shared'
 import type { FlashSaleDetail } from '@mp-pilates/shared'
+import { getErrorMessage } from '../../utils/auth'
 import { formatPrice, getFlashSalePhaseLabel, getCountdownParts, getStockRatio, getStockPercent } from '../../utils/format'
 import { getSystemLayout } from '../../utils/system'
 import { useUserStore } from '../../stores/user'
 import { useFlashSaleStore } from '../../stores/flash-sale'
 import CustomNavBar from '../../components/CustomNavBar.vue'
 import { post } from '../../utils/request'
+import { requestOrderPaidSubscriptionMessage } from '../../utils/wechat-subscription'
 
 const userStore = useUserStore()
 const flashSaleStore = useFlashSaleStore()
@@ -343,8 +345,8 @@ async function handleAction() {
             if (!isNewUser) {
               await loadDetail() // refresh participation status
             }
-          } catch {
+          } catch (err: unknown) {
-            uni.showToast({ title: '登录失败', icon: 'none' })
+            uni.showToast({ title: getErrorMessage(err, '登录失败'), icon: 'none' })
           }
         }
       },
@@ -395,6 +397,7 @@ async function doPurchase() {
       })
     })
 
+    await requestOrderPaidSubscriptionMessage().catch(() => undefined)
     uni.showToast({ title: '抢购成功！', icon: 'success' })
     await userStore.fetchMemberships()
     await loadDetail() // refresh status

packages/app/src/pages/profile/index.vue

@@ -24,6 +24,7 @@ import { onShow, onShareAppMessage, onShareTimeline } from '@dcloudio/uni-app'
 import { storeToRefs } from 'pinia'
 import { useUserStore } from '../../stores/user'
 import { getSystemLayout } from '../../utils/system'
+import { getErrorMessage } from '../../utils/auth'
 import UserCard from '../../components/UserCard.vue'
 import ProfileMenu from '../../components/ProfileMenu.vue'
 import CustomNavBar from '../../components/CustomNavBar.vue'
@@ -72,8 +73,8 @@ async function handleLogin() {
     if (!isNewUser) {
       await userStore.fetchStats()
     }
-  } catch {
+  } catch (err: unknown) {
-    uni.showToast({ title: '登录失败，请重试', icon: 'none' })
+    uni.showToast({ title: getErrorMessage(err, '登录失败，请重试'), icon: 'none' })
   } finally {
     loginLoading.value = false
   }

packages/app/src/stores/user.ts

@@ -9,6 +9,7 @@ import { UserRole, MembershipStatus } from '@mp-pilates/shared'
 import { wxLogin, isLoggedIn, logout as authLogout } from '../utils/auth'
 import { get, put } from '../utils/request'
 import { ROUTES } from '../utils/routes'
+import { cacheSubscriptionMessageTemplateConfig, resetSubscriptionMessageTemplateCache } from '../utils/wechat-subscription'
 
 export const useUserStore = defineStore('user', () => {
   // State
@@ -59,6 +60,7 @@ export const useUserStore = defineStore('user', () => {
     if (!isLoggedIn()) return
     try {
       user.value = await get<UserProfileResponse>('/user/profile')
+      cacheSubscriptionMessageTemplateConfig(user.value.subscriptionMessageTemplates)
     } catch (err) {
       console.error('Fetch profile failed:', err)
     }
@@ -97,6 +99,7 @@ export const useUserStore = defineStore('user', () => {
 
   function logout() {
     authLogout()
+    resetSubscriptionMessageTemplateCache()
     token.value = ''
     user.value = null
     stats.value = null

packages/app/src/utils/auth.ts

@@ -7,13 +7,66 @@ interface LoginResponse {
   readonly isNewUser: boolean
 }
 
+interface UniErrorLike {
+  readonly errMsg?: string
+}
+
+interface WechatPrivacyApi {
+  requirePrivacyAuthorize?: (options: {
+    success: () => void
+    fail: (err: UniErrorLike) => void
+  }) => void
+}
+
+function buildPrivacyError(err?: UniErrorLike): Error {
+  const errMsg = err?.errMsg || ''
+
+  if (errMsg.includes('cancel') || errMsg.includes('deny') || errMsg.includes('disagree')) {
+    return new Error('请先同意隐私保护指引')
+  }
+
+  return new Error('隐私授权失败，请重试')
+}
+
+async function ensurePrivacyAuthorization(): Promise<void> {
+  // #ifdef MP-WEIXIN
+  const wechat = (globalThis as typeof globalThis & { wx?: WechatPrivacyApi }).wx
+  if (!wechat || typeof wechat.requirePrivacyAuthorize !== 'function') {
+    return
+  }
+
+  const requirePrivacyAuthorize = wechat.requirePrivacyAuthorize
+
+  await new Promise<void>((resolve, reject) => {
+    requirePrivacyAuthorize({
+      success: () => resolve(),
+      fail: (err: UniErrorLike) => reject(buildPrivacyError(err)),
+    })
+  })
+  // #endif
+}
+
+export function getErrorMessage(err: unknown, fallback: string): string {
+  if (err instanceof Error && err.message) {
+    return err.message
+  }
+  return fallback
+}
+
 export async function wxLogin(): Promise<LoginResponse> {
+  await ensurePrivacyAuthorization()
+
   return new Promise((resolve, reject) => {
     // Step 1:静默登录，获取 code
     uni.login({
       provider: 'weixin',
       success: async (loginRes) => {
         try {
+          if (!loginRes.code) {
+            reject(new Error('微信登录失败，请重试'))
+            return
+          }
+
           // Step 2: 发送登录请求
           // 注：uni.getUserProfile 已被微信废弃（基础库 2.27.1+），
           // 新用户的昵称/头像由后端生成默认值，用户可在个人资料页修改

packages/app/src/utils/wechat-subscription.ts

@@ -0,0 +1,188 @@
+import {
+  SubscriptionMessageScene,
+} from '@mp-pilates/shared'
+import type {
+  ReportSubscriptionMessageRequestDto,
+  SubscriptionMessageRequestItem,
+  SubscriptionMessageTemplate,
+  SubscriptionMessageTemplateConfig,
+} from '@mp-pilates/shared'
+import { post } from './request'
+
+type TemplateResult = SubscriptionMessageRequestItem['result'] | 'tmplIds empty' | 'err' | 'undefined'
+
+type RequestSubscribeMessageSuccess = Record<string, TemplateResult | undefined> & {
+  errMsg?: string
+}
+
+interface RequestSubscribeMessageFail {
+  errMsg?: string
+  errCode?: number | null
+}
+
+function stringifyDebugPayload(payload: unknown): string {
+  try {
+    return JSON.stringify(payload)
+  } catch {
+    return String(payload)
+  }
+}
+
+function getSubscribeDebugContext() {
+  try {
+    const systemInfo = uni.getSystemInfoSync()
+    const host = systemInfo.host as { env?: string } | string | undefined
+    return {
+      platform: systemInfo.platform,
+      hostEnv: typeof host === 'object' && host ? host.env : undefined,
+      app: systemInfo.appName,
+      system: systemInfo.system,
+      language: systemInfo.language,
+      version: systemInfo.version,
+      SDKVersion: systemInfo.SDKVersion,
+    }
+  } catch {
+    return {
+      platform: 'unknown',
+    }
+  }
+}
+
+function buildSubscribeError(err: RequestSubscribeMessageFail, scene: SubscriptionMessageScene, templateIds: string[]): Error {
+  const debugContext = getSubscribeDebugContext()
+  const rawMessage = (err.errMsg || '').trim()
+
+  if (!rawMessage && debugContext.platform === 'devtools') {
+    return new Error(
+      `开发者工具当前环境不支持订阅消息唤起。请退出游客模式，使用已登录的微信开发者工具并在真机中重试。调试信息: ${stringifyDebugPayload({ scene, templateIds, err, debugContext })}`,
+    )
+  }
+
+  return new Error(
+    `订阅消息授权失败: ${stringifyDebugPayload({ scene, templateIds, err, debugContext })}`,
+  )
+}
+
+const TEMPLATE_CONFIG_STORAGE_KEY = 'subscriptionMessageTemplateConfig'
+
+let cachedConfig: SubscriptionMessageTemplateConfig | null = null
+
+function isMpWeixin(): boolean {
+  // #ifdef MP-WEIXIN
+  return true
+  // #endif
+  return false
+}
+
+function normalizeResult(result?: TemplateResult): SubscriptionMessageRequestItem['result'] | null {
+  if (result === 'accept' || result === 'reject' || result === 'ban' || result === 'filter') {
+    return result
+  }
+  return null
+}
+
+async function fetchTemplateConfig(): Promise<SubscriptionMessageTemplateConfig> {
+  if (cachedConfig) {
+    return cachedConfig
+  }
+
+  const stored = uni.getStorageSync(TEMPLATE_CONFIG_STORAGE_KEY) as SubscriptionMessageTemplateConfig | ''
+  if (!stored || !Array.isArray(stored.templates)) {
+    throw new Error('订阅消息模板尚未初始化，请重新进入页面后重试')
+  }
+
+  const config: SubscriptionMessageTemplateConfig = {
+    templates: stored.templates.filter((item) => item.templateId),
+  }
+  cachedConfig = config
+  return config
+}
+
+export function cacheSubscriptionMessageTemplateConfig(config: SubscriptionMessageTemplateConfig): SubscriptionMessageTemplateConfig {
+  const normalized: SubscriptionMessageTemplateConfig = {
+    templates: config.templates.filter((item) => item.templateId),
+  }
+  cachedConfig = normalized
+  uni.setStorageSync(TEMPLATE_CONFIG_STORAGE_KEY, normalized)
+  return normalized
+}
+
+function getTemplatesByScene(
+  config: SubscriptionMessageTemplateConfig,
+  scene: SubscriptionMessageScene,
+): SubscriptionMessageTemplate[] {
+  return config.templates.filter((item) => item.scene === scene && item.templateId)
+}
+
+async function reportResults(requests: SubscriptionMessageRequestItem[]): Promise<void> {
+  if (requests.length === 0) {
+    return
+  }
+
+  const payload: ReportSubscriptionMessageRequestDto = { requests }
+  await post('/user/subscription-messages/report', payload as unknown as Record<string, unknown>)
+}
+
+export async function requestSubscriptionMessage(scene: SubscriptionMessageScene): Promise<SubscriptionMessageRequestItem[]> {
+  if (!isMpWeixin()) {
+    return []
+  }
+
+  const config = await fetchTemplateConfig()
+  const templates = getTemplatesByScene(config, scene)
+  if (templates.length === 0) {
+    console.error('[subscribe] no templates matched scene', stringifyDebugPayload({ scene, config, debugContext: getSubscribeDebugContext() }))
+    return []
+  }
+
+  const templateIds = templates.map((item) => item.templateId)
+  const debugContext = getSubscribeDebugContext()
+  console.log('[subscribe] requestSubscribeMessage:start', stringifyDebugPayload({ scene, templateIds, templates, debugContext }))
+
+  const result = await new Promise<RequestSubscribeMessageSuccess>((resolve, reject) => {
+    uni.requestSubscribeMessage({
+      tmplIds: templateIds,
+      success: (res) => {
+        console.log('[subscribe] requestSubscribeMessage:success', stringifyDebugPayload({ scene, response: res, templateIds, debugContext }))
+        resolve(res as RequestSubscribeMessageSuccess)
+      },
+      fail: (err) => {
+        console.error('[subscribe] requestSubscribeMessage:fail', stringifyDebugPayload({ scene, error: err, templateIds, debugContext }))
+        reject(buildSubscribeError(err as RequestSubscribeMessageFail, scene, templateIds))
+      },
+    })
+  })
+
+  const requests = templates
+    .map<SubscriptionMessageRequestItem | null>((item) => {
+      const normalized = normalizeResult(result[item.templateId])
+      if (!normalized) {
+        return null
+      }
+
+      return {
+        templateId: item.templateId,
+        scene: item.scene,
+        result: normalized,
+      }
+    })
+    .filter((item): item is SubscriptionMessageRequestItem => item !== null)
+
+  console.log('[subscribe] requestSubscribeMessage:normalized', stringifyDebugPayload({ scene, result, requests, templateIds, debugContext }))
+
+  await reportResults(requests)
+  return requests
+}
+
+export async function requestOrderPaidSubscriptionMessage(): Promise<SubscriptionMessageRequestItem[]> {
+  return requestSubscriptionMessage(SubscriptionMessageScene.BOOKING_CREATED)
+}
+
+export async function requestBookingCreatedSubscriptionMessage(): Promise<SubscriptionMessageRequestItem[]> {
+  return requestSubscriptionMessage(SubscriptionMessageScene.BOOKING_CREATED)
+}
+
+export function resetSubscriptionMessageTemplateCache(): void {
+  cachedConfig = null
+  uni.removeStorageSync(TEMPLATE_CONFIG_STORAGE_KEY)
+}

packages/server/.env

@@ -19,3 +19,5 @@ API_BASE_URL=https://focus.richarjiang.com/
 
 # Server
 PORT=3000
+
+WX_SUBSCRIBE_TEMPLATE_BOOKING_CONFIRMED=antYfc85gvwImFZ9kM4UiqMOywJxbqFVgKHLH3NikII

packages/server/package.json

@@ -52,9 +52,9 @@
   },
   "jest": {
     "moduleFileExtensions": [
+      "ts",
       "js",
-      "json",
+      "json"
-      "ts"
     ],
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",
@@ -69,6 +69,7 @@
     "coverageDirectory": "../coverage",
     "testEnvironment": "node",
     "moduleNameMapper": {
+      "^@mp-pilates/shared$": "<rootDir>/../../shared/src/index.ts",
       "^@mp-pilates/shared(.*)$": "<rootDir>/../../shared/src$1"
     }
   },

packages/server/prisma/schema.prisma

@@ -80,10 +80,36 @@ model User {
   bookings    Booking[]
   orders      Order[]
   flashSaleOrders FlashSaleOrder[]
+  subscriptionMessageConsents SubscriptionMessageConsent[]
 
   @@map("users")
 }
 
+model SubscriptionMessageConsent {
+  id                String   @id @default(uuid())
+  userId            String   @map("user_id")
+  templateId        String   @map("template_id")
+  scene             String
+  totalRequestCount Int      @default(0) @map("total_request_count")
+  acceptCount       Int      @default(0) @map("accept_count")
+  rejectCount       Int      @default(0) @map("reject_count")
+  banCount          Int      @default(0) @map("ban_count")
+  filterCount       Int      @default(0) @map("filter_count")
+  sentCount         Int      @default(0) @map("sent_count")
+  lastResult        String   @map("last_result")
+  lastRequestedAt   DateTime @default(now()) @map("last_requested_at")
+  lastSentAt        DateTime? @map("last_sent_at")
+  createdAt         DateTime @default(now()) @map("created_at")
+  updatedAt         DateTime @updatedAt @map("updated_at")
+
+  user User @relation(fields: [userId], references: [id])
+
+  @@unique([userId, templateId, scene])
+  @@index([userId])
+  @@index([scene])
+  @@map("subscription_message_consents")
+}
+
 model CardType {
   id            String           @id @default(uuid())
   name          String

packages/server/src/booking/__tests__/booking.service.spec.ts

@@ -10,6 +10,7 @@ import { BookingService } from '../booking.service'
 import { PrismaService } from '../../prisma/prisma.service'
 import { MembershipService } from '../../membership/membership.service'
 import { StudioService } from '../../studio/studio.service'
+import { SubscriptionMessageService } from '../../user/subscription-message.service'
 
 // ─── Fixtures ──────────────────────────────────────────────────────────────
 
@@ -138,6 +139,9 @@ function buildTxMock(overrides: Record<string, unknown> = {}) {
       findUnique: jest.fn(),
       update: jest.fn(),
     },
+    bookingStatusHistory: {
+      create: jest.fn(),
+    },
     ...overrides,
   }
 }
@@ -148,6 +152,7 @@ describe('BookingService', () => {
   let service: BookingService
   let prisma: jest.Mocked<PrismaService>
   let studioService: jest.Mocked<StudioService>
+  let subscriptionMessageService: { sendBookingConfirmedMessage: jest.Mock }
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -172,6 +177,9 @@ describe('BookingService', () => {
               findUnique: jest.fn(),
               update: jest.fn(),
             },
+            user: {
+              findUnique: jest.fn(),
+            },
           },
         },
         {
@@ -188,35 +196,91 @@ describe('BookingService', () => {
             getInfo: jest.fn(),
           },
         },
+        {
+          provide: SubscriptionMessageService,
+          useValue: {
+            sendBookingConfirmedMessage: jest.fn(),
+          },
+        },
       ],
     }).compile()
 
     service = module.get<BookingService>(BookingService)
     prisma = module.get(PrismaService) as jest.Mocked<PrismaService>
     studioService = module.get(StudioService) as jest.Mocked<StudioService>
+    subscriptionMessageService = module.get(SubscriptionMessageService)
   })
 
   afterEach(() => jest.clearAllMocks())
 
+  describe('confirmBooking', () => {
+    it('sends booking confirmed subscription message after admin confirmation', async () => {
+      const tx = buildTxMock({
+        bookingStatusHistory: { create: jest.fn() },
+      })
+      tx.booking.findUnique.mockResolvedValue({
+        ...mockConfirmedBooking,
+        status: BookingStatus.PENDING_CONFIRMATION,
+        timeSlot: mockOpenSlot,
+        membership: mockActiveMembership,
+      })
+      tx.booking.update.mockResolvedValue({
+        ...mockConfirmedBooking,
+        status: BookingStatus.CONFIRMED,
+        confirmedAt: new Date('2099-12-30T00:00:00Z'),
+      })
+      tx.timeSlot.update.mockResolvedValue({ ...mockOpenSlot, bookedCount: 1, status: TimeSlotStatus.OPEN })
+      tx.membership.update.mockResolvedValue({ ...mockActiveMembership, remainingTimes: 4 })
+
+      ;(prisma.$transaction as jest.Mock).mockImplementation((fn) => fn(tx))
+      ;(prisma.booking.findUnique as jest.Mock).mockResolvedValue({
+        ...mockConfirmedBooking,
+        status: BookingStatus.CONFIRMED,
+        confirmedAt: new Date('2099-12-30T00:00:00Z'),
+        timeSlot: mockOpenSlot,
+        membership: mockActiveMembership,
+      })
+      ;(prisma.user.findUnique as jest.Mock).mockResolvedValue({ openid: 'openid-001' })
+      studioService.getInfo.mockResolvedValue({
+        ...mockStudioConfig,
+        name: 'FocusCore Pilates',
+      })
+      subscriptionMessageService.sendBookingConfirmedMessage.mockResolvedValue(true)
+
+      await service.confirmBooking(MOCK_BOOKING_ID, 'admin-001')
+
+      expect(subscriptionMessageService.sendBookingConfirmedMessage).toHaveBeenCalledWith({
+        openid: 'openid-001',
+        bookingId: MOCK_BOOKING_ID,
+        bookingContent: '预约已确认',
+        bookingTime: '2099-12-31 09:00',
+        courseName: 'FocusCore Pilates',
+        bookingPeriod: '2099-12-31 09:00~10:00',
+      })
+    })
+  })
+
   // ─── createBooking ────────────────────────────────────────────────────────
 
   describe('createBooking', () => {
     const dto = { timeSlotId: MOCK_SLOT_ID, membershipId: MOCK_MEMBERSHIP_ID }
 
-    it('creates booking, increments bookedCount, and deducts membership (TIMES card)', async () => {
+    it('creates booking in pending confirmation status', async () => {
       const tx = buildTxMock()
       tx.timeSlot.findUnique.mockResolvedValue(mockOpenSlot)
       tx.booking.findFirst.mockResolvedValue(null) // no duplicate
       tx.membership.findUnique.mockResolvedValue(mockActiveMembership)
-      tx.booking.create.mockResolvedValue(mockConfirmedBooking)
+      tx.booking.create.mockResolvedValue({
-      tx.timeSlot.update.mockResolvedValue({ ...mockOpenSlot, bookedCount: 1 })
+        ...mockConfirmedBooking,
-      tx.membership.update.mockResolvedValue({ ...mockActiveMembership, remainingTimes: 4 })
+        status: BookingStatus.PENDING_CONFIRMATION,
+      })
 
       ;(prisma.$transaction as jest.Mock).mockImplementation((fn) => fn(tx))
 
       // Mock the re-fetch after transaction
       ;(prisma.booking.findUnique as jest.Mock).mockResolvedValue({
         ...mockConfirmedBooking,
+        status: BookingStatus.PENDING_CONFIRMATION,
         timeSlot: mockOpenSlot,
         membership: mockActiveMembership,
       })
@@ -229,55 +293,45 @@ describe('BookingService', () => {
             userId: MOCK_USER_ID,
             timeSlotId: MOCK_SLOT_ID,
             membershipId: MOCK_MEMBERSHIP_ID,
-            status: BookingStatus.CONFIRMED,
+            status: BookingStatus.PENDING_CONFIRMATION,
           }),
         }),
       )
 
-      // bookedCount incremented from 0 → 1, still OPEN (capacity 5)
+      expect(tx.timeSlot.update).not.toHaveBeenCalled()
-      expect(tx.timeSlot.update).toHaveBeenCalledWith(
+      expect(tx.membership.update).not.toHaveBeenCalled()
-        expect.objectContaining({
-          data: expect.objectContaining({ bookedCount: 1, status: TimeSlotStatus.OPEN }),
-        }),
-      )
-
-      // membership deducted from 5 → 4
-      expect(tx.membership.update).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            remainingTimes: 4,
-            status: MembershipStatus.ACTIVE,
-          }),
-        }),
-      )
 
       expect(result).toBeDefined()
     })
 
-    it('sets slot to FULL when bookedCount reaches capacity', async () => {
+    it('records booking status history when user creates a booking', async () => {
       const nearFullSlot = { ...mockOpenSlot, bookedCount: 4, capacity: 5 }
 
       const tx = buildTxMock()
       tx.timeSlot.findUnique.mockResolvedValue(nearFullSlot)
       tx.booking.findFirst.mockResolvedValue(null)
       tx.membership.findUnique.mockResolvedValue(mockActiveMembership)
-      tx.booking.create.mockResolvedValue(mockConfirmedBooking)
+      tx.booking.create.mockResolvedValue({
-      tx.timeSlot.update.mockResolvedValue({ ...nearFullSlot, bookedCount: 5, status: TimeSlotStatus.FULL })
+        ...mockConfirmedBooking,
-      tx.membership.update.mockResolvedValue({ ...mockActiveMembership, remainingTimes: 4 })
+        status: BookingStatus.PENDING_CONFIRMATION,
+      })
 
       ;(prisma.$transaction as jest.Mock).mockImplementation((fn) => fn(tx))
       ;(prisma.booking.findUnique as jest.Mock).mockResolvedValue({
         ...mockConfirmedBooking,
-        timeSlot: { ...nearFullSlot, status: TimeSlotStatus.FULL },
+        status: BookingStatus.PENDING_CONFIRMATION,
+        timeSlot: nearFullSlot,
         membership: mockActiveMembership,
       })
 
       await service.createBooking(MOCK_USER_ID, dto)
 
-      // bookedCount 4+1 = 5 = capacity → FULL
+      expect(tx.bookingStatusHistory.create).toHaveBeenCalledWith(
-      expect(tx.timeSlot.update).toHaveBeenCalledWith(
         expect.objectContaining({
-          data: expect.objectContaining({ bookedCount: 5, status: TimeSlotStatus.FULL }),
+          data: expect.objectContaining({
+            toStatus: BookingStatus.PENDING_CONFIRMATION,
+            operatorId: MOCK_USER_ID,
+          }),
         }),
       )
     })
@@ -306,34 +360,29 @@ describe('BookingService', () => {
       expect(tx.membership.update).not.toHaveBeenCalled()
     })
 
-    it('marks membership as USED_UP when remainingTimes hits 0', async () => {
+    it('allows time-based membership with zero remaining times and leaves deduction to admin confirmation', async () => {
-      const lastTimeMembership = { ...mockActiveMembership, remainingTimes: 1 }
-
       const tx = buildTxMock()
       tx.timeSlot.findUnique.mockResolvedValue(mockOpenSlot)
       tx.booking.findFirst.mockResolvedValue(null)
-      tx.membership.findUnique.mockResolvedValue(lastTimeMembership)
+      tx.membership.findUnique.mockResolvedValue(mockMembershipNoTimes)
-      tx.booking.create.mockResolvedValue(mockConfirmedBooking)
+      tx.booking.create.mockResolvedValue({
-      tx.timeSlot.update.mockResolvedValue({ ...mockOpenSlot, bookedCount: 1 })
+        ...mockConfirmedBooking,
-      tx.membership.update.mockResolvedValue({ ...lastTimeMembership, remainingTimes: 0, status: MembershipStatus.USED_UP })
+        membershipId: mockMembershipNoTimes.id,
+        status: BookingStatus.PENDING_CONFIRMATION,
+      })
 
       ;(prisma.$transaction as jest.Mock).mockImplementation((fn) => fn(tx))
       ;(prisma.booking.findUnique as jest.Mock).mockResolvedValue({
         ...mockConfirmedBooking,
+        membershipId: mockMembershipNoTimes.id,
+        status: BookingStatus.PENDING_CONFIRMATION,
         timeSlot: mockOpenSlot,
-        membership: { ...lastTimeMembership, remainingTimes: 0, status: MembershipStatus.USED_UP },
+        membership: mockMembershipNoTimes,
       })
 
       await service.createBooking(MOCK_USER_ID, dto)
 
-      expect(tx.membership.update).toHaveBeenCalledWith(
+      expect(tx.membership.update).not.toHaveBeenCalled()
-        expect.objectContaining({
-          data: expect.objectContaining({
-            remainingTimes: 0,
-            status: MembershipStatus.USED_UP,
-          }),
-        }),
-      )
     })
 
     it('throws BadRequestException when slot is FULL', async () => {
@@ -374,20 +423,6 @@ describe('BookingService', () => {
       )
     })
 
-    it('throws BadRequestException when TIMES membership has 0 remaining', async () => {
-      const tx = buildTxMock()
-      tx.timeSlot.findUnique.mockResolvedValue(mockOpenSlot)
-      tx.booking.findFirst.mockResolvedValue(null)
-      tx.membership.findUnique.mockResolvedValue(mockMembershipNoTimes)
-
-      ;(prisma.$transaction as jest.Mock).mockImplementation((fn) => fn(tx))
-
-      await expect(service.createBooking(MOCK_USER_ID, dto)).rejects.toThrow(
-        BadRequestException,
-      )
-      expect(tx.booking.create).not.toHaveBeenCalled()
-    })
-
     it('throws NotFoundException when timeSlot does not exist', async () => {
       const tx = buildTxMock()
       tx.timeSlot.findUnique.mockResolvedValue(null)
@@ -662,7 +697,7 @@ describe('BookingService', () => {
         expect.objectContaining({
           where: expect.objectContaining({
             userId: MOCK_USER_ID,
-            status: BookingStatus.CONFIRMED,
+            status: { in: [BookingStatus.PENDING_CONFIRMATION, BookingStatus.CONFIRMED] },
           }),
           orderBy: [
             { timeSlot: { date: 'asc' } },

packages/server/src/booking/booking.module.ts

@@ -3,9 +3,10 @@ import { BookingController } from './booking.controller'
 import { BookingService } from './booking.service'
 import { MembershipModule } from '../membership/membership.module'
 import { StudioModule } from '../studio/studio.module'
+import { UserModule } from '../user/user.module'
 
 @Module({
-  imports: [MembershipModule, StudioModule],
+  imports: [MembershipModule, StudioModule, UserModule],
   controllers: [BookingController],
   providers: [BookingService],
   exports: [BookingService],

packages/server/src/booking/booking.service.ts

@@ -10,6 +10,7 @@ import { BookingStatus, CardTypeCategory, MembershipStatus, TimeSlotStatus } fro
 import { PrismaService } from '../prisma/prisma.service'
 import { MembershipService } from '../membership/membership.service'
 import { StudioService } from '../studio/studio.service'
+import { SubscriptionMessageService } from '../user/subscription-message.service'
 import { CreateBookingDto } from './dto/create-booking.dto'
 
 // ─── Types ─────────────────────────────────────────────────────────────────
@@ -48,6 +49,7 @@ export class BookingService {
     private readonly prisma: PrismaService,
     private readonly membershipService: MembershipService,
     private readonly studioService: StudioService,
+    private readonly subscriptionMessageService: SubscriptionMessageService,
   ) {}
 
   // ─── Create Booking ──────────────────────────────────────────────────────
@@ -235,7 +237,9 @@ export class BookingService {
       return updated
     })
 
-    return this.fetchBookingWithRelations(booking.id)
+    const confirmedBooking = await this.fetchBookingWithRelations(booking.id)
+    await this.trySendBookingConfirmedSubscriptionMessage(confirmedBooking)
+    return confirmedBooking
   }
 
   // ─── Complete / NoShow Booking (Admin) ──────────────────────────────────
@@ -566,4 +570,34 @@ export class BookingService {
 
     return { ...booking } as BookingWithRelations
   }
+
+  private async trySendBookingConfirmedSubscriptionMessage(
+    booking: BookingWithRelations,
+  ): Promise<void> {
+    try {
+      const user = await this.prisma.user.findUnique({
+        where: { id: booking.userId },
+        select: { openid: true },
+      })
+      if (!user?.openid) {
+        return
+      }
+
+      const studio = await this.studioService.getInfo()
+      const bookingDate = booking.timeSlot.date
+      const dateLabel = `${bookingDate.getFullYear()}-${String(bookingDate.getMonth() + 1).padStart(2, '0')}-${String(bookingDate.getDate()).padStart(2, '0')}`
+      const periodLabel = `${booking.timeSlot.startTime.slice(0, 5)}~${booking.timeSlot.endTime.slice(0, 5)}`
+
+      await this.subscriptionMessageService.sendBookingConfirmedMessage({
+        openid: user.openid,
+        bookingId: booking.id,
+        bookingContent: '预约已确认',
+        bookingTime: `${dateLabel} ${booking.timeSlot.startTime.slice(0, 5)}`,
+        courseName: studio.name || '普拉提课程',
+        bookingPeriod: `${dateLabel} ${periodLabel}`,
+      })
+    } catch (error) {
+      console.error('Send booking confirmed subscription message failed:', error)
+    }
+  }
 }

packages/server/src/user/__tests__/user.service.spec.ts

@@ -2,7 +2,13 @@ import { Test, TestingModule } from '@nestjs/testing'
 import { NotFoundException } from '@nestjs/common'
 import { UserService } from '../user.service'
 import { PrismaService } from '../../prisma/prisma.service'
-import { MembershipStatus, BookingStatus, UserRole } from '@mp-pilates/shared'
+import {
+  MembershipStatus,
+  BookingStatus,
+  UserRole,
+  SubscriptionMessageScene,
+} from '@mp-pilates/shared'
+import { ConfigService } from '@nestjs/config'
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -48,11 +54,22 @@ const mockPrisma = {
     findUnique: jest.fn(),
     update: jest.fn(),
   },
+  subscriptionMessageConsent: {
+    upsert: jest.fn(),
+    findMany: jest.fn(),
+  },
   booking: {
     findMany: jest.fn(),
   },
 }
 
+const mockConfigService = {
+  get: jest.fn((key: string, defaultValue = '') => {
+    if (key === 'WX_SUBSCRIBE_TEMPLATE_BOOKING_CONFIRMED') return 'tmpl-booking-confirmed'
+    return defaultValue
+  }),
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -65,6 +82,7 @@ describe('UserService', () => {
       providers: [
         UserService,
         { provide: PrismaService, useValue: mockPrisma },
+        { provide: ConfigService, useValue: mockConfigService },
       ],
     }).compile()
 
@@ -101,6 +119,15 @@ describe('UserService', () => {
         avatarUrl: 'https://example.com/avatar.png',
         role: UserRole.MEMBER,
         activeMembershipCount: 3,
+        subscriptionMessageTemplates: {
+          templates: [
+            {
+              templateId: 'tmpl-booking-confirmed',
+              scene: SubscriptionMessageScene.BOOKING_CREATED,
+              description: '购卡或预约时请求一次订阅，用于后续预约确认通知推送',
+            },
+          ],
+        },
         createdAt: new Date('2024-01-01T00:00:00Z').toISOString(),
       })
     })
@@ -112,6 +139,89 @@ describe('UserService', () => {
     })
   })
 
+  describe('reportSubscriptionMessageRequests', () => {
+    it('aggregates and returns subscription consent stats', async () => {
+      mockPrisma.subscriptionMessageConsent.upsert.mockResolvedValue(undefined)
+      mockPrisma.subscriptionMessageConsent.findMany.mockResolvedValue([
+        {
+          userId: 'user-1',
+          templateId: 'tmpl-booking-confirmed',
+          scene: SubscriptionMessageScene.BOOKING_CREATED,
+          totalRequestCount: 2,
+          acceptCount: 1,
+          rejectCount: 1,
+          banCount: 0,
+          filterCount: 0,
+          sentCount: 0,
+          lastResult: 'reject',
+          lastRequestedAt: new Date('2024-01-03T00:00:00Z'),
+          lastSentAt: null,
+          createdAt: new Date('2024-01-01T00:00:00Z'),
+          updatedAt: new Date('2024-01-03T00:00:00Z'),
+        },
+      ])
+
+      const result = await service.reportSubscriptionMessageRequests('user-1', [
+        {
+          templateId: 'tmpl-booking-confirmed',
+          scene: SubscriptionMessageScene.BOOKING_CREATED,
+          result: 'reject',
+        },
+      ])
+
+      expect(mockPrisma.subscriptionMessageConsent.upsert).toHaveBeenCalledWith({
+        where: {
+          userId_templateId_scene: {
+            userId: 'user-1',
+            templateId: 'tmpl-booking-confirmed',
+            scene: SubscriptionMessageScene.BOOKING_CREATED,
+          },
+        },
+        create: {
+          userId: 'user-1',
+          templateId: 'tmpl-booking-confirmed',
+          scene: SubscriptionMessageScene.BOOKING_CREATED,
+          totalRequestCount: 1,
+          acceptCount: 0,
+          rejectCount: 1,
+          banCount: 0,
+          filterCount: 0,
+          sentCount: 0,
+          lastResult: 'reject',
+          lastRequestedAt: expect.any(Date),
+        },
+        update: {
+          totalRequestCount: { increment: 1 },
+          acceptCount: { increment: 0 },
+          rejectCount: { increment: 1 },
+          banCount: { increment: 0 },
+          filterCount: { increment: 0 },
+          lastResult: 'reject',
+          lastRequestedAt: expect.any(Date),
+        },
+      })
+
+      expect(result).toEqual([
+        {
+          userId: 'user-1',
+          templateId: 'tmpl-booking-confirmed',
+          scene: SubscriptionMessageScene.BOOKING_CREATED,
+          totalRequestCount: 2,
+          acceptCount: 1,
+          rejectCount: 1,
+          banCount: 0,
+          filterCount: 0,
+          sentCount: 0,
+          lastResult: 'reject',
+          lastRequestedAt: '2024-01-03T00:00:00.000Z',
+          lastSentAt: null,
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-03T00:00:00.000Z',
+        },
+      ])
+    })
+  })
+
   // -------------------------------------------------------------------------
   // updateProfile
   // -------------------------------------------------------------------------
@@ -145,6 +255,7 @@ describe('UserService', () => {
       expect(result.nickname).toBe('Bob')
       expect(result.avatarUrl).toBe('https://example.com/new.png')
       expect(result.activeMembershipCount).toBe(1)
+      expect(result.subscriptionMessageTemplates.templates).toHaveLength(1)
     })
 
     it('only includes provided fields in the update payload', async () => {

packages/server/src/user/dto/report-subscription-message.dto.ts

@@ -0,0 +1,34 @@
+import {
+  ArrayMaxSize,
+  ArrayMinSize,
+  IsArray,
+  IsEnum,
+  IsIn,
+  IsString,
+  ValidateNested,
+} from 'class-validator'
+import { Type } from 'class-transformer'
+import {
+  SubscriptionMessageScene,
+  SUBSCRIPTION_MESSAGE_REQUEST_RESULTS,
+} from '@mp-pilates/shared'
+
+export class SubscriptionMessageRequestItemDto {
+  @IsString()
+  readonly templateId!: string
+
+  @IsEnum(SubscriptionMessageScene)
+  readonly scene!: SubscriptionMessageScene
+
+  @IsIn(SUBSCRIPTION_MESSAGE_REQUEST_RESULTS)
+  readonly result!: (typeof SUBSCRIPTION_MESSAGE_REQUEST_RESULTS)[number]
+}
+
+export class ReportSubscriptionMessageRequestDto {
+  @IsArray()
+  @ArrayMinSize(1)
+  @ArrayMaxSize(10)
+  @ValidateNested({ each: true })
+  @Type(() => SubscriptionMessageRequestItemDto)
+  readonly requests!: SubscriptionMessageRequestItemDto[]
+}

packages/server/src/user/subscription-message.service.ts

@@ -0,0 +1,168 @@
+import {
+  Injectable,
+  InternalServerErrorException,
+  Logger,
+} from '@nestjs/common'
+import { ConfigService } from '@nestjs/config'
+import { PrismaService } from '../prisma/prisma.service'
+
+interface BookingConfirmedTemplatePayload {
+  readonly openid: string
+  readonly bookingId: string
+  readonly bookingContent: string
+  readonly bookingTime: string
+  readonly courseName: string
+  readonly bookingPeriod: string
+}
+
+interface WechatAccessTokenResponse {
+  access_token?: string
+  expires_in?: number
+  errcode?: number
+  errmsg?: string
+}
+
+interface WechatSubscribeSendResponse {
+  errcode?: number
+  errmsg?: string
+}
+
+function stringifyDebugPayload(payload: unknown): string {
+  try {
+    return JSON.stringify(payload)
+  } catch {
+    return String(payload)
+  }
+}
+
+@Injectable()
+export class SubscriptionMessageService {
+  private readonly logger = new Logger(SubscriptionMessageService.name)
+  private accessTokenCache: { token: string; expireAt: number } | null = null
+
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  getBookingConfirmedTemplateId(): string {
+    return this.configService.get<string>('WX_SUBSCRIBE_TEMPLATE_BOOKING_CONFIRMED', '')
+  }
+
+  async sendBookingConfirmedMessage(payload: BookingConfirmedTemplatePayload): Promise<boolean> {
+    const templateId = this.getBookingConfirmedTemplateId()
+    if (!templateId) {
+      this.logger.warn('WX_SUBSCRIBE_TEMPLATE_BOOKING_CONFIRMED is not configured, skip sending subscription message')
+      return false
+    }
+
+    const consent = await this.prisma.subscriptionMessageConsent.findFirst({
+      where: {
+        user: { openid: payload.openid },
+        templateId,
+        scene: 'BOOKING_CREATED',
+        acceptCount: { gt: 0 },
+        totalRequestCount: { gt: 0 },
+      },
+      orderBy: [
+        { lastRequestedAt: 'desc' },
+        { updatedAt: 'desc' },
+      ],
+    })
+
+    if (!consent) {
+      this.logger.warn(`No subscription quota found: ${stringifyDebugPayload({ openid: payload.openid, bookingId: payload.bookingId, templateId, scene: 'BOOKING_CREATED' })}`)
+      return false
+    }
+
+    if (consent.sentCount >= consent.acceptCount) {
+      this.logger.warn(`Subscription quota exhausted: ${stringifyDebugPayload({ consentId: consent.id, bookingId: payload.bookingId, sentCount: consent.sentCount, acceptCount: consent.acceptCount, templateId })}`)
+      return false
+    }
+
+    const accessToken = await this.getAccessToken()
+    const page = `/pages/booking/detail?id=${payload.bookingId}`
+    const requestBody = {
+      touser: payload.openid,
+      template_id: templateId,
+      page,
+      data: {
+        thing1: { value: payload.bookingContent.slice(0, 20) },
+        time2: { value: payload.bookingTime.slice(0, 20) },
+        thing25: { value: payload.courseName.slice(0, 20) },
+        time35: { value: payload.bookingPeriod.slice(0, 20) },
+      },
+    }
+
+    this.logger.log(`WeChat subscribe send request: ${stringifyDebugPayload({ bookingId: payload.bookingId, templateId, requestBody, consentId: consent.id })}`)
+
+    const response = await fetch(
+      `https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=${accessToken}`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestBody),
+      },
+    )
+
+    if (!response.ok) {
+      const responseText = await response.text()
+      this.logger.error(`WeChat subscribe send http error: ${stringifyDebugPayload({ status: response.status, statusText: response.statusText, body: responseText, bookingId: payload.bookingId, templateId, requestBody })}`)
+      throw new InternalServerErrorException('调用微信订阅消息接口失败')
+    }
+
+    const result = (await response.json()) as WechatSubscribeSendResponse
+    if (result.errcode && result.errcode !== 0) {
+      this.logger.warn(`WeChat subscribe send failed: ${stringifyDebugPayload({ bookingId: payload.bookingId, templateId, requestBody, response: result, consentId: consent.id })}`)
+      return false
+    }
+
+    this.logger.log(`WeChat subscribe send success: ${stringifyDebugPayload({ bookingId: payload.bookingId, templateId, response: result, consentId: consent.id })}`)
+
+    await this.prisma.subscriptionMessageConsent.update({
+      where: { id: consent.id },
+      data: {
+        sentCount: { increment: 1 },
+        lastSentAt: new Date(),
+      },
+    })
+
+    return true
+  }
+
+  private async getAccessToken(): Promise<string> {
+    const now = Date.now()
+    if (this.accessTokenCache && this.accessTokenCache.expireAt > now) {
+      return this.accessTokenCache.token
+    }
+
+    const appId = this.configService.getOrThrow<string>('WX_APPID')
+    const secret = this.configService.getOrThrow<string>('WX_SECRET')
+    const response = await fetch(
+      `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${appId}&secret=${secret}`,
+    )
+
+    if (!response.ok) {
+      const responseText = await response.text()
+      this.logger.error(`WeChat access_token http error: ${stringifyDebugPayload({ status: response.status, statusText: response.statusText, body: responseText })}`)
+      throw new InternalServerErrorException('获取微信 access_token 失败')
+    }
+
+    const data = (await response.json()) as WechatAccessTokenResponse
+    if (!data.access_token || !data.expires_in) {
+      this.logger.error(`WeChat access_token invalid response: ${stringifyDebugPayload(data)}`)
+      throw new InternalServerErrorException(data.errmsg || '微信 access_token 返回异常')
+    }
+
+    this.logger.log(`WeChat access_token refreshed: ${stringifyDebugPayload({ expiresIn: data.expires_in })}`)
+
+    this.accessTokenCache = {
+      token: data.access_token,
+      expireAt: now + Math.max(data.expires_in - 300, 60) * 1000,
+    }
+
+    return data.access_token
+  }
+}

packages/server/src/user/user.controller.ts

@@ -6,6 +6,7 @@ import {
   Body,
   Param,
   Query,
+  Post,
   UseGuards,
 } from '@nestjs/common'
 import { UserRole, CardTypeCategory } from '@mp-pilates/shared'
@@ -16,6 +17,7 @@ import { CurrentUser } from '../common/decorators/current-user.decorator'
 import { UserService } from './user.service'
 import { UpdateProfileDto } from './dto/update-profile.dto'
 import { UpdateUserMembershipDto } from './dto/update-user-membership.dto'
+import { ReportSubscriptionMessageRequestDto } from './dto/report-subscription-message.dto'
 
 const VALID_CARD_TYPES = new Set<string>(Object.values(CardTypeCategory))
 
@@ -42,6 +44,19 @@ export class UserController {
     return this.userService.getStats(userId)
   }
 
+  @Get('user/subscription-messages/templates')
+  getSubscriptionMessageTemplates() {
+    return this.userService.getSubscriptionMessageTemplates()
+  }
+
+  @Post('user/subscription-messages/report')
+  reportSubscriptionMessageRequests(
+    @CurrentUser('sub') userId: string,
+    @Body() dto: ReportSubscriptionMessageRequestDto,
+  ) {
+    return this.userService.reportSubscriptionMessageRequests(userId, dto.requests)
+  }
+
   // ─── Admin: Member Management ─────────────────────────────────────────────
 
   @Get('admin/members')

packages/server/src/user/user.module.ts

@@ -1,12 +1,14 @@
 import { Module } from '@nestjs/common'
+import { ConfigModule } from '@nestjs/config'
 import { AuthModule } from '../auth/auth.module'
 import { UserController } from './user.controller'
 import { UserService } from './user.service'
+import { SubscriptionMessageService } from './subscription-message.service'
 
 @Module({
-  imports: [AuthModule],
+  imports: [AuthModule, ConfigModule],
   controllers: [UserController],
-  providers: [UserService],
+  providers: [UserService, SubscriptionMessageService],
-  exports: [UserService],
+  exports: [UserService, SubscriptionMessageService],
 })
 export class UserModule {}

packages/server/src/user/user.service.ts

@@ -1,14 +1,47 @@
 import { Injectable, NotFoundException } from '@nestjs/common'
-import { MembershipStatus, BookingStatus, UserRole, CardTypeCategory } from '@mp-pilates/shared'
+import {
-import type { PaginatedData, UserProfileResponse, UserStatsResponse } from '@mp-pilates/shared'
+  MembershipStatus,
+  BookingStatus,
+  UserRole,
+  CardTypeCategory,
+  SubscriptionMessageScene,
+} from '@mp-pilates/shared'
+import type {
+  PaginatedData,
+  UserProfileResponse,
+  UserStatsResponse,
+  SubscriptionMessageConsentSummary,
+  SubscriptionMessageRequestItem,
+  SubscriptionMessageRequestResult,
+  SubscriptionMessageTemplateConfig,
+} from '@mp-pilates/shared'
+import { ConfigService } from '@nestjs/config'
 import { PrismaService } from '../prisma/prisma.service'
 import { UpdateUserMembershipDto } from './dto/update-user-membership.dto'
 
 const VALID_CARD_TYPES = new Set<string>(Object.values(CardTypeCategory))
 
+type SubscriptionMessageConsentDelegate = PrismaService['subscriptionMessageConsent']
+type SubscriptionMessageConsentRecord = Awaited<ReturnType<SubscriptionMessageConsentDelegate['findMany']>>[number]
+
 @Injectable()
 export class UserService {
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly configService: ConfigService,
+  ) {}
+
+  private buildSubscriptionTemplateConfig(): SubscriptionMessageTemplateConfig {
+    return {
+      templates: [
+        {
+          templateId: this.configService.get<string>('WX_SUBSCRIBE_TEMPLATE_BOOKING_CONFIRMED', ''),
+          scene: SubscriptionMessageScene.BOOKING_CREATED,
+          description: '购卡或预约时请求一次订阅，用于后续预约确认通知推送',
+        },
+      ].filter((item) => item.templateId),
+    }
+  }
 
   async getProfile(userId: string): Promise<UserProfileResponse> {
     const user = await this.prisma.user.findUnique({
@@ -35,6 +68,7 @@ export class UserService {
       avatarUrl: user.avatarUrl,
       role: user.role as UserRole,
       activeMembershipCount: user._count.memberships,
+      subscriptionMessageTemplates: this.buildSubscriptionTemplateConfig(),
       createdAt: user.createdAt.toISOString(),
     }
   }
@@ -67,10 +101,86 @@ export class UserService {
       avatarUrl: updated.avatarUrl,
       role: updated.role as UserRole,
       activeMembershipCount: updated._count.memberships,
+      subscriptionMessageTemplates: this.buildSubscriptionTemplateConfig(),
       createdAt: updated.createdAt.toISOString(),
     }
   }
 
+  getSubscriptionMessageTemplates(): SubscriptionMessageTemplateConfig {
+    return this.buildSubscriptionTemplateConfig()
+  }
+
+  async reportSubscriptionMessageRequests(
+    userId: string,
+    requests: readonly SubscriptionMessageRequestItem[],
+  ): Promise<SubscriptionMessageConsentSummary[]> {
+    if (requests.length === 0) {
+      return []
+    }
+
+    await Promise.all(
+      requests.map((item) => this.prisma.subscriptionMessageConsent.upsert({
+        where: {
+          userId_templateId_scene: {
+            userId,
+            templateId: item.templateId,
+            scene: item.scene,
+          },
+        },
+        create: {
+          userId,
+          templateId: item.templateId,
+          scene: item.scene,
+          totalRequestCount: 1,
+          acceptCount: item.result === 'accept' ? 1 : 0,
+          rejectCount: item.result === 'reject' ? 1 : 0,
+          banCount: item.result === 'ban' ? 1 : 0,
+          filterCount: item.result === 'filter' ? 1 : 0,
+          sentCount: 0,
+          lastResult: item.result,
+          lastRequestedAt: new Date(),
+        },
+        update: {
+          totalRequestCount: { increment: 1 },
+          acceptCount: { increment: item.result === 'accept' ? 1 : 0 },
+          rejectCount: { increment: item.result === 'reject' ? 1 : 0 },
+          banCount: { increment: item.result === 'ban' ? 1 : 0 },
+          filterCount: { increment: item.result === 'filter' ? 1 : 0 },
+          lastResult: item.result,
+          lastRequestedAt: new Date(),
+        },
+      })),
+    )
+
+    const summaries = await this.prisma.subscriptionMessageConsent.findMany({
+      where: {
+        userId,
+        OR: requests.map((item) => ({
+          templateId: item.templateId,
+          scene: item.scene,
+        })),
+      },
+      orderBy: { updatedAt: 'desc' },
+    })
+
+    return summaries.map((item: SubscriptionMessageConsentRecord) => ({
+      userId: item.userId,
+      templateId: item.templateId,
+      scene: item.scene as SubscriptionMessageScene,
+      totalRequestCount: item.totalRequestCount,
+      acceptCount: item.acceptCount,
+      rejectCount: item.rejectCount,
+      banCount: item.banCount,
+      filterCount: item.filterCount,
+      sentCount: item.sentCount,
+      lastResult: item.lastResult as SubscriptionMessageRequestResult,
+      lastRequestedAt: item.lastRequestedAt.toISOString(),
+      lastSentAt: item.lastSentAt?.toISOString() ?? null,
+      createdAt: item.createdAt.toISOString(),
+      updatedAt: item.updatedAt.toISOString(),
+    }))
+  }
+
   async getStats(userId: string): Promise<UserStatsResponse> {
     const completedBookings = await this.prisma.booking.findMany({
       where: {

packages/shared/src/constants.ts

@@ -19,3 +19,6 @@ export const DATE_SELECTOR_DAYS = 7
 
 /** 星期映射 */
 export const WEEKDAY_LABELS = ['', '周一', '周二', '周三', '周四', '周五', '周六', '周日'] as const
+
+/** 微信订阅消息请求结果 */
+export const SUBSCRIPTION_MESSAGE_REQUEST_RESULTS = ['accept', 'reject', 'ban', 'filter'] as const

packages/shared/src/enums.ts

@@ -58,3 +58,9 @@ export enum FlashSaleOrderStatus {
   PAID = 'PAID',
   EXPIRED = 'EXPIRED',
 }
+
+// ===== Subscribe Message =====
+export enum SubscriptionMessageScene {
+  ORDER_PAID = 'ORDER_PAID',
+  BOOKING_CREATED = 'BOOKING_CREATED',
+}

packages/shared/src/index.ts

@@ -9,6 +9,7 @@ export {
   OrderStatus,
   FlashSaleStatus,
   FlashSaleOrderStatus,
+  SubscriptionMessageScene,
 } from './enums'
 
 // Constants
@@ -19,6 +20,7 @@ export {
   TIME_PERIODS,
   DATE_SELECTOR_DAYS,
   WEEKDAY_LABELS,
+  SUBSCRIPTION_MESSAGE_REQUEST_RESULTS,
 } from './constants'
 
 // Types
@@ -63,6 +65,12 @@ export type {
   CreateFlashSaleDto,
   UpdateFlashSaleDto,
   FlashSalePurchaseResponse,
+  SubscriptionMessageRequestResult,
+  SubscriptionMessageRequestItem,
+  SubscriptionMessageTemplate,
+  SubscriptionMessageTemplateConfig,
+  ReportSubscriptionMessageRequestDto,
+  SubscriptionMessageConsentSummary,
 } from './types/index'
 
 export { FlashSalePhase } from './types/index'

packages/shared/src/types/index.ts

@@ -1,4 +1,12 @@
 export type { User, UserProfileResponse, UpdateProfileDto, UserStatsResponse } from './user'
+export type {
+  SubscriptionMessageRequestResult,
+  SubscriptionMessageRequestItem,
+  SubscriptionMessageTemplate,
+  SubscriptionMessageTemplateConfig,
+  ReportSubscriptionMessageRequestDto,
+  SubscriptionMessageConsentSummary,
+} from './subscription'
 export type { CardType, CreateCardTypeDto, UpdateCardTypeDto } from './card-type'
 export type { Membership, MembershipWithCardType } from './membership'
 export type { WeekTemplate, WeekTemplateInput } from './week-template'

packages/shared/src/types/subscription.ts

@@ -0,0 +1,41 @@
+import { SubscriptionMessageScene } from '../enums'
+import type { SUBSCRIPTION_MESSAGE_REQUEST_RESULTS } from '../constants'
+
+export type SubscriptionMessageRequestResult = typeof SUBSCRIPTION_MESSAGE_REQUEST_RESULTS[number]
+
+export interface SubscriptionMessageRequestItem {
+  readonly templateId: string
+  readonly scene: SubscriptionMessageScene
+  readonly result: SubscriptionMessageRequestResult
+}
+
+export interface SubscriptionMessageTemplate {
+  readonly templateId: string
+  readonly scene: SubscriptionMessageScene
+  readonly description: string
+}
+
+export interface SubscriptionMessageTemplateConfig {
+  readonly templates: SubscriptionMessageTemplate[]
+}
+
+export interface ReportSubscriptionMessageRequestDto {
+  readonly requests: SubscriptionMessageRequestItem[]
+}
+
+export interface SubscriptionMessageConsentSummary {
+  readonly userId: string
+  readonly templateId: string
+  readonly scene: SubscriptionMessageScene
+  readonly totalRequestCount: number
+  readonly acceptCount: number
+  readonly rejectCount: number
+  readonly banCount: number
+  readonly filterCount: number
+  readonly sentCount: number
+  readonly lastResult: SubscriptionMessageRequestResult
+  readonly lastRequestedAt: string
+  readonly lastSentAt: string | null
+  readonly createdAt: string
+  readonly updatedAt: string
+}

packages/shared/src/types/user.ts

@@ -1,4 +1,5 @@
 import { UserRole } from '../enums'
+import type { SubscriptionMessageTemplateConfig } from './subscription'
 
 export interface User {
   readonly id: string
@@ -19,6 +20,7 @@ export interface UserProfileResponse {
   readonly avatarUrl: string | null
   readonly role: UserRole
   readonly activeMembershipCount: number
+  readonly subscriptionMessageTemplates: SubscriptionMessageTemplateConfig
   readonly createdAt: string
 }