Telegram小程序 指南 | 授权用户

riyad

/ E: m' \& K/ l- I# \1 k7 C

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

客户端​

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

1. import { retrieveLaunchParams } from '@telegram-apps/sdk';
   ! V: c: R, U. \- C9 V0 g! k
2. 
   
3. const { initDataRaw } = retrieveLaunchParams();
   
4. 
   # f9 r5 {) Z) B, P3 N. S
5. fetch('https://example.com/api', {
   
6.   method: 'POST',
   . T- A' u) ?3 @$ M+ J1 m
7.   headers: {
   
8.     Authorization: `tma ${initDataRaw}`
   
9.   },
   
10. });

复制代码

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

' f3 m% c2 f, R# U服务器端​

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

Node.js​

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

1. import { validate, parse, type InitDataParsed } from '@telegram-apps/init-data-node';
   
2. import express, {
   
3.   type ErrorRequestHandler,
   
4.   type RequestHandler,
   
5.   type Response,
   
6. } from 'express';
   
7. 
   
8. /**
   . b: x* s: C5 f
9. * Sets init data in the specified Response object.
   
10. * @param res - Response object.
    # \/ D0 x, @; O) g0 `
11. * @param initData - init data.
    
12. */
    2 Z- o3 a7 j# b! l
13. function setInitData(res: Response, initData: InitDataParsed): void {
    
14.   res.locals.initData = initData;
    5 K) E( e7 q- F2 C" _
15. }
    % x4 T9 V, F6 i& E
16. 
    
17. /**
    
18. * Extracts init data from the Response object.
    
19. * @param res - Response object.
    
20. * @returns Init data stored in the Response object. Can return undefined in case,
    
21. * the client is not authorized.
    : ]) h6 B2 x1 S
22. */
    
23. function getInitData(res: Response): InitDataParsed | undefined {
    3 ]# M( ]! w! R' y
24.   return res.locals.initData;
    $ K$ f: O3 x7 V$ Q2 I
25. }
    ! r! D0 F: w2 [  p5 S# x
26. 
    ; c' y9 F- r( V, @2 D' x" s4 N
27. /**
    
28. * Middleware which authorizes the external client.
    0 ~9 W2 J' B1 o/ J
29. * @param req - Request object.
    7 A: t3 [8 G+ t9 y" E. n' W! ]" B
30. * @param res - Response object.
    
31. * @param next - function to call the next middleware.
    
32. */
    
33. const authMiddleware: RequestHandler = (req, res, next) => {
    
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.
    ) B) F/ m8 J+ }  Y' i* _9 S" o
37.   const [authType, authData = ''] = (req.header('authorization') || '').split(' ');
    3 Z( w4 q2 J$ P/ {8 g( \. M! ~
38. 
    
39.   switch (authType) {
    
40.     case 'tma':
    : Y$ z# I, z) U! p, a! ]
41.       try {
    
42.         // Validate init data.
    ) e0 F. K5 j# [9 I' T  |+ p& f
43.         validate(authData, token, {
    
44.           // We consider init data sign valid for 1 hour from their creation moment.
    
45.           expiresIn: 3600,
    ' d( }4 r* B, `: y+ i
46.         });
    
47. 
    + @/ z9 n6 B' ~2 m4 q. _4 |0 G1 S
48.         // Parse init data. We will surely need it in the future.
    ) h, x1 ^8 k: A( ?" t
49.         setInitData(res, parse(authData));
    
50.         return next();
    
51.       } catch (e) {
    + P3 y7 Z+ h4 h
52.         return next(e);
    
53.       }
    
54.     // ... other authorization methods.
    
55.     default:
    2 v6 O# H- Z) l7 n) p, W6 M, H' V
56.       return next(new Error('Unauthorized'));
    ! V7 w- K0 |0 B+ C& h7 l
57.   }
      K1 l, Y6 S$ U
58. };
    
59. 
    
60. /**
    
61. * Middleware which shows the user init data.
    
62. * @param _req
    
63. * @param res - Response object.
    
64. * @param next - function to call the next middleware.
    
65. */
    ) f6 }% c# G* @2 k- |& Y& `% V
66. const showInitDataMiddleware: RequestHandler = (_req, res, next) => {
    2 M) H; f/ e  ~. t( x
67.   const initData = getInitData(res);
    ! z- t& z* k8 Y5 X& o
68.   if (!initData) {
    " k' v. ]2 Q+ ~
69.     return next(new Error('Cant display init data as long as it was not found'));
    
70.   }
    * Q) a. K3 j1 N: ]9 J1 b3 ^
71.   res.json(initData);
    9 w; o8 H$ X' j
72. };
    2 ~/ g+ J8 l$ U0 ~0 e/ i
73. 
    
74. /**
    
75. * Middleware which displays the user init data.
    ' C# C$ J6 |9 Y0 s) C: J
76. * @param err - handled error.
    
77. * @param _req
    
78. * @param res - Response object.
    
79. */
    + _# g; y# m0 a( c3 y
80. const defaultErrorMiddleware: ErrorRequestHandler = (err, _req, res) => {
    5 ~1 `: \: y5 F$ {: g/ T/ b
81.   res.status(500).json({
    
82.     error: err.message,
    
83.   });
    
84. };
    
85. 
    & V& R' q. W5 h
86. // Your secret bot token.
    4 I; K% s. p: P" C
87. const token = '1234567890:ABC';
    ; `8 C/ E. G  _6 T) e
88. 
    
89. // Create an Express applet and start listening to port 3000.
    
90. const app = express();
    - Y- Z; e4 O; @: t6 g
91. 
    & M( L8 g/ w2 J2 v- N" r
92. app.use(authMiddleware);
    ; \7 f2 ?4 V" U
93. app.get('/', showInitDataMiddleware);
    % e" Z8 o+ C$ h$ }) P/ a+ V+ m
94. app.use(defaultErrorMiddleware);
    5 m4 _) q2 s3 [: ^: B
95. 
    
96. app.listen(3000);
    
97. 
    ' ~7 v7 ~# M5 e, ^
98. // After the HTTP server was launched, try sending an HTTP GET request to the URL
    / ]1 ]3 C$ ~: E( i. @0 p
99. // http://localhost:3000/ with an Authorization header containing data in the required format.

复制代码

6 M) k4 @' }0 r9 Q  r, ^GoLang[color=var(--vp-c-brand-1)]​

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

1. package main
   $ e$ X6 S4 U! I7 ?
2. 
   ! W& \4 G2 a, X4 N
3. import (
   
4.         "context"
   
5.         "strings"
   ; A- e  S) b$ F, I" d  T! K7 C
6.         "time"
   % o- t8 E( P) J& T- k3 h5 g: [9 g
7. 
   ) J& [. U9 G3 h$ u/ p& b/ D
8.         "github.com/gin-gonic/gin"
   
9.         initdata "github.com/telegram-mini-apps/init-data-golang"
   
10. )
    4 Y, d* X' U# @) {4 [" O; t6 F! D
11. 
    / `7 k. Y3 E' H) P; o0 F5 b
12. type contextKey string
    
13. 
    ' W7 ~" T) S0 h- q. x
14. const (
    0 t; S" c$ d) s/ m  }
15.         _initDataKey contextKey = "init-data"
    
16. )
    
17. 
    
18. // Returns new context with specified init data.
    4 i/ u* y- P' p" u* t
19. func withInitData(ctx context.Context, initData initdata.InitData) context.Context {
    
20.         return context.WithValue(ctx, _initDataKey, initData)
    
21. }
    
22. 
    
23. // Returns the init data from the specified context.
    : U! L# r6 n+ ]/ e( o9 G4 _% P2 \
24. func ctxInitData(ctx context.Context) (initdata.InitData, bool) {
    0 v" \6 b' M) t* o1 a3 p; a
25.         initData, ok := ctx.Value(_initDataKey).(initdata.InitData)
    * k$ z, ?8 ^4 U/ r
26.         return initData, ok
    
27. }
    
28. 
    
29. // Middleware which authorizes the external client.
    
30. func authMiddleware(token string) gin.HandlerFunc {
    
31.         return func(context *gin.Context) {
    0 J8 ^8 D- i; u  \) [3 r& d
32.                 // We expect passing init data in the Authorization header in the following format:
    0 |) G6 U7 P; R  j" n5 @7 ^
33.                 // <auth-type> <auth-data>
    . `' M6 H2 X3 b1 V0 M$ [
34.                 // <auth-type> must be "tma", and <auth-data> is Telegram Mini Apps init data.
    
35.                 authParts := strings.Split(context.GetHeader("authorization"), " ")
    
36.                 if len(authParts) != 2 {
    
37.                         context.AbortWithStatusJSON(401, map[string]any{
    : D$ |* D- n* x5 J) g4 y& {+ k
38.                                 "message": "Unauthorized",
    
39.                         })
    8 _6 Q4 I# H4 _# k6 F" U' |4 N3 X
40.                         return
    
41.                 }
    : C0 w) _3 c. U7 i
42. 
    4 E( |3 {) S) L9 w5 a
43.                 authType := authParts[0]
    $ ~7 K# T6 R  E7 t( f( D
44.                 authData := authParts[1]
    - Z2 R- t: Q3 i6 S. w
45. 
    5 ^4 N7 z: j1 y- s
46.                 switch authType {
    ; N3 h/ ?( ]8 P7 x
47.                 case "tma":
    5 X2 o) }+ R) `0 P( ~2 M6 ?0 p6 v
48.                         // Validate init data. We consider init data sign valid for 1 hour from their
    * E! i, `3 I# Y+ C! @
49.                         // creation moment.
    ) @: ]- S1 ]' g7 x
50.                         if err := initdata.Validate(authData, token, time.Hour); err != nil {
    
51.                                 context.AbortWithStatusJSON(401, map[string]any{
    
52.                                         "message": err.Error(),
    
53.                                 })
    
54.                                 return
    , U* o+ N3 K3 P/ X
55.                         }
    
56. 
    7 O$ g+ P0 E. N5 |; r* L, J
57.                         // Parse init data. We will surely need it in the future.
    
58.                         initData, err := initdata.Parse(authData)
    
59.                         if err != nil {
    
60.                                 context.AbortWithStatusJSON(500, map[string]any{
    
61.                                         "message": err.Error(),
    " C  i8 m: {% h$ \: @
62.                                 })
    " s4 E' W  H; L; c" Z3 w
63.                                 return
    8 c8 m# E. f4 \4 s- e- _! `8 J1 E
64.                         }
    5 Y8 ~( |9 Z7 t2 c) L# q; V
65. 
    
66.                         context.Request = context.Request.WithContext(
    
67.                                 withInitData(context.Request.Context(), initData),
    
68.                         )
    
69.                 }
    
70.         }
    ' B9 Z" z3 F7 i+ N4 E7 o7 l
71. }
    
72. 
    
73. // Middleware which shows the user init data.
    
74. func showInitDataMiddleware(context *gin.Context) {
    
75.         initData, ok := ctxInitData(context.Request.Context())
    ( |  `1 l+ m) {
76.         if !ok {
    5 O% G# q1 a( `0 W# Q5 q4 h
77.                 context.AbortWithStatusJSON(401, map[string]any{
    $ M* C. c) r7 K7 w) Q8 W
78.                         "message": "Init data not found",
    9 k: `6 ]; H4 ]$ O
79.                 })
    , e- P. C& W. ^: R+ L& e3 B* j
80.                 return
    
81.         }
    7 U* q' T+ ]0 }: a; M/ C+ B
82. 
    
83.         context.JSON(200, initData)
    " |/ [8 ^! ~- R6 Y' {% R, b5 J
84. }
    
85. 
    
86. func main() {
    
87.         // Your secret bot token.
    % O! D8 u& a5 Z
88.         token := "1234567890:ABC"
    ' d" X' ]! s; n  U7 a0 k
89. 
    / P1 o6 T3 B- T& b+ U" B' J
90.         r := gin.New()
    
91. 
    $ j8 E* _6 n6 }* p3 P6 b
92.         r.Use(authMiddleware(token))
    
93.         r.GET("/", showInitDataMiddleware)
    
94. 
    
95.         if err := r.Run(":3000"); err != nil {
    
96.                 panic(err)
    4 [& @/ U+ k' S" C( |5 h
97.         }
    , m% A6 m& v# i& L$ z9 o! g
98. }

复制代码

2 }9 A" [1 F1 k1 B  d$ j- A0 G9 r