PocketBase 微信小程序登录实现

const WECHAT_CONFIG = {
  appid: "your_appid_here",
  secret: "your_secret_here",
};

package main

import (
  "crypto/aes"
  "crypto/cipher"
  "encoding/base64"
  "encoding/json"
  "errors"
  "fmt"
  "net/http"
  "net/url"
  "time"

  "github.com/pocketbase/pocketbase/core"
  "github.com/pocketbase/pocketbase/models"
  "github.com/pocketbase/pocketbase/tools/types"
)

type WeChatConfig struct {
  AppID  string
  Secret string
}

type WxCode2SessionResponse struct {
  OpenID     string `json:"openid"`
  SessionKey string `json:"session_key"`
  UnionID    string `json:"unionid"`
  ErrCode    int    `json:"errcode"`
  ErrMsg     string `json:"errmsg"`
}

type WxUserInfo struct {
  OpenID    string `json:"openId"`
  NickName  string `json:"nickName"`
  Gender    int    `json:"gender"`
  City      string `json:"city"`
  Province  string `json:"province"`
  Country   string `json:"country"`
  AvatarURL string `json:"avatarUrl"`
  Language  string `json:"language"`
}

func wechatLogin(e *core.RequestEvent) error {
  appID := e.App.Settings().Value["wechat"].(map[string]any)["appid"].(string)
  secret := e.App.Settings().Value["wechat"].(map[string]any)["secret"].(string)

  code := e.Request.URL.Query().Get("code")
  if code == "" {
    return e.JSON(http.StatusBadRequest, map[string]any{"error": "code is required"})
  }

  // 调用微信 API
  wxURL := fmt.Sprintf(
    "https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code",
    appID,
    secret,
    code,
  )

  resp, err := http.Get(wxURL)
  if err != nil {
    return e.JSON(http.StatusInternalServerError, map[string]any{"error": err.Error()})
  }
  defer resp.Body.Close()

  var wxResp WxCode2SessionResponse
  if err := json.NewDecoder(resp.Body).Decode(&wxResp); err != nil {
    return e.JSON(http.StatusInternalServerError, map[string]any{"error": err.Error()})
  }

  if wxResp.ErrCode != 0 {
    return e.JSON(http.StatusBadRequest, map[string]any{
      "error":   "WeChat API error",
      "code":    wxResp.ErrCode,
      "message": wxResp.ErrMsg,
    })
  }

  // 查找或创建用户
  collection, _ := e.App.Dao().FindCollectionByNameOrId("miniprogram_users")

  records, _ := e.App.Dao().FindRecordsByFilter(
    collection.Id,
    fmt.Sprintf("openid = '%s'", wxResp.OpenID),
    "",
    1,
  )

  var user *models.Record
  if len(records) > 0 {
    user = records[0]
    user.Set("lastLogin", time.Now())
    e.App.Dao().SaveRecord(user)
  } else {
    user = models.NewRecord(collection)
    user.Set("openid", wxResp.OpenID)
    user.Set("nickname", "微信用户")
    user.Set("lastLogin", time.Now())
    e.App.Dao().SaveRecord(user)
  }

  // 生成 token
  token, _ := e.App.NewRecordAuthToken(user, types.NowDefault().Add(time.Hour*24*30))

  return e.JSON(http.StatusOK, map[string]any{
    "token": token,
    "user": map[string]any{
      "id":         user.Id,
      "openid":     user.GetString("openid"),
      "nickname":   user.GetString("nickname"),
      "avatarUrl":  user.GetString("avatarUrl"),
    },
  })
}

// 添加路由
func main() {
  app := core.NewApp()

  app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
    e.Router.GET("/api/wechat-login", wechatLogin)
    return nil
  })

  if err := app.Start(); err != nil {
    app.Logger().Error(err.Error())
  }
}

const BASE_URL = "https://api.yourserver.com";

/**
 * 微信登录
 */
export async function wechatLogin() {
  try {
    // 1. 获取 code
    const loginRes = await wx.login();
    if (!loginRes.code) {
      throw new Error("获取微信登录 code 失败");
    }

    // 2. 发送到服务器
    const response = await wx.request({
      url: `${BASE_URL}/api/wechat-login`,
      method: "POST",
      data: {
        code: loginRes.code,
      },
      header: {
        "content-type": "application/x-www-form-urlencoded",
      },
    });

    if (response.statusCode !== 200) {
      throw new Error(response.data.error || "登录失败");
    }

    const { token, user } = response.data;

    // 3. 存储登录信息
    wx.setStorageSync("pb_token", token);
    wx.setStorageSync("pb_user", user);

    return { token, user };
  } catch (error) {
    console.error("微信登录失败:", error);
    throw error;
  }
}

/**
 * 获取用户信息（需要授权）
 */
export async function getUserProfile() {
  return new Promise((resolve, reject) => {
    wx.getUserProfile({
      desc: "用于完善会员资料",
      success: (res) => {
        resolve(res.userInfo);
      },
      fail: (err) => {
        reject(err);
      },
    });
  });
}

/**
 * 获取手机号
 */
export async function getPhoneNumber(code) {
  try {
    const response = await wx.request({
      url: `${BASE_URL}/api/wechat-phone`,
      method: "POST",
      data: { code },
      header: {
        "content-type": "application/x-www-form-urlencoded",
        Authorization: `Bearer ${wx.getStorageSync("pb_token")}`,
      },
    });

    if (response.statusCode !== 200) {
      throw new Error(response.data.error || "获取手机号失败");
    }

    return response.data;
  } catch (error) {
    console.error("获取手机号失败:", error);
    throw error;
  }
}

/**
 * 检查登录状态
 */
export function checkLogin() {
  const token = wx.getStorageSync("pb_token");
  const user = wx.getStorageSync("pb_user");
  return !!(token && user);
}

/**
 * 退出登录
 */
export function logout() {
  wx.removeStorageSync("pb_token");
  wx.removeStorageSync("pb_user");
}

import PocketBase from "pocketbase";
import { wechatLogin, checkLogin } from "./wechat-auth.js";

const pb = new PocketBase("https://api.yourserver.com");

// 请求拦截器
pb.beforeSend = function (url, options) {
  const token = wx.getStorageSync("pb_token");
  if (token) {
    options.headers = options.headers || {};
    options.headers["Authorization"] = `Bearer ${token}`;
  }
  return { url, options };
};

/**
 * 初始化登录
 */
export async function initAuth() {
  // 检查本地存储的 token
  if (checkLogin()) {
    const token = wx.getStorageSync("pb_token");
    pb.authStore.save(token, wx.getStorageSync("pb_user"));
    return true;
  }

  // 尝试静默登录
  try {
    await wechatLogin();
    return true;
  } catch (error) {
    console.log("静默登录失败，需要用户主动登录");
    return false;
  }
}

/**
 * 带认证的请求
 */
export async function authRequest(collection, action, data = {}) {
  if (!checkLogin()) {
    await wechatLogin();
  }

  switch (action) {
    case "getList":
      return await pb.collection(collection).getList(...data);
    case "getOne":
      return await pb.collection(collection).getOne(...data);
    case "create":
      return await pb.collection(collection).create(data);
    case "update":
      return await pb.collection(collection).update(...data);
    case "delete":
      return await pb.collection(collection).delete(...data);
    default:
      throw new Error(`Unknown action: ${action}`);
  }
}

export default pb;

import { wechatLogin, getUserProfile } from "../../utils/wechat-auth.js";

Page({
  data: {
    loading: false,
  },

  /**
   * 微信快捷登录
   */
  async handleWechatLogin() {
    if (this.data.loading) return;

    this.setData({ loading: true });

    try {
      // 尝试静默登录
      await wechatLogin();

      wx.showToast({
        title: "登录成功",
        icon: "success",
      });

      // 登录成功后跳转
      setTimeout(() => {
        wx.switchTab({
          url: "/pages/index/index",
        });
      }, 1500);
    } catch (error) {
      wx.showToast({
        title: error.message || "登录失败",
        icon: "none",
      });
    } finally {
      this.setData({ loading: false });
    }
  },

  /**
   * 获取用户信息后登录
   */
  async handleLoginWithProfile() {
    if (this.data.loading) return;

    this.setData({ loading: true });

    try {
      // 获取用户信息授权
      const userInfo = await getUserProfile();

      // 获取登录 code
      const loginRes = await wx.login();

      // 发送到服务器
      const response = await wx.request({
        url: "https://api.yourserver.com/api/wechat-login",
        method: "POST",
        data: {
          code: loginRes.code,
          userInfo: JSON.stringify(userInfo),
        },
        header: {
          "content-type": "application/x-www-form-urlencoded",
        },
      });

      if (response.statusCode !== 200) {
        throw new Error(response.data.error || "登录失败");
      }

      const { token, user } = response.data;

      // 存储登录信息
      wx.setStorageSync("pb_token", token);
      wx.setStorageSync("pb_user", user);

      wx.showToast({
        title: "登录成功",
        icon: "success",
      });

      setTimeout(() => {
        wx.switchTab({
          url: "/pages/index/index",
        });
      }, 1500);
    } catch (error) {
      wx.showToast({
        title: error.message || "登录失败",
        icon: "none",
      });
    } finally {
      this.setData({ loading: false });
    }
  },

  /**
   * 获取手机号
   */
  async handleGetPhoneNumber(e) {
    const { code } = e.detail;

    if (!code) {
      wx.showToast({
        title: "获取手机号失败",
        icon: "none",
      });
      return;
    }

    try {
      // 调用后端接口获取手机号
      // ... 手机号处理逻辑

      wx.showToast({
        title: "获取成功",
        icon: "success",
      });
    } catch (error) {
      wx.showToast({
        title: "获取手机号失败",
        icon: "none",
      });
    }
  },
});

<view class="login-container">
  <view class="logo-section">
    <image class="logo" src="/assets/logo.png" mode="aspectFit"></image>
    <text class="app-name">我的应用</text>
    <text class="app-slogan">欢迎回来</text>
  </view>

  <view class="login-section">
    <button
      class="login-btn wechat-btn"
      loading="{{loading}}"
      disabled="{{loading}}"
      bindtap="handleWechatLogin"
    >
      <image class="icon" src="/assets/wechat-icon.png"></image>
      <text>微信快捷登录</text>
    </button>

    <button
      class="login-btn profile-btn"
      loading="{{loading}}"
      disabled="{{loading}}"
      bindtap="handleLoginWithProfile"
    >
      <image class="icon" src="/assets/wechat-icon.png"></image>
      <text>获取用户信息登录</text>
    </button>

    <button
      class="login-btn phone-btn"
      open-type="getPhoneNumber"
      bindgetphonenumber="handleGetPhoneNumber"
    >
      <text>获取手机号</text>
    </button>
  </view>

  <view class="agreement-section">
    <checkbox-group bindchange="handleAgreementChange">
      <label>
        <checkbox value="agree" checked="{{agreed}}" />
        <text>我已阅读并同意</text>
        <text class="link" bindtap="showUserAgreement">《用户协议》</text>
        <text>和</text>
        <text class="link" bindtap="showPrivacyPolicy">《隐私政策》</text>
      </label>
    </checkbox-group>
  </view>
</view>

import { initAuth } from "./utils/pocketbase.js";

App({
  onLaunch() {
    this.checkUpdate();
  },

  async onShow() {
    // 初始化认证
    const isLoggedIn = await initAuth();

    if (!isLoggedIn) {
      // 未登录，跳转到登录页
      wx.reLaunch({
        url: "/pages/login/login",
      });
    }
  },

  checkUpdate() {
    if (wx.canIUse("getUpdateManager")) {
      const updateManager = wx.getUpdateManager();

      updateManager.onCheckForUpdate((res) => {
        if (res.hasUpdate) {
          updateManager.onUpdateReady(() => {
            wx.showModal({
              title: "更新提示",
              content: "新版本已准备好，是否重启应用？",
              success: (res) => {
                if (res.confirm) {
                  updateManager.applyUpdate();
                }
              },
            });
          });

          updateManager.onUpdateFailed(() => {
            wx.showModal({
              title: "更新失败",
              content: "新版本下载失败，请检查网络",
              showCancel: false,
            });
          });
        }
      });
    }
  },
});