Telegram小程序 指南 | 授权用户

riyad

/ C& Q! G$ x  ^+ J3 b9 J0 _
8 ]/ _1 y6 E0 u3 F. g

本文提供了不同编程语言的代码示例，说明开发人员如何使用 Telegram 初始数据授权用户。

客户端​

首先，需要从客户端向服务器传输初始数据开始。 我们可以使用此代码 ：

1. import { retrieveLaunchParams } from '@telegram-apps/sdk';
   
2. 
   5 h' \" v5 x  L3 j
3. const { initDataRaw } = retrieveLaunchParams();
   & \7 F5 C' m7 D4 G3 D
4. 
   7 [/ ]1 e) z# F% e! a7 L
5. fetch('https://example.com/api', {
   ' B7 E4 k7 g/ d0 w' }( b  U7 O8 w" e" B
6.   method: 'POST',
   " [2 |5 z& q5 N$ y( X
7.   headers: {
   ( e2 A+ ]% t: D* f0 g6 Z
8.     Authorization: `tma ${initDataRaw}`
   
9.   },
   + t/ S; [/ K8 C" t9 N$ g) P
10. });

复制代码

我们使用 https://example.com/api URL 向假想的服务器发送请求。 该请求使用 HTTP POST 方法（你可以使用任何你想要的方法），并附加 Authorization（授权）标头，这在这里是最重要的。 表示一个字符串，包含由空格分割的两个部分。 第一个描述授权方法（在 的情况下，我们的服务器将支持其他几种方法），第二个包含授权数据。 就 Telegram Mini Apps 而言，第二部分是原始 init 数据。

服务器端​

现在，当 init 数据传输到服务器端时，我们应该创建一个简单的 HTTP 服务器，使用这些数据并 授权用户。

Node.js​

Node.js 示例使用 express 处理 HTTP 请求。

1. import { validate, parse, type InitDataParsed } from '@telegram-apps/init-data-node';
   $ @2 T# i  [" C/ D# O
2. import express, {
   
3.   type ErrorRequestHandler,
   
4.   type RequestHandler,
   & G. p3 C- e8 i0 w1 E
5.   type Response,
   
6. } from 'express';
   
7. 
   
8. /**
   $ z$ n: r; _$ o+ c. [' f7 U
9. * Sets init data in the specified Response object.
   
10. * @param res - Response object.
    6 x# ~) g) V$ ^; h
11. * @param initData - init data.
    
12. */
    
13. function setInitData(res: Response, initData: InitDataParsed): void {
    " ~6 E2 {5 g7 g6 l9 l" N
14.   res.locals.initData = initData;
    1 ~- n7 Y* ?- m4 U3 z1 j* q2 _
15. }
    
16. 
    
17. /**
    / h/ h% r4 E4 h% W
18. * Extracts init data from the Response object.
    ' Q4 Y0 y& S. o: I: |- L6 E/ f
19. * @param res - Response object.
    
20. * @returns Init data stored in the Response object. Can return undefined in case,
    : l! a, D( S9 m$ R& }5 K1 I
21. * the client is not authorized.
    ( |9 V) d# V  `
22. */
    ) U; j" a1 N. m9 P, D4 C5 x4 |9 g( X
23. function getInitData(res: Response): InitDataParsed | undefined {
    
24.   return res.locals.initData;
    + Y8 q2 ~$ h+ I5 p6 |- m
25. }
    " E5 W4 V* R$ G' G0 @$ w0 N: p
26. 
    $ G6 h! o) t, ~4 m
27. /**
    
28. * Middleware which authorizes the external client.
    
29. * @param req - Request object.
    1 l2 \" f# u* E- H% u7 [
30. * @param res - Response object.
    
31. * @param next - function to call the next middleware.
    4 K; Q/ w7 }% _7 x; y0 g6 N$ [
32. */
    
33. const authMiddleware: RequestHandler = (req, res, next) => {
    ; o: L6 }* F+ C' F, \
34.   // We expect passing init data in the Authorization header in the following format:
    
35.   // <auth-type> <auth-data>
    
36.   // <auth-type> must be "tma", and <auth-data> is Telegram Mini Apps init data.
    - i% t# K: W) {* q/ y$ E
37.   const [authType, authData = ''] = (req.header('authorization') || '').split(' ');
    5 \5 s) c8 M" a2 \6 k; F3 e
38. 
    
39.   switch (authType) {
    
40.     case 'tma':
    
41.       try {
    4 r6 P; u0 G" D  q
42.         // Validate init data.
    , T$ c* u! N5 b' Z" i) K; m- ]
43.         validate(authData, token, {
    * h2 ~* V1 X. a1 ^, L- m' J8 Y
44.           // We consider init data sign valid for 1 hour from their creation moment.
    
45.           expiresIn: 3600,
    
46.         });
    0 R- W9 T8 W; m$ r, v6 V& R0 Q
47. 
    
48.         // Parse init data. We will surely need it in the future.
    
49.         setInitData(res, parse(authData));
    1 Q1 C/ S5 y! S& J. k1 c9 M
50.         return next();
    ' {: S# Y; ?4 V5 f0 F- M) r! e" W
51.       } catch (e) {
    ) ^% @  R; R9 K2 O# |
52.         return next(e);
    ( k& l$ }/ n+ o; F) g
53.       }
    
54.     // ... other authorization methods.
    6 k; |* L: o" h. J: F
55.     default:
    
56.       return next(new Error('Unauthorized'));
    
57.   }
    2 }4 [# W+ Z# H: y
58. };
    
59. 
    7 ?5 r* O* N; d$ u5 O& n! B1 K
60. /**
    
61. * Middleware which shows the user init data.
    
62. * @param _req
    * V- c/ a4 o1 S# c
63. * @param res - Response object.
    
64. * @param next - function to call the next middleware.
    
65. */
    : i- k3 C" o$ k' `% B
66. const showInitDataMiddleware: RequestHandler = (_req, res, next) => {
    
67.   const initData = getInitData(res);
    ' x7 i4 l8 g6 S" ]
68.   if (!initData) {
    1 U, z2 G* p" p# R$ ]: w
69.     return next(new Error('Cant display init data as long as it was not found'));
      T1 |( ]# U# r5 c6 @. I4 V6 O6 |
70.   }
    ; ]5 a. i6 S* N+ D- i
71.   res.json(initData);
    
72. };
    
73. 
    
74. /**
      |1 t9 U5 K, u) N0 D3 g
75. * Middleware which displays the user init data.
    2 y% N; {, i% S
76. * @param err - handled error.
    
77. * @param _req
    
78. * @param res - Response object.
    
79. */
    2 G; ]) d' P7 l1 a3 I
80. const defaultErrorMiddleware: ErrorRequestHandler = (err, _req, res) => {
    : T; Y( C8 a8 @6 A
81.   res.status(500).json({
    
82.     error: err.message,
    
83.   });
    - i5 ^% D/ M2 Q
84. };
    9 I. q/ {+ M* M% [& V8 h" W
85. 
    
86. // Your secret bot token.
    2 v8 C0 [7 ~1 F, j9 x/ u& Z3 R
87. const token = '1234567890:ABC';
    ( ^, L) Q$ r: M8 W4 Q9 p
88. 
    ( ^3 [0 O  D% X' ]6 g  V; X
89. // Create an Express applet and start listening to port 3000.
    ( V& c% \' X# S! f1 H7 h; ~
90. const app = express();
    
91. 
    
92. app.use(authMiddleware);
    . J' i* D$ q# I6 Y
93. app.get('/', showInitDataMiddleware);
    
94. app.use(defaultErrorMiddleware);
    
95. 
    ' B; T& A8 X% E2 e# Z" q+ C
96. app.listen(3000);
    
97. 
    
98. // After the HTTP server was launched, try sending an HTTP GET request to the URL
    
99. // http://localhost:3000/ with an Authorization header containing data in the required format.

复制代码

GoLang[color=var(--vp-c-brand-1)]​

GoLang 示例使用 [color=var(--vp-c-brand-1)]gin 处理 HTTP 请求。

1. package main
   
2. 
   ; G  i* N9 N. f& p+ j0 J
3. import (
   7 t. x2 i6 S1 Z: I6 ^
4.         "context"
   0 x- }" I& }4 w7 ^
5.         "strings"
   
6.         "time"
   2 o6 y  t  q& c8 A+ k
7. 
   
8.         "github.com/gin-gonic/gin"
   
9.         initdata "github.com/telegram-mini-apps/init-data-golang"
   
10. )
    8 N7 G+ @% T! R  p( s
11. 
    6 `% u" x2 c4 h' _
12. type contextKey string
    9 H3 Y+ |# f$ T; h$ q* Q* i$ m- D
13. 
    & x# V0 L* H3 D3 L/ x  K
14. const (
    
15.         _initDataKey contextKey = "init-data"
    
16. )
    ( z9 M0 ^5 X& F/ _
17. 
    0 t1 h  g/ M$ F" v! p) l3 A( h
18. // Returns new context with specified init data.
    
19. func withInitData(ctx context.Context, initData initdata.InitData) context.Context {
    7 ~% z4 ?! I4 ]% I9 J
20.         return context.WithValue(ctx, _initDataKey, initData)
    
21. }
    
22. 
    6 ~, K% t6 \; d- A# A7 n; T
23. // Returns the init data from the specified context.
    
24. func ctxInitData(ctx context.Context) (initdata.InitData, bool) {
    ( r: S, K# T) c* R- E" Y; t& k
25.         initData, ok := ctx.Value(_initDataKey).(initdata.InitData)
    # s  y# c7 }7 @6 U9 o& D4 f% _7 p
26.         return initData, ok
      k* ?4 h; T1 f' k
27. }
    6 A& U$ O/ W" d1 B
28. 
    
29. // Middleware which authorizes the external client.
    
30. func authMiddleware(token string) gin.HandlerFunc {
    
31.         return func(context *gin.Context) {
    . P8 j9 t$ u4 u0 ^! V
32.                 // We expect passing init data in the Authorization header in the following format:
    
33.                 // <auth-type> <auth-data>
    % ^* _% ^3 @( K7 l; `
34.                 // <auth-type> must be "tma", and <auth-data> is Telegram Mini Apps init data.
    
35.                 authParts := strings.Split(context.GetHeader("authorization"), " ")
    2 u& b& d3 i# Y4 P; o8 z
36.                 if len(authParts) != 2 {
    " a: Z# p0 I$ {* x& E* M8 k
37.                         context.AbortWithStatusJSON(401, map[string]any{
    4 ]- J4 u$ U0 v& a; W
38.                                 "message": "Unauthorized",
    
39.                         })
      F/ Q: J! Y* G( Z4 g9 M* a5 x
40.                         return
    
41.                 }
    5 g- o$ l% {' a9 o4 ^( o9 W
42. 
    
43.                 authType := authParts[0]
    % Q9 _+ j1 M0 `( K2 v, T
44.                 authData := authParts[1]
    
45. 
    
46.                 switch authType {
    
47.                 case "tma":
    
48.                         // Validate init data. We consider init data sign valid for 1 hour from their
    0 n$ x0 \. l3 f6 U; V
49.                         // creation moment.
    3 _3 c4 L5 ?+ M: N' y
50.                         if err := initdata.Validate(authData, token, time.Hour); err != nil {
    
51.                                 context.AbortWithStatusJSON(401, map[string]any{
    
52.                                         "message": err.Error(),
    * l- A- R* A) k9 [3 ]5 \
53.                                 })
    
54.                                 return
    
55.                         }
    
56. 
    
57.                         // Parse init data. We will surely need it in the future.
    % O8 A8 s7 {, q# B/ ?4 Z
58.                         initData, err := initdata.Parse(authData)
    & \6 E2 u2 q) E! V/ A% W1 }
59.                         if err != nil {
    7 {$ M& V* e, o2 Y1 J
60.                                 context.AbortWithStatusJSON(500, map[string]any{
    
61.                                         "message": err.Error(),
    
62.                                 })
    1 n3 C- S2 C+ A$ m3 [3 n1 H
63.                                 return
    , h) z6 S/ V( X9 b3 R8 O8 `1 O
64.                         }
    % E, _; q7 c* T+ D  n
65. 
    4 v( v- c& q0 K/ b5 ~  x2 r, k
66.                         context.Request = context.Request.WithContext(
    ' {9 p! \: A9 R! T% U
67.                                 withInitData(context.Request.Context(), initData),
    
68.                         )
    + `8 W9 U' h# S5 ~4 a) Y+ A! [
69.                 }
    
70.         }
    ' t2 m) Y) q: I: u* w5 s
71. }
    
72. 
    ( `4 l# P# Y. B+ I5 X0 W+ U6 A4 ]
73. // Middleware which shows the user init data.
    3 U  Z! y0 y# f1 `. F# S6 T& J/ K
74. func showInitDataMiddleware(context *gin.Context) {
    , D0 V+ M1 m2 I; }9 G
75.         initData, ok := ctxInitData(context.Request.Context())
    . h, }- h- @4 b' O8 J1 S$ n
76.         if !ok {
    
77.                 context.AbortWithStatusJSON(401, map[string]any{
    3 r: j9 E+ V5 F9 p1 P% T2 X
78.                         "message": "Init data not found",
    # \* ~( ~, x$ Y4 P/ ?. q
79.                 })
    + k: L$ P2 y/ X. y7 W' A% B) S' l
80.                 return
    
81.         }
    ! H$ X8 z% p6 @3 Z$ d% T
82. 
    
83.         context.JSON(200, initData)
    
84. }
    
85. 
    0 E3 ?1 t. j- D1 v+ w
86. func main() {
    
87.         // Your secret bot token.
    
88.         token := "1234567890:ABC"
    9 e! h6 n: ?# j5 Z9 n" p; P
89. 
    
90.         r := gin.New()
    + H0 f. z4 w2 D: C/ ]1 Y! o
91. 
    
92.         r.Use(authMiddleware(token))
    
93.         r.GET("/", showInitDataMiddleware)
    
94. 
    ! @! g7 R. n& _. D4 X$ V# ]
95.         if err := r.Run(":3000"); err != nil {
    
96.                 panic(err)
    
97.         }
    
98. }

复制代码