Telegram小程序 指南 | 授权用户

riyad

5 B) w' d4 C0 I) y# [

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

客户端​

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

1. import { retrieveLaunchParams } from '@telegram-apps/sdk';
   3 X/ C6 t7 h( k2 ^& v
2. 
   & P: r# l! T" P2 N! ~
3. const { initDataRaw } = retrieveLaunchParams();
   & S; |' p3 {# |0 ?
4. 
   $ X; A, q6 H; S( j2 K% }' w3 s3 b2 z
5. fetch('https://example.com/api', {
   + z& p: ?5 E" h4 [0 g& M4 o6 R
6.   method: 'POST',
   1 W9 i  z# [3 X
7.   headers: {
   
8.     Authorization: `tma ${initDataRaw}`
   ( D! m' P  B- x% V( M' W, k
9.   },
   . o& W5 R4 r1 U# `6 _4 ]$ c4 D
10. });

复制代码

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

% o% c$ f! W: {服务器端​

现在，当 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. 
     W9 `9 C2 ^7 H* j  g- [
8. /**
   ( w# D  f2 [" _, [5 C; K- e, ?7 P
9. * Sets init data in the specified Response object.
   , M' c) L1 Z0 r2 C' D: e$ ~
10. * @param res - Response object.
    
11. * @param initData - init data.
    . j/ f  W8 p: `1 f. @$ ^4 \+ n
12. */
    
13. function setInitData(res: Response, initData: InitDataParsed): void {
    
14.   res.locals.initData = initData;
    
15. }
    
16. 
    / U' S) R8 F" e1 X* u6 p
17. /**
    3 n, r' X" H# p" Z
18. * Extracts init data from the Response object.
      u+ \. [6 I  m3 }
19. * @param res - Response object.
    . t& V8 p7 b1 I2 L1 p
20. * @returns Init data stored in the Response object. Can return undefined in case,
    
21. * the client is not authorized.
    ! K5 C/ F! g7 M8 M1 d
22. */
    
23. function getInitData(res: Response): InitDataParsed | undefined {
    # H% S/ Q4 ]: y
24.   return res.locals.initData;
    
25. }
    ' V- N" [" J, n1 V" L% h* Z/ j' X
26. 
    
27. /**
    9 Y8 ~, `2 {: O, v9 \, X/ R! [
28. * Middleware which authorizes the external client.
    
29. * @param req - Request object.
    & k$ `& x( Q2 e& R+ s4 J( o+ x
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:
    " s" l# K5 |) h5 ]& X# c+ G
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(' ');
    + F: G( q8 K; G9 P. {* A
38. 
    
39.   switch (authType) {
    # T& [" s; u6 D* N5 x, z# l2 }
40.     case 'tma':
    2 M# {5 r9 ]& \4 c# K$ g
41.       try {
    
42.         // Validate init data.
    4 A/ d/ d  k0 m' W) n1 e/ }
43.         validate(authData, token, {
    * v! ?" m9 l) p2 g' c: F) w
44.           // We consider init data sign valid for 1 hour from their creation moment.
    , A- b' u& U+ V9 [$ s" N' _) m5 @
45.           expiresIn: 3600,
    
46.         });
    
47. 
    & C7 U' k# v0 H' d  |- Z# e
48.         // Parse init data. We will surely need it in the future.
    
49.         setInitData(res, parse(authData));
    5 q5 z8 k9 G! z. k$ [) l
50.         return next();
    & w. S6 ~/ C8 G' S) o6 o) Z
51.       } catch (e) {
    8 @* n7 A& l3 O6 K; z
52.         return next(e);
    ! y1 a$ Q# V- D9 Y4 {2 p! s( X- _- `
53.       }
    % Y; I" I" ~/ O  [
54.     // ... other authorization methods.
    # z3 x4 N; b: n" H8 q2 o( h' u6 U2 S
55.     default:
    
56.       return next(new Error('Unauthorized'));
    
57.   }
    5 L. ~9 }# ^4 ?1 _9 ]* B( a4 Q/ k
58. };
    4 I. Y1 q0 [) @4 p6 V( X. E+ F/ A
59. 
    
60. /**
    
61. * Middleware which shows the user init data.
    , e6 `9 i# |8 k  ?0 Z
62. * @param _req
    $ Q3 n8 H0 h# z" v: ~
63. * @param res - Response object.
    : [2 V$ N* R# A" k/ S5 Z: B  ^; R, [
64. * @param next - function to call the next middleware.
    
65. */
    
66. const showInitDataMiddleware: RequestHandler = (_req, res, next) => {
    
67.   const initData = getInitData(res);
    
68.   if (!initData) {
    * s  k8 V0 o' f0 @
69.     return next(new Error('Cant display init data as long as it was not found'));
    
70.   }
    
71.   res.json(initData);
    ! Y3 d. ~0 ]4 H4 P, v
72. };
    
73. 
    # e8 w1 V5 n: U" r$ G: w
74. /**
    
75. * Middleware which displays the user init data.
    
76. * @param err - handled error.
    
77. * @param _req
    3 ~, p( b  a% y* C4 E3 q. J
78. * @param res - Response object.
    
79. */
    
80. const defaultErrorMiddleware: ErrorRequestHandler = (err, _req, res) => {
    
81.   res.status(500).json({
    0 s+ P8 [: s0 _, {9 ?+ }
82.     error: err.message,
    9 c% p9 ?& |8 S: U) \, @  x
83.   });
    ( h- L6 W1 y, W5 t3 L5 X
84. };
    & x. i3 _1 U& s& y5 ~
85. 
    5 H- y4 y& s7 C7 X5 s- q
86. // Your secret bot token.
    
87. const token = '1234567890:ABC';
    
88. 
    
89. // Create an Express applet and start listening to port 3000.
    8 J, l! |) V* i, W2 a
90. const app = express();
    ' a: r" H0 g3 i' v( I. G# n
91. 
    
92. app.use(authMiddleware);
    : m7 Y! f, }$ t7 Z5 j2 F
93. app.get('/', showInitDataMiddleware);
    
94. app.use(defaultErrorMiddleware);
    
95. 
    
96. app.listen(3000);
    
97. 
    - ~7 O' u( m2 b4 `6 W0 ~4 @
98. // After the HTTP server was launched, try sending an HTTP GET request to the URL
    - x; G7 q9 \% _8 D
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. 
   
3. import (
   
4.         "context"
   / @& J$ n5 s2 Z8 u9 |$ K4 Y
5.         "strings"
   
6.         "time"
   8 j( \% Z9 @0 G! B9 d: ]5 B5 J
7. 
   
8.         "github.com/gin-gonic/gin"
   - w. J: T# H! S3 Y, P1 K9 `! ], S
9.         initdata "github.com/telegram-mini-apps/init-data-golang"
   9 r/ A: i; l9 [3 q4 A% T
10. )
    
11. 
    
12. type contextKey string
    
13. 
    
14. const (
    3 X+ o. e2 X) o0 k( |
15.         _initDataKey contextKey = "init-data"
    
16. )
    
17. 
    
18. // Returns new context with specified init data.
    # m. `! R: N; Y) X7 y9 T  f% G* q1 d
19. func withInitData(ctx context.Context, initData initdata.InitData) context.Context {
    
20.         return context.WithValue(ctx, _initDataKey, initData)
    ; u  E. Q5 o3 t1 y( T( @
21. }
    
22. 
    
23. // Returns the init data from the specified context.
    + |+ \. T4 }0 m- @, z& B
24. func ctxInitData(ctx context.Context) (initdata.InitData, bool) {
    
25.         initData, ok := ctx.Value(_initDataKey).(initdata.InitData)
    
26.         return initData, ok
    + P* Q) U  h9 \. A
27. }
    ( t; y; G  U7 s6 L
28. 
    
29. // Middleware which authorizes the external client.
    
30. func authMiddleware(token string) gin.HandlerFunc {
    ! R5 j/ Y: W; i# @
31.         return func(context *gin.Context) {
    
32.                 // We expect passing init data in the Authorization header in the following format:
    
33.                 // <auth-type> <auth-data>
    
34.                 // <auth-type> must be "tma", and <auth-data> is Telegram Mini Apps init data.
    
35.                 authParts := strings.Split(context.GetHeader("authorization"), " ")
    4 I9 |) y! m! F( M
36.                 if len(authParts) != 2 {
    5 Q' N# h  C( o" u" A- u
37.                         context.AbortWithStatusJSON(401, map[string]any{
    5 C8 X# C& K( V) E& K# \+ q  }; Z
38.                                 "message": "Unauthorized",
    ' c, i7 `5 o1 N& o
39.                         })
    
40.                         return
    ! z# o3 ~, V  Y! h
41.                 }
    - h3 P. {0 D: Y, s4 D5 d% ~( k" Z
42. 
    
43.                 authType := authParts[0]
    2 V2 K  D$ w: e- Y! }1 o3 V" ^$ A4 @
44.                 authData := authParts[1]
    ' f; w9 T' T3 p# y
45. 
    
46.                 switch authType {
    
47.                 case "tma":
    " G# S$ v2 F7 [! t! p& ~/ Y7 j1 I
48.                         // Validate init data. We consider init data sign valid for 1 hour from their
    
49.                         // creation moment.
    . c9 N( |' c2 @7 e  E; I( ?; Y
50.                         if err := initdata.Validate(authData, token, time.Hour); err != nil {
    * h  c# N8 I  O* c/ l' Q3 e
51.                                 context.AbortWithStatusJSON(401, map[string]any{
    
52.                                         "message": err.Error(),
    0 _$ a/ t! T4 `' N5 O+ m% k) m: p
53.                                 })
    " i) I9 ~9 B2 h
54.                                 return
    : U4 a+ G# e3 f6 Q* {; n
55.                         }
    
56. 
    
57.                         // Parse init data. We will surely need it in the future.
    
58.                         initData, err := initdata.Parse(authData)
    - ]. c) a# d5 t; L3 `2 r2 F4 a
59.                         if err != nil {
    2 n5 \. d& |& v5 v" o5 c% S
60.                                 context.AbortWithStatusJSON(500, map[string]any{
    4 u5 n7 t: E8 c
61.                                         "message": err.Error(),
    
62.                                 })
    8 Z/ v6 E! i" o2 f9 l6 f6 t
63.                                 return
    
64.                         }
    
65. 
    
66.                         context.Request = context.Request.WithContext(
    
67.                                 withInitData(context.Request.Context(), initData),
    ' _+ a( |4 P1 [: \8 p
68.                         )
    
69.                 }
    
70.         }
    
71. }
    
72. 
    7 @* S; p* F) M% h: H
73. // Middleware which shows the user init data.
    
74. func showInitDataMiddleware(context *gin.Context) {
    # I9 o: M' Z2 I6 I2 J! e' w
75.         initData, ok := ctxInitData(context.Request.Context())
    0 D! J/ A& U) i0 E; a) T. H
76.         if !ok {
    & o0 D1 @' \: S0 z/ ?8 Y1 X
77.                 context.AbortWithStatusJSON(401, map[string]any{
    ' a3 ]5 q5 e. [$ f
78.                         "message": "Init data not found",
    
79.                 })
    : i0 K+ ~# H* h& k) x( Y7 I2 r/ \
80.                 return
    4 ?2 o5 `6 b% v- g. }
81.         }
    ! w) h  z/ }. O" `
82. 
    
83.         context.JSON(200, initData)
    
84. }
    
85. 
    ! \: M+ `1 ]! m2 @1 {( W% A0 `
86. func main() {
    
87.         // Your secret bot token.
    ! y6 B# R! l. ]6 |" q
88.         token := "1234567890:ABC"
    / t$ q' c) y4 Q0 ~! `- T  ^
89. 
    . r' x# |  }) x; }3 b
90.         r := gin.New()
    + C! f9 C  X" j' U1 j
91. 
    ' c! h4 E0 N# X( E8 }' Y  u! B
92.         r.Use(authMiddleware(token))
    
93.         r.GET("/", showInitDataMiddleware)
    # o) _$ N4 a, T) S
94. 
    * O7 r, o+ g: o3 I5 |6 o1 a3 F3 I
95.         if err := r.Run(":3000"); err != nil {
    % h1 S1 l: R2 X4 y4 n6 h
96.                 panic(err)
    
97.         }
    
98. }

复制代码

) ^* a  f: ?+ [+ G7 }) q
% w  ]. O8 O8 d- ?