Telegram小程序 指南 | 授权用户

riyad

, e2 E! |/ ^- S

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

3 k# b5 x1 H3 L: T' P' p, t客户端​

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

1. import { retrieveLaunchParams } from '@telegram-apps/sdk';
   ( i+ l( w. b$ I) C
2. 
   
3. const { initDataRaw } = retrieveLaunchParams();
   
4. 
   
5. fetch('https://example.com/api', {
     H7 D  U# T- t" O1 y1 B
6.   method: 'POST',
   
7.   headers: {
   
8.     Authorization: `tma ${initDataRaw}`
   ' y4 T1 e0 x6 Y( B+ _; \
9.   },
   ; D5 E' I! I% f* `
10. });

复制代码

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

  }- x3 x8 j( F4 M$ k4 K2 f2 Q* o服务器端​

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

Node.js​

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

1. import { validate, parse, type InitDataParsed } from '@telegram-apps/init-data-node';
   1 w  @; h5 P3 W; W# f8 F
2. import express, {
   . _1 H+ ]; A/ ?3 K, k3 ^- N
3.   type ErrorRequestHandler,
   
4.   type RequestHandler,
   ' I! W! B# L$ w$ r& _: N+ O
5.   type Response,
   
6. } from 'express';
   
7. 
   
8. /**
   : ^( G# p: x$ h& i, A' Z" e: c1 p
9. * Sets init data in the specified Response object.
   3 E9 m) \& N" ?! f( a( e6 @
10. * @param res - Response object.
    
11. * @param initData - init data.
    ) }6 M8 D5 T+ h2 c- P" C: O- L( h
12. */
    8 D; H* \5 x7 z4 I+ U1 i6 L- u
13. function setInitData(res: Response, initData: InitDataParsed): void {
    
14.   res.locals.initData = initData;
    
15. }
    
16. 
    
17. /**
    6 e4 ~# Z% N; H3 j7 s
18. * Extracts init data from the Response object.
    
19. * @param res - Response object.
    . X1 O0 p) j; e, [. ?% j% u8 [
20. * @returns Init data stored in the Response object. Can return undefined in case,
    
21. * the client is not authorized.
    
22. */
    & d) Y+ A9 v3 T+ |, n6 ~
23. function getInitData(res: Response): InitDataParsed | undefined {
    
24.   return res.locals.initData;
    9 @2 A1 X& a! s# B- b/ C* D
25. }
    2 u+ V8 Y# J: B
26. 
    
27. /**
    3 h* y! C" z9 h; O
28. * Middleware which authorizes the external client.
    
29. * @param req - Request object.
    $ z8 |3 ?' P  r
30. * @param res - Response object.
    # `2 m- C9 z( j# ^4 @; U
31. * @param next - function to call the next middleware.
    
32. */
    1 {, c% U: p) ~1 h# ~
33. const authMiddleware: RequestHandler = (req, res, next) => {
    . @& }4 E, K3 K* f$ Y
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.
    
37.   const [authType, authData = ''] = (req.header('authorization') || '').split(' ');
    
38. 
    . U' t' J4 y0 K8 F
39.   switch (authType) {
    - X2 S) _. s, [/ r/ r
40.     case 'tma':
    
41.       try {
    4 s- O. j' P9 J6 ~2 P
42.         // Validate init data.
    
43.         validate(authData, token, {
    
44.           // We consider init data sign valid for 1 hour from their creation moment.
    ; Q3 {: q( Q) p+ {
45.           expiresIn: 3600,
    
46.         });
    
47. 
    . t4 l& n3 V0 y" U+ h  W1 @
48.         // Parse init data. We will surely need it in the future.
    : o( j. \# Y* [' V( L+ ]
49.         setInitData(res, parse(authData));
    # _1 ~; \/ I* n1 p
50.         return next();
    6 I+ k+ ^# O. I, N; N* ]! b. @0 Y& X
51.       } catch (e) {
    
52.         return next(e);
    + y) l( r: z% b
53.       }
    # D4 Y9 {0 v& P8 _! K5 L
54.     // ... other authorization methods.
    : V5 G5 B7 ]- q' X
55.     default:
    1 l& g# n9 D0 k; J( E- Y! B8 T
56.       return next(new Error('Unauthorized'));
    ! y1 p1 y+ `& j9 q5 g" C# G# Q
57.   }
    
58. };
    
59. 
    % `$ K$ x) _' H& m# A) D
60. /**
    
61. * Middleware which shows the user init data.
    
62. * @param _req
    : R0 r3 U6 ~, l" a1 _
63. * @param res - Response object.
    4 T# t) J0 W. _2 m4 }, `
64. * @param next - function to call the next middleware.
    / F2 e1 v5 K; o( j1 b) \
65. */
    . Y& G' ^& [' x1 R: x( o& }
66. const showInitDataMiddleware: RequestHandler = (_req, res, next) => {
    
67.   const initData = getInitData(res);
    
68.   if (!initData) {
    
69.     return next(new Error('Cant display init data as long as it was not found'));
    
70.   }
    : f2 ^! @! c6 [3 g( J
71.   res.json(initData);
    
72. };
    - d/ Y5 ]" e* g; H2 `* r
73. 
    $ c" w/ l( A' j. u$ a8 j
74. /**
    7 w# G4 O/ L) }- l1 T6 ~! ^! Y
75. * Middleware which displays the user init data.
    
76. * @param err - handled error.
    
77. * @param _req
    
78. * @param res - Response object.
    8 R. ~- g. l) c. E7 L, X3 I$ p8 o
79. */
    & _0 \  X2 o+ S$ V; U
80. const defaultErrorMiddleware: ErrorRequestHandler = (err, _req, res) => {
    $ Q0 R5 v0 d2 V4 q3 U
81.   res.status(500).json({
    
82.     error: err.message,
    
83.   });
    
84. };
    
85. 
    
86. // Your secret bot token.
    
87. const token = '1234567890:ABC';
    , e3 X9 ?  g& Y! M) L
88. 
    , B  S) [, B0 M, K
89. // Create an Express applet and start listening to port 3000.
    
90. const app = express();
    & ^8 ]3 s9 ]& S0 R
91. 
    & g+ V8 t9 b6 f% D7 v- t9 G0 j8 p
92. app.use(authMiddleware);
    
93. app.get('/', showInitDataMiddleware);
    
94. app.use(defaultErrorMiddleware);
    
95. 
    / M6 d( L) O0 v" Q9 ]3 E
96. app.listen(3000);
    
97. 
    - }+ [9 i8 F1 I2 X3 ~' k8 {
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.

复制代码

  A+ R) s8 I$ ~4 n- K- BGoLang[color=var(--vp-c-brand-1)]​

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

1. package main
   7 B. u, G/ m& z) s4 H. u8 g
2. 
   
3. import (
   
4.         "context"
   
5.         "strings"
   
6.         "time"
   
7. 
   
8.         "github.com/gin-gonic/gin"
   ' o; D  ?% k5 @# w; J$ S- P, c
9.         initdata "github.com/telegram-mini-apps/init-data-golang"
   ( e0 ?' K: O1 U  h
10. )
    ; |* G1 C8 {0 J3 a  O1 M4 ?) t
11. 
    & S* ~7 m% x  u1 P8 A
12. type contextKey string
      H' y9 N) A8 n
13. 
    5 v* }- S$ O% d9 N( j$ i; A* O7 P
14. const (
    
15.         _initDataKey contextKey = "init-data"
    0 `) }, X' `4 S
16. )
    
17. 
    1 N6 o% o! c+ i, j9 g
18. // Returns new context with specified init data.
    ) c* `; V4 r8 h2 K
19. func withInitData(ctx context.Context, initData initdata.InitData) context.Context {
    # D$ Q4 c* \, D5 |/ H
20.         return context.WithValue(ctx, _initDataKey, initData)
    $ Z# Z9 Q3 {# P$ m2 `* l6 L0 O0 f  c
21. }
    ; M) l5 r* x# h& q" \
22. 
    
23. // Returns the init data from the specified context.
    
24. func ctxInitData(ctx context.Context) (initdata.InitData, bool) {
    . J: s1 E3 A2 W2 h* _# o
25.         initData, ok := ctx.Value(_initDataKey).(initdata.InitData)
    
26.         return initData, ok
    * u- q. U! @  g9 }. v1 D* k/ W4 B
27. }
    / B5 R6 Y0 `' q# X9 N
28. 
    
29. // Middleware which authorizes the external client.
    
30. func authMiddleware(token string) gin.HandlerFunc {
    7 }( `7 `6 l5 r$ \
31.         return func(context *gin.Context) {
    
32.                 // We expect passing init data in the Authorization header in the following format:
    ! }" e& L4 R: x9 Y. K$ f; J6 U+ o
33.                 // <auth-type> <auth-data>
    ! b; j5 R3 F& W2 p$ a
34.                 // <auth-type> must be "tma", and <auth-data> is Telegram Mini Apps init data.
    , l$ m+ |; p8 A9 K* Z
35.                 authParts := strings.Split(context.GetHeader("authorization"), " ")
    
36.                 if len(authParts) != 2 {
    ' G- D$ p' z! W' T" y' @
37.                         context.AbortWithStatusJSON(401, map[string]any{
    $ E/ b/ N' A; `2 @' ]
38.                                 "message": "Unauthorized",
      ~" C# \$ l. Z' A8 u/ }- ~) n3 s
39.                         })
    ) M, p# Y0 e0 ]) I& B1 @9 L
40.                         return
    
41.                 }
    2 t5 Y% A7 z# A/ d  h. J; @' K
42. 
    * X3 d! m; W/ e
43.                 authType := authParts[0]
    
44.                 authData := authParts[1]
    
45. 
    ; S6 n% |9 x# ?& h( X) u
46.                 switch authType {
    
47.                 case "tma":
    & V+ a& ^! q$ V. [4 E5 ^
48.                         // Validate init data. We consider init data sign valid for 1 hour from their
    4 v" y- t& f. L$ [
49.                         // creation moment.
    
50.                         if err := initdata.Validate(authData, token, time.Hour); err != nil {
    & @, S0 [8 ~5 T, D
51.                                 context.AbortWithStatusJSON(401, map[string]any{
    
52.                                         "message": err.Error(),
    
53.                                 })
    
54.                                 return
    0 e" n) V$ B" r. \; j% h/ n9 H2 Q
55.                         }
    
56. 
    # C/ J' A& p) W" z+ {2 E% W  |
57.                         // Parse init data. We will surely need it in the future.
    ( R" T0 o$ M# O0 T  y& \
58.                         initData, err := initdata.Parse(authData)
    
59.                         if err != nil {
    ! S- N  x1 u" ?
60.                                 context.AbortWithStatusJSON(500, map[string]any{
    
61.                                         "message": err.Error(),
    $ u( w, y: n( l2 r4 N6 w, ^2 \9 Q0 s8 B  T
62.                                 })
    
63.                                 return
    
64.                         }
    / ~" a3 `7 u. F  l% ~% b
65. 
    
66.                         context.Request = context.Request.WithContext(
    
67.                                 withInitData(context.Request.Context(), initData),
    
68.                         )
    
69.                 }
    6 _6 z* \% m6 y: C# Q* C
70.         }
    
71. }
    
72. 
    ) z! P1 x' ]+ ~7 e
73. // Middleware which shows the user init data.
    
74. func showInitDataMiddleware(context *gin.Context) {
    
75.         initData, ok := ctxInitData(context.Request.Context())
    
76.         if !ok {
    
77.                 context.AbortWithStatusJSON(401, map[string]any{
    " A: ~: J3 m' i8 W; ]
78.                         "message": "Init data not found",
    
79.                 })
    4 x2 o% A+ |! m( W
80.                 return
    1 d8 {* c( N$ I
81.         }
    - J! J9 V% ~$ M5 L) l
82. 
    ' {& e! n2 T  n* {
83.         context.JSON(200, initData)
    
84. }
    
85. 
    - H' X) M3 H- R" p: H
86. func main() {
    - R5 ~" {, W- ^* b: R0 U
87.         // Your secret bot token.
    
88.         token := "1234567890:ABC"
    & ^6 ?" ^6 q# ^' I! b8 H2 s9 c, A3 z
89. 
    # }  x0 A4 x+ B$ U3 d) w
90.         r := gin.New()
    : a. _9 [4 H& }" l5 o$ ?
91. 
    $ c7 r8 O) U5 T5 C
92.         r.Use(authMiddleware(token))
    / a6 @! T0 ]$ g5 T9 E# L: P1 F
93.         r.GET("/", showInitDataMiddleware)
    
94. 
    
95.         if err := r.Run(":3000"); err != nil {
    ' D( o) T6 A4 p- i- l: j8 ]3 l
96.                 panic(err)
    
97.         }
    
98. }

复制代码