Objets connectés : comment récupérer des données apis, web-services, Json, etc

**aladin95** · 19/12/2018, 15h14

Bonjour a tous,
J'ai un dispositif connecté par Sigfox.

j'ai les infos nécessaires a la récupération des données mais cela commence par une authentification qui déjà me pose problème.

il est dit :
Authentification par tocken OAuth2

Pour récupérer le token il faut faire une requête POST en url encode sur l'url "https://apis.... etc

Comment faire ça en Delphi XE5 pour Windows 10 ??

Peut-on tester a l'aide de l'outil RestDebugger ?.

Merci d'avance.
et joyeuses fêtes aux lecteurs

**gbegreg** · 19/12/2018, 19h50

Bonsoir,

Je n'ai plus XE5 sous la main pour vérifier, mais normalement, vous avez dans la rubrique "REST Client" dans la palette des composants. Il y a tout ce qu'il faut pour répondre à votre besoin :
- TRESTClient : représentant le client REST;
- TOAuth2Authenticator à associer à la propriété Authentificator du TRESTClient pour gérer l'authentification OAuth2 ;
- TRESTRequest : associé également au TRESTClient, pour la requête REST proprement dite.

Pour l'url encode, il s'agit simplement d'une conversion de la chaine de caractères afin qu'elle corresponde à une url (exemple de modifications apportées : remplacement des espaces par %20). Pour ce faire, il y a la fonction urlencode de idURI :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
urlencodee := TIdURI.URLEncode('http://www.site.fr/page.php?param1="toto titi"');

Enfin, il est possible de tester cela avec l'outil RESTDebugger. L'avantage de cet outil, c'est qu'une fois votre requête au point, il est possible de "copier les composant" et ainsi de coller tout le nécessaire dans votre fiche.

**aladin95** · 21/01/2019, 14h30

Merci de ces infos.
J'attendais une réponse du SAV de cet objet et j'ai pu me connecter par Postman
je vous joins une copie de cette connexion pour que vous puissiez m'indiquer, si vous voulez bien, les équivalences avec REST DEBUGGER

C'est la 1ere étape de la récupération

puis on explique :
le header des requêtes suivantes doit contenir :
authorization : bearer <valeur du token>

puis faire une requete GET sur une 2eme URL qui contient l'ID de l'objet {serial}

exemples de requête :
https://apis.goflipr.com/modules/{serial}/survey/last
https://apis.goflipr.com/modules/{serial}/survey/lasthours/{heure}
https://apis.goflipr.com/modules/{serial}/survey/statsperdays/days}

J'ai bien récupéré le token par Postman mais je n'arrive pas a récupérer les valeurs en intégrant ce TOKEN

merci par avance

**SergioMaster** · 21/01/2019, 17h09

Bonjour,
Comme l'a indiqué gbgreg, utilisez le débogueur REST
1 - dans le premier onglet indiquez l'adresse GET
2 - dans le second indiquez les paramètres
3 - dans le dernier l'authentification nécessaire

par exemple : pour obtenir les comptes
1 - https://apis.goflipr.com/acounts
2 - ajouter le paramètre token et indiquer la valeur
3 - se passe de commentaire

**popo** · 21/01/2019, 17h21

Pour obtenir les données, il faut passer le token obtenu dans l'en-tête de la requête sous le terme "Authorization"
Dans l'illustration jointe, remplacer {{token}} par le contenu de "access_token" de la requête précédente, et remplacer {serial} par une données pertinente
Nom : 2019-01-21_171728.png
Affichages : 1678
Taille : 9,8 Ko

Nom : 2019-01-21_171728.png
Affichages : 1678
Taille : 9,8 Ko

**aladin95** · 21/01/2019, 18h14

pour Sergio
dans l'onglet authentication j'ai mis oauth2 mais apres 4 cases sont proposées que je ne sais remplir
4 autres sont grisées donc inutilisables
ce qui me retourne 400:Bad Request..

J'aimerais bien passer cette etape pour integrer cela dans du code delphi car sauf erreur la 2eme me semble liée a la réponse dans un délai restreint a la 1ere
le token doit varier dans le temps

Merci de votre aide et désolé si je ne suis vraiment pas familiarisé avec ces procédures

**SergioMaster** · 22/01/2019, 09h11

Envoyé par aladin95

dans l'onglet authentication j'ai mis oauth2 mais apres 4 cases sont proposées que je ne sais remplir
4 autres sont grisées donc inutilisables
ce qui me retourne 400:Bad Request..

Que cela retourne BAD Request c'est normal.
Je ne connais pas le type d'authentification Auth2 donc je ne sais que répondre, avez vous remarqué qu'il y a aussi un assistant pour configurer auth ? (bouton)
Un peu de recherche et :

J'aimerais bien passer cette etape pour integrer cela dans du code delphi car sauf erreur la 2eme me semble liée a la réponse dans un délai restreint a la 1ere
le token doit varier dans le temps

il semblerai que le token puisse se renouveler

Merci de votre aide et désolé si je ne suis vraiment pas familiarisé avec ces procédures

Je ne le suis pas davantage il faut surfer sur le net pour obtenir des réponses

**popo** · 22/01/2019, 13h16

Envoyé par aladin95

pour Sergio
dans l'onglet authentication j'ai mis oauth2 mais apres 4 cases sont proposées que je ne sais remplir
4 autres sont grisées donc inutilisables
ce qui me retourne 400:Bad Request..

L'onglet Authorization sert pour obtenir le token.
L'OAUTH V2 implique que tu sois détenteur d'un ClientId, d'un ClientSecret, et optionnellement d'un Scope indiquant le type de données que tu vas chercher à obtenir.
Le fournisseur de l'API doit également t'indiquer quel Grant Type utiliser.
Se sont les zones qui te sont présentées dans l'IHM de PostMan et que tu ne sais pas remplir.
Mais tu n'a pas besoin de cet onglet puisque tu as déjà obtenu le token... (c'est la réponse à la requête que tu présente dans ton impression d'écran)

Envoyé par aladin95

J'aimerais bien passer cette etape pour integrer cela dans du code delphi car sauf erreur la 2eme me semble liée a la réponse dans un délai restreint a la 1ere
le token doit varier dans le temps

Le token ne varie pas, il a une durée de vie qui est portée dans la propriété "expires_in" de la réponse que tu as déjà obtenu (toujours celle de ton impression écran).
En règle générale, cette durée de vie est exprimée en secondes et une fois ce délai écoulé, tu doit redemander un jeton en te servant de la valeur de "refresh_token". La procédure dépend de l'implémentation de l'API. Tu doit donc demander à ton fournisseur de t'expliquer la marche à suivre pour renouveler le token.

Mais lorsque tu as un token valide (non expiré), c'est donc dans l'onglet Header que ça se passe.
Il te suffit de suivre ce que j'ai noté dans mon précédent message pour que ça marche.

**aladin95** · 23/01/2019, 11h07

Merci Popo
sous postman, la requête a fonctionné j'ai les résultats escomptés

Il me reste a transposer tout ça sous Rest debugger

sous REQUEST :
GET : j'ai noté l'URL composée idem postman
Content-type : j'ai tout essayé mais je pense que urlencode est le bon type
custom body : vide

sous Parameters:
ressource : laissé vide

request parameters :
[HEADER] authorisation=bearer ey...anx0 (la chaine complete sans " )

sous Authentication :
none

Sous Connection :
Use proxy decoché
je vois apparaitre mon username et mon login

et la requete me retourne 401:unauthorized...

**popo** · 24/01/2019, 17h25

Désolé, je ne connais pas RestDebogger.
Je ne vais pas pouvoir t'aider à tester avec cet outil.

Mais si ça marche sur PostMan, ça devrait fonctionner avec les composant REST de Delphi.
N'hésite pas à revenir si tu as difficulté avec ces composants

**aladin95** · 24/01/2019, 17h36

je vais essayer.. merci

Sinon, pour info, c'est un outil gratuit qu'on trouve sur https://www.embarcadero.com/fr/free-tools/rest-debugger

et en principe cela permet de générer les composants qui vont bien

**aladin95** · 03/03/2019, 15h59

je reviens sur ce problème pour demander si qqn connait l'usage des composants REST et sait comment les utiliser pour solutionner cette interrogation de cet objet connecté.
Je voudrais intégrer tout cela dans un service Windows pour automatiser la récupération des données.

j'ai suivi les exemples sous postman et je vous indique les paramètres utilisés

en principe il y a 2 parties :

Récupérer le token
pour cela faire une requête POST sur une Url indiquée par le fabriquant ex https://apis.golflipr.com/OAuth2/token
dans la partie body
x-www-form-urlencoded coché
le tableau KEY / Value / description
Key 1 : grant_type : password
Key 2 : password : <mon mot de passe d’accès a l'objet>
Key 3 : username : <mon login>
apres le send
je recupere :
1 {
2 "acces_token": "<chaine 1>",
3 "token_type": bearer",
4 "expires_in": 1799,
5 "refresh_token": "<chaine 2>"
6 }

Récupérer les données
cette fois une requête GET sur une url spécifique https://apis.golflipr.com/xx.... a la nature des données récupérées
et dans le Body
key 1 authorization : bearer "<chaine1>" (c'est la chaine 1 recupérée ci dessus)
puis après Send
je récupère une chaîne complète xml avec les données

j'aimerais transposer tout ça en delphi XE5 (mini) pour intégration dans mon service

j'ai fais quelques tentatives sans succès y compris en essayant Rest Debugger (impossible de récupérer les mêmes données. Je ne parviens pas a le paramétrer correctement)

merci d'avance a celui ou ceux qui me permettrons cela

**ShaiLeTroll** · 04/03/2019, 08h37

en XE2, j'ai fait un connecteur pour un WebService développé en PHP Symfony avec une Bearer Auth

Si ça peut aider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
unit Slite.WS.REST;
 
interface
 
uses System.SysUtils, System.Classes, System.Types, System.Generics.Collections,
  Data.DBXJSON,
  IdHTTP, IdURI, IdAuthentication, IdHeaderList, IdStack;
 
type
  { Forward class declarations }
  TSliteRESTClient = class;
  ESliteRESTClientError = class;
  TSliteSymfonyWebServiceClient = class;
 
  { Class declarations }
 
  /// <summary>Classe encapsulant les WebServices REST</summary>
  TSliteRESTClient = class(TObject)
  public
    type
      THTTPVerb = IdHTTP.TIdHTTPMethod;
      THTTPVerbType = (vtGET, vtPOST, vtPUT, vtDELETE, vtPATCH);
      THTTPIgnoredErrorCodes = array of SmallInt;
    const
      HTTP_VERBS: array[THTTPVerbType] of THTTPVerb = (Id_HTTPMethodGet, Id_HTTPMethodPost, Id_HTTPMethodPut, Id_HTTPMethodDelete, 'PATCH');
      HTTP_RESULT_CODE_NO_CONTENT = 204;
  strict protected
    type
      /// <summary>Classe gérant les requetes HTTP avec Entrée et Sortie en JSON</summary>
      TJSONRequester = class(TIdHTTP)
      public
        constructor Create(AOwner: TComponent);
      end;
      /// <summary>Classe gérant les requetes HTTP</summary>
      TRESTRequester = class(TJSONRequester)
      strict private
        FParent: TSliteRESTClient;
        FURIBase: string;
      public
        property Parent: TSliteRESTClient read FParent write FParent;
        property URIBase: string read FURIBase write FURIBase;
      end;
  strict private
    FRESTRequester: TRESTRequester;
    FLastErrorMessage: string;
    FLastResultCode: Integer;
  strict protected
    property RESTRequester: TRESTRequester read FRESTRequester;
  protected
    procedure DoRequest(const AHTTPVerb: TSliteRESTClient.THTTPVerbType; const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; ASource: TStream = nil; AResponseContent: TStream = nil; const AURIFilters: TStringDynArray = nil; const AIgnoreReplies: TSliteRESTClient.THTTPIgnoredErrorCodes = nil);
  public
    function GetObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AOutObject: Data.DBXJSON.TJSONObject; AItemsPerPage: Integer = -1): Boolean;
    function PostObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
    function PutObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
    function PatchObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
    function DeleteObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string): Boolean;
 
    function GetLastErrorMessageAsJSONObject(AOutObject: Data.DBXJSON.TJSONObject): Boolean;
    property LastErrorMessage: string read FLastErrorMessage;
    property LastResultCode: Integer read FLastResultCode;
  public
    constructor Create();
    destructor Destroy(); override;
  public
    class procedure FillVerbList(AStrings: TStrings);
    class function BuildURL(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; const AURIFilters: TStringDynArray = nil): string;
    class function BuildURIMethodNamesAndParams(const MethodNames: array of string; const MethodParams: array of string): string;
  end;
 
  /// <summary>Classe d'Exception des WebServices REST</summary>
  ESliteRESTClientError = class(Exception)
  protected
    FErrorCode: Integer;
    FErrorMessage: string;
  public
    constructor Create(const Msg: string; const AErrorCode: Integer; const AErrorMessage: string);
    property ErrorCode: Integer read FErrorCode;
    property ErrorMessage: string read FErrorMessage;
  end;
 
  /// <summary>Classe encapsulant les WebServices de la plateforme Symfony créée par Michel ROCA D'HUYTEZA de Sensiolabs</summary>
  TSliteSymfonyWebServiceClient = class(TSliteRESTClient)
  private
    type
      /// <summary>Classe gérant les requetes HTTP dédié à la récupération du JWT token pour la Bearer Authentication</summary>
      THTTPTokenGetter = class(TSliteRESTClient.TJSONRequester);
 
      /// <summary>Classe fournissant la Bearer Authentication avec son JWT token requise par les WebServices de la plateforme Symfony créée par Michel ROCA D'HUYTEZA de Sensiolabs</summary>
      THTTPBearerAuthentication = class(TIdAuthentication)
      strict private
        FRESTRequester: TRESTRequester;
        FToken: string;
        FRefreshToken: string;
        FRefreshTokenKey: string;
        FTokenTimeStamp: TDateTime;
        FTokenValiditySeconds: Integer;
        FRoles: TStrings;
        FURIBase: string;
 
        function GetToken(): string;
        function LoadToken(): Boolean;
        function IsTokenOutOfDate(): Boolean;
        function GetRoles(): TStrings;
      protected
        function DoNext(): TIdAuthWhatsNext; override;
      public
        constructor Create(ARESTRequester: TRESTRequester); reintroduce;
        destructor Destroy(); override;
 
        function Authentication(): string; override;
        function RefreshToken(): Boolean;
        procedure Clear();
 
        property Token: string read GetToken;
        property Roles: TStrings read GetRoles;
        property URIBase: string read FURIBase write FURIBase;
      end;
  public
    type
      /// <summary>Classe fournissant un cache du JWT token de la Bearer Authentication requise par les WebServices de la plateforme Symfony créée par Michel ROCA D'HUYTEZA de Sensiolabs</summary>
      THTTPBearerAuthenticationCache = class(TObject)
      public
        const
          DEFAULT_TOKEN_VALIDITY_DURATION = 86400; // 86400 secondes = 1440 minutes = 24 heures = 1 Jour, voir dans "parameters.yml" sur le serveur
      strict private
        type
          TCacheItem = class(TObject)
          private
            FToken: string;
            FRefreshToken: string;
            FRefreshTokenKey: string;
            FTokenTimeStamp: TDateTime;
            FRoles: TStrings;
            procedure SetRoles(const Value: TStrings);
          public
            constructor Create();
            destructor Destroy(); override;
 
            property Token: string read FToken write FToken;
            property RefreshToken: string read FRefreshToken write FRefreshToken;
            property RefreshTokenKey: string read FRefreshTokenKey write FRefreshTokenKey;
            property TokenTimeStamp: TDateTime read FTokenTimeStamp write FTokenTimeStamp;
            property Roles: TStrings read FRoles write SetRoles;
          end;
          TCache = System.Generics.Collections.TObjectDictionary<string, TCacheItem>;
        class var
          FCache: TCache;
          FTokenValiditySeconds: Integer;
      private
        class function GetToken(const UserName: string): string; static;
        class procedure SetToken(const UserName: string; const Value: string); static;
        class function GetRefreshToken(const UserName: string): string; static;
        class procedure SetRefreshToken(const UserName, Value: string); static;
        class function GetRefreshTokenKey(const UserName: string): string; static;
        class procedure SetRefreshTokenKey(const UserName, Value: string); static;
        class function GetTokenTimeStamp(const UserName: string): TDateTime; static;
        class procedure SetTokenTimeStamp(const UserName: string; const Value: TDateTime); static;
        class function GetRoles(const UserName: string): TStrings; static;
        class procedure SetRoles(const UserName: string; const Value: TStrings); static;
 
        class function FindCacheItem(const UserName: string): TCacheItem;
      public
        class constructor Create();
        class destructor Destroy();
 
        class function IsTokenOutOfDate(const UserName: string): Boolean;
 
        class property Token[const UserName: string]: string read GetToken write SetToken;
        class property RefreshToken[const UserName: string]: string read GetRefreshToken write SetRefreshToken;
        class property RefreshTokenKey[const UserName: string]: string read GetRefreshTokenKey write SetRefreshTokenKey;
        class property TokenTimeStamp[const UserName: string]: TDateTime read GetTokenTimeStamp write SetTokenTimeStamp;
        class property TokenValiditySeconds: Integer read FTokenValiditySeconds write FTokenValiditySeconds;
        class property Roles[const UserName: string]: TStrings read GetRoles write SetRoles;
      end;
  strict private
    FPassword: string;
    FUserName: string;
 
    procedure RESTRequesterAuthorizationEventHandler(Sender: TObject; Authentication: TIdAuthentication; var Handled: Boolean);
    procedure SetPassword(const Value: string);
    procedure SetUserName(const Value: string);
    function GetURIBase: string;
    procedure SetURIBase(const Value: string);
    function GetRoles(): TStrings;
  public
    constructor Create();
 
    property UserName: string read FUserName write SetUserName;
    property Password: string read FPassword write SetPassword;
    property URIBase: string read GetURIBase write SetURIBase;
    property Roles: TStrings read GetRoles;
  end;
 
// La "Vérification de débordement" est volontairement désactivée (normalement c'est le cas dans un projet en RELEASE) !
// je préfère faire manuellement le controle uniquement lorsque c'est réellement nécessaire et non systématiquement comme le ferait RANGECHECKS
// cela permet de fournir un message plus clair que le banale "Erreur de vérification d'étendue"
// en indiquant quelle propriété a reçu une valeur hors limite ou dans quelle méthode se produit l'erreur
// Extrait de l'aide : Activer la vérification des limites ralentit votre programme et en augmente le volume.
{$IFOPT R+}
{$MESSAGE WARN 'Slite.REST ne doit pas être compilé en RangeChecking car le code effectue ses propres contrôles pour améliorer les messages d erreur ! Veuillez retirer cette option du projet !!! '}
{$R-}
{$ENDIF RANGECHECKS}
 
implementation
 
uses System.StrUtils, System.DateUtils, System.Math;
 
const
  ERR_INVALID_HTTP_VERB = 'Invalid HTTP Verb Enumerated Value : %d'; // Do not localize
 
{ TSliteRESTClient }
 
//------------------------------------------------------------------------------
constructor TSliteRESTClient.Create();
begin
  inherited Create();
 
  FRESTRequester := TRESTRequester.Create(nil);
  FRESTRequester.Parent := Self;
end;
 
//------------------------------------------------------------------------------
destructor TSliteRESTClient.Destroy();
begin
  FreeAndNil(FRESTRequester);
 
  inherited Destroy();
end;
 
//------------------------------------------------------------------------------
class function TSliteRESTClient.BuildURIMethodNamesAndParams(const MethodNames: array of string; const MethodParams: array of string): string;
const
  URL_DELIMITER = '/';
var
  I: Integer;
begin
  if Length(MethodNames) = Length(MethodParams) then
  begin
    for I := Low(MethodNames) to High(MethodNames) do
    begin
      if I > Low(MethodNames) then
        Result := Result + URL_DELIMITER;
      Result := Result + MethodNames[I] + URL_DELIMITER + MethodParams[I];
    end;
  end;
end;
 
//------------------------------------------------------------------------------
class function TSliteRESTClient.BuildURL(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; const AURIFilters: TStringDynArray = nil): string;
const
  URL_DELIMITER = '/';
  URL_FILTER_DELIMITER = '?';
  URL_FILTER_SEPARATOR = '&';
 
  function IsURLDelimiter(const S: string; Index: Integer): Boolean;
  begin
    Result := (Index > 0) and (Index <= Length(S)) and (S[Index] = URL_DELIMITER)
      and (ByteType(S, Index) = mbSingleByte);
  end;
 
  function IncludeTrailingURLDelimiter(const S: string): string;
  begin
    Result := S;
    if not IsURLDelimiter(Result, Length(Result)) then
      Result := Result + URL_DELIMITER;
  end;
 
var
  I: Integer;
begin
  Result := IncludeTrailingURLDelimiter(IncludeTrailingURLDelimiter(AURIBase) + AURIClassName) + AURIMethodNamesAndParams;
  if Length(AURIFilters) > 0 then
  begin
    Result := Result + URL_FILTER_DELIMITER;
    for I := Low(AURIFilters) to High(AURIFilters) do
    begin
      if I > Low(AURIFilters) then
        Result := Result + URL_FILTER_SEPARATOR;
      Result := Result + AURIFilters[I];
    end;
  end;
  Result := TIdURI.URLEncode(Result);
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.DeleteObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string): Boolean;
begin
  Result := False;
  FLastErrorMessage := '';
  try
    DoRequest(vtDELETE, AURIBase, AURIClassName, AURIMethodNamesAndParams, nil, nil);
    Result := FLastResultCode = HTTP_RESULT_CODE_NO_CONTENT;
  except
    on ERESTError: ESliteRESTClientError do
      FLastErrorMessage := ERESTError.ErrorMessage;
    on E: Exception do
      raise;
  end;
end;
 
//------------------------------------------------------------------------------
procedure TSliteRESTClient.DoRequest(const AHTTPVerb: TSliteRESTClient.THTTPVerbType; const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; ASource: TStream = nil; AResponseContent: TStream = nil; const AURIFilters: TStringDynArray = nil; const AIgnoreReplies: TSliteRESTClient.THTTPIgnoredErrorCodes = nil);
var
  URL: string;
begin
  FLastResultCode := 0;
  try
    URL := BuildURL(AURIBase, AURIClassName, AURIMethodNamesAndParams, AURIFilters);
    FRESTRequester.URIBase := AURIBase;
 
    case AHTTPVerb of
      vtGET: FRESTRequester.Get(URL, AResponseContent, AIgnoreReplies);
      vtPOST: FRESTRequester.Post(URL, ASource, AResponseContent);
      vtPUT: FRESTRequester.Put(URL, ASource, AResponseContent);
      vtDELETE: FRESTRequester.Delete(URL);
    else
      if (Ord(Low(HTTP_VERBS)) <= Ord(AHTTPVerb)) and (Ord(AHTTPVerb) <= Ord(High(HTTP_VERBS))) then
        FRESTRequester.DoRequest(HTTP_VERBS[AHTTPVerb], URL, ASource, AResponseContent, AIgnoreReplies)
      else
        raise ERangeError.CreateFmt(ERR_INVALID_HTTP_VERB, [Ord(AHTTPVerb)]);
    end;
 
    FLastResultCode := FRESTRequester.ResponseCode;
 
    if Assigned(AResponseContent) then
      AResponseContent.Seek(0, soBeginning);
  except
    on EHTTPError: EIdHTTPProtocolException do
    begin
      FLastResultCode := EHTTPError.ErrorCode;
      raise ESliteRESTClientError.Create(EHTTPError.Message, EHTTPError.ErrorCode, EHTTPError.ErrorMessage);
    end;
    on ESocketError: EIdSocketError do
    begin
      FLastResultCode := ESocketError.LastError;
      raise ESliteRESTClientError.Create(ESocketError.Message, ESocketError.LastError, '');
    end;
    on E: Exception do
      raise;
  end;
end;
 
//------------------------------------------------------------------------------
class procedure TSliteRESTClient.FillVerbList(AStrings: TStrings);
var
  iVT: THTTPVerbType;
begin
  for iVT := Low(HTTP_VERBS) to High(HTTP_VERBS) do
    AStrings.Add(HTTP_VERBS[iVT]);
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.GetLastErrorMessageAsJSONObject(AOutObject: Data.DBXJSON.TJSONObject): Boolean;
var
  ErrorContent: TStringStream;
begin
  Result := False;
  if FLastErrorMessage <> '' then
  begin
    ErrorContent := TStringStream.Create(FLastErrorMessage);
    try
      if ErrorContent.Size > 0 then
      begin
        try
          AOutObject.Parse(ErrorContent.Bytes, 0);
          Result := True;
        except
          Exit;
        end;
      end;
    finally
      ErrorContent.Free();
    end;
  end;
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.GetObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AOutObject: Data.DBXJSON.TJSONObject; AItemsPerPage: Integer = -1): Boolean;
var
  ReponseContent: TBytesStream;
  URIFilters: TStringDynArray;
begin
  Result := False;
  FLastErrorMessage := '';
  try
    ReponseContent := TBytesStream.Create();
    try
      if AItemsPerPage > 0 then
      begin
        SetLength(URIFilters, 1);
        URIFilters[0] := Format('itemsPerPage=%d', [AItemsPerPage]);
      end;
      DoRequest(vtGET, AURIBase, AURIClassName, AURIMethodNamesAndParams, nil, ReponseContent, URIFilters);
      if ReponseContent.Size > 0 then
      begin
        AOutObject.Parse(ReponseContent.Bytes, 0);
        Result := True; // GET a forcément un retour
      end;
    finally
      ReponseContent.Free();
    end;
  except
    on ERESTError: ESliteRESTClientError do
      FLastErrorMessage := ERESTError.ErrorMessage;
    on E: Exception do
      raise;
  end;
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.PatchObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
var
  Source: TStringStream;
  ReponseContent: TBytesStream;
begin
  Result := False;
  FLastErrorMessage := '';
  try
    Source := TStringStream.Create('', TEncoding.UTF8);
    try
      Source.WriteString(AInObject.ToString);
      Source.Seek(0, soBeginning);
 
      ReponseContent := TBytesStream.Create();
      try
        DoRequest(vtPATCH, AURIBase, AURIClassName, AURIMethodNamesAndParams, Source, ReponseContent);
        if ReponseContent.Size > 0 then
          if Assigned(AOutObject) then
            AOutObject.Parse(ReponseContent.Bytes, 0);
        Result := True; // PATCH peut ne rien retourner
      finally
        ReponseContent.Free();
      end;
    finally
      Source.Free();
    end;
  except
    on ERESTError: ESliteRESTClientError do
      FLastErrorMessage := ERESTError.ErrorMessage;
    on E: Exception do
      raise;
  end;
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.PostObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
var
  Source: TStringStream;
  ReponseContent: TBytesStream;
begin
  Result := False;
  FLastErrorMessage := '';
  try
    Source := TStringStream.Create('', TEncoding.UTF8);
    try
      Source.WriteString(AInObject.ToString);
      Source.Seek(0, soBeginning);
 
      ReponseContent := TBytesStream.Create();
      try
        DoRequest(vtPOST, AURIBase, AURIClassName, AURIMethodNamesAndParams, Source, ReponseContent);
        if ReponseContent.Size > 0 then
          if Assigned(AOutObject) then
            AOutObject.Parse(ReponseContent.Bytes, 0);
        Result := True; // POST peut ne rien retourner
      finally
        ReponseContent.Free();
      end;
    finally
      Source.Free();
    end;
  except
    on ERESTError: ESliteRESTClientError do
      FLastErrorMessage := ERESTError.ErrorMessage;
    on E: Exception do
      raise;
  end;
end;
 
//------------------------------------------------------------------------------
function TSliteRESTClient.PutObject(const AURIBase, AURIClassName, AURIMethodNamesAndParams: string; AInObject: Data.DBXJSON.TJSONObject; AOutObject: Data.DBXJSON.TJSONObject = nil): Boolean;
var
  Source: TStringStream;
  ReponseContent: TBytesStream;
begin
  Result := False;
  FLastErrorMessage := '';
  try
    Source := TStringStream.Create('', TEncoding.UTF8);
    try
      Source.WriteString(AInObject.ToString);
      Source.Seek(0, soBeginning);
 
      ReponseContent := TBytesStream.Create();
      try
        DoRequest(vtPUT, AURIBase, AURIClassName, AURIMethodNamesAndParams, Source, ReponseContent);
        if ReponseContent.Size > 0 then
          if Assigned(AOutObject) then
            AOutObject.Parse(ReponseContent.Bytes, 0);
        Result := True; // PUT peut ne rien retourner
      finally
        ReponseContent.Free();
      end;
    finally
      Source.Free();
    end;
  except
    on ERESTError: ESliteRESTClientError do
      FLastErrorMessage := ERESTError.ErrorMessage;
    on E: Exception do
      raise;
  end;
end;
 
{ ESliteRESTClientError }
 
//------------------------------------------------------------------------------
constructor ESliteRESTClientError.Create(const Msg: string; const AErrorCode: Integer; const AErrorMessage: string);
begin
  inherited Create(Msg);
 
  FErrorCode := AErrorCode;
  FErrorMessage := AErrorMessage;
end;
 
 
{ TSliteRESTClient.TJSONRequester }
 
//------------------------------------------------------------------------------
constructor TSliteRESTClient.TJSONRequester.Create(AOwner: TComponent);
begin
  inherited Create(nil);
 
  Request.ContentType := 'application/json';
  Request.Accept := 'application/json';
end;
 
{ TSliteSymfonyWebServiceClient }
 
//------------------------------------------------------------------------------
constructor TSliteSymfonyWebServiceClient.Create();
begin
  inherited Create();
 
  RESTRequester.OnAuthorization := RESTRequesterAuthorizationEventHandler;
  // TIdBasicAuthentication permet d'éviter l'erreur HTTP 401 mais le WS continuera a renvoyer "Bad credentials"
  // Confirmation par Michel ROCA D'HUYTEZA de Sensiolabs, le mode "Bearer Token" est obligatoire à la place d'un "Basic User@PW"
  // l'objet Authentication est libéré par Request lui même libéré par RESTRequester
  RESTRequester.Request.Authentication := THTTPBearerAuthentication.Create(RESTRequester);
 
  // Le WebService supporte le CharSet ISO-8859-1 seulement dans certains cas, ce qui est un peu étrange, donc utilisation de l'UTF-8 comme il est recommandé !
  RESTRequester.Request.ContentType := 'application/json; charset=utf-8';
  RESTRequester.Request.CharSet := 'UTF-8';
  RESTRequester.Request.ContentEncoding := 'UTF-8';
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.GetRoles(): TStrings;
begin
  Result := THTTPBearerAuthentication(RESTRequester.Request.Authentication).Roles;
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.GetURIBase(): string;
begin
  Result := THTTPBearerAuthentication(RESTRequester.Request.Authentication).URIBase;
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.RESTRequesterAuthorizationEventHandler(Sender: TObject; Authentication: TIdAuthentication; var Handled: Boolean);
begin
  Handled := (UserName <> '') and (Password <> '');
  if Handled then
  begin
    Authentication.Username := UserName;
    Authentication.Password := Password;
  end;
 
  // RefreshToken a été testé hors du contexte de ce gestionnaire d'évènement et fonctionne sans problème
  // L'invocation depuis le gestionnaire d'évènement n'a pas pu être testé !!!
  if Authentication is THTTPBearerAuthentication then
    THTTPBearerAuthentication(Authentication).RefreshToken();
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.SetPassword(const Value: string);
begin
  FPassword := Value;
  THTTPBearerAuthentication(RESTRequester.Request.Authentication).Clear();
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.SetURIBase(const Value: string);
begin
  THTTPBearerAuthentication(RESTRequester.Request.Authentication).Clear();
  THTTPBearerAuthentication(RESTRequester.Request.Authentication).URIBase := Value;
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.SetUserName(const Value: string);
begin
  FUserName := Value;
  THTTPBearerAuthentication(RESTRequester.Request.Authentication).Clear();
end;
 
{ TSliteSymfonyWebServiceClient.THTTPBearerAuthentication }
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.Authentication(): string;
begin
  Result := 'Bearer ' + Token;
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.Clear();
begin
  FToken := '';
  FRefreshToken := '';
  FRefreshTokenKey := '';
  FTokenTimeStamp := 0;
  FTokenValiditySeconds := 0;
  FreeAndNil(FRoles);
end;
 
//------------------------------------------------------------------------------
constructor TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.Create(ARESTRequester: TRESTRequester);
begin
  inherited Create();
 
  FRESTRequester := ARESTRequester;
end;
 
//------------------------------------------------------------------------------
destructor TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.Destroy();
begin
  FreeAndNil(FRoles);
 
  inherited Destroy();
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.DoNext(): TIdAuthWhatsNext;
begin
  if FCurrentStep = 0 then
  begin
    if (UserName <> '') and (Password <> '') then
      Result := wnDoRequest
    else
      Result := wnAskTheProgram;
  end
  else
    Result := wnFail;
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.GetRoles(): TStrings;
begin
  if not Assigned(FRoles) or (FRoles.Count = 0) or (FToken = '') or IsTokenOutOfDate() then
  begin
    FRESTRequester.URIBase := FURIBase;
    LoadToken();
  end;
 
  Result := FRoles;
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.GetToken(): string;
begin
  if (FToken = '') or IsTokenOutOfDate() then
    LoadToken();
 
  Result := FToken;
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.IsTokenOutOfDate(): Boolean;
begin
  // On ne prend pas le risque d'utiliser un token presque périmé !
  Result := (FTokenTimeStamp = 0) or (System.Math.Ceil(SecondSpan(Now(), FTokenTimeStamp)) > FTokenValiditySeconds - 1);
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.LoadToken(): Boolean;
const
  GET_TOKEN_METHOD_NAME = 'get_token';
  GET_TOKEN_CONTENT_TYPE = 'application/json';
  GET_TOKEN_JSON_PARAM_FMT = '{"username":"%s","password":"%s","refresh_token_key":"%s"}'; // Version rapide sans passer par un TJSONObject
  GET_TOKEN_JSON_VALUE_TOKEN = 'token';
  GET_TOKEN_JSON_VALUE_REFRESH_TOKEN = 'refresh_token';
  GET_TOKEN_JSON_VALUE_DATA = 'data';
  GET_TOKEN_JSON_VALUE_DATA_ROLES = 'roles';
 
  procedure FillRoles(AReponseObject: Data.DBXJSON.TJSONObject);
  var
    NodePair: Data.DBXJSON.TJSONPair;
    NodeValue: Data.DBXJSON.TJSONValue;
    NodeData: Data.DBXJSON.TJSONObject;
    NodeDataRoles: Data.DBXJSON.TJSONArray;
    indr: Integer;
  begin
    if not Assigned(FRoles) then
      FRoles := TStringList.Create()
    else
      FRoles.Clear();
 
    if Assigned(AReponseObject) then    
    begin
      try
        NodePair := AReponseObject.Get(GET_TOKEN_JSON_VALUE_DATA);
        if Assigned(NodePair) then
        begin
          NodeValue := NodePair.JsonValue;
          if NodeValue is Data.DBXJSON.TJSONObject then
          begin
            NodeData := Data.DBXJSON.TJSONObject(NodeValue);
 
            NodePair := NodeData.Get(GET_TOKEN_JSON_VALUE_DATA_ROLES);
            if Assigned(NodePair) then
            begin
              NodeValue := NodePair.JsonValue;
              if NodeValue is Data.DBXJSON.TJSONArray then
              begin
                NodeDataRoles := Data.DBXJSON.TJSONArray(NodeValue);
 
                for indr := 0 to NodeDataRoles.Size - 1 do
                  if NodeDataRoles.Get(indr).Value <> '' then
                    FRoles.Add(NodeDataRoles.Get(indr).Value);
              end;
            end;
          end;
        end;
      except
        FRoles.Clear();
      end;
    end;
  end;
 
var
  WSClient: TSliteSymfonyWebServiceClient;
  HTTPTokenGetter: THTTPTokenGetter;
  Source: TStringStream;
  ReponseContent: TBytesStream;
  ReponseObject: Data.DBXJSON.TJSONObject;
  CachedRoles: TStrings;
begin
  Result := False;
 
  WSClient := TSliteSymfonyWebServiceClient(FRESTRequester.Parent);
  if (WSClient.UserName <> '') and not THTTPBearerAuthenticationCache.IsTokenOutOfDate(WSClient.UserName) and (THTTPBearerAuthenticationCache.Token[WSClient.UserName] <> '') then
  begin
    FToken := THTTPBearerAuthenticationCache.Token[WSClient.UserName];
    FRefreshToken := THTTPBearerAuthenticationCache.RefreshToken[WSClient.UserName];
    FRefreshTokenKey := THTTPBearerAuthenticationCache.RefreshTokenKey[WSClient.UserName];
    FTokenTimeStamp := THTTPBearerAuthenticationCache.TokenTimeStamp[WSClient.UserName];
    FTokenValiditySeconds := THTTPBearerAuthenticationCache.TokenValiditySeconds;
    if not Assigned(FRoles) then
      FRoles := TStringList.Create();
    CachedRoles := THTTPBearerAuthenticationCache.Roles[WSClient.UserName];
    if Assigned(CachedRoles) and (CachedRoles.Count > 0) then
    begin
      FRoles.Assign(CachedRoles);
      Exit(True);
    end
    else
      FRoles.Clear();
 
 
  end;
 
  HTTPTokenGetter := THTTPTokenGetter.Create(nil);
  try
    HTTPTokenGetter.OnAuthorization := WSClient.RESTRequesterAuthorizationEventHandler;
    HTTPTokenGetter.Request.ContentType := GET_TOKEN_CONTENT_TYPE;
    Source := TStringStream.Create();
    try
      FRefreshTokenKey := FormatDateTime('YYYYMMDDHHNNSSZZZ', Now());
      Source.WriteString(Format(GET_TOKEN_JSON_PARAM_FMT, [WSClient.UserName, WSClient.Password, FRefreshTokenKey]));
      Source.Seek(0, soBeginning);
 
      ReponseContent := TBytesStream.Create();
      try
        try
          HTTPTokenGetter.Post(BuildURL(FRESTRequester.URIBase, '', GET_TOKEN_METHOD_NAME), Source, ReponseContent);
          if ReponseContent.Size > 0 then
          begin
            ReponseObject := Data.DBXJSON.TJSONObject.Create();
            try
              ReponseObject.Parse(ReponseContent.Bytes, 0);
              FToken := ReponseObject.Get(GET_TOKEN_JSON_VALUE_TOKEN).JsonValue.Value;
              FRefreshToken := ReponseObject.Get(GET_TOKEN_JSON_VALUE_REFRESH_TOKEN).JsonValue.Value;
              FTokenTimeStamp := Now();
              FillRoles(ReponseObject);
 
              THTTPBearerAuthenticationCache.Token[WSClient.UserName] := FToken;
              THTTPBearerAuthenticationCache.RefreshToken[WSClient.UserName] := FRefreshToken;
              THTTPBearerAuthenticationCache.RefreshTokenKey[WSClient.UserName] := FRefreshTokenKey;
              THTTPBearerAuthenticationCache.TokenTimeStamp[WSClient.UserName] := FTokenTimeStamp;
              THTTPBearerAuthenticationCache.Roles[WSClient.UserName] := FRoles;
 
              Result := True;
            finally
              ReponseObject.Free();
            end;
          end;
        except
          on E: Exception do
          begin
            FToken := '';
            FRefreshToken := '';
            FRefreshTokenKey := '';
            FTokenTimeStamp := 0;
            FTokenValiditySeconds := 0;
            FillRoles(nil);
          end;
        end;
      finally
        ReponseContent.Free();
      end;
    finally
      Source.Free();
    end;
  finally
    HTTPTokenGetter.Free();
  end;
end;
 
//------------------------------------------------------------------------------
function TSliteSymfonyWebServiceClient.THTTPBearerAuthentication.RefreshToken(): Boolean;
const
  GET_TOKEN_METHOD_NAME = 'refresh_token';
  GET_TOKEN_CONTENT_TYPE = 'application/json';
  GET_TOKEN_JSON_PARAM_FMT = '{"token":"%s","refresh_token":"%s","refresh_token_key":"%s"}'; // Version rapide sans passer par un TJSONObject
  GET_TOKEN_JSON_VALUE_TOKEN = 'token';
  GET_TOKEN_JSON_VALUE_REFRESH_TOKEN = 'refresh_token';
var
  WSClient: TSliteSymfonyWebServiceClient;
  HTTPTokenGetter: THTTPTokenGetter;
  Source: TStringStream;
  ReponseContent: TBytesStream;
  ReponseObject: Data.DBXJSON.TJSONObject;
begin
  Result := False;
 
  if (FToken = '') or (FRefreshToken = '') or (FRefreshTokenKey = '') then
  begin
    GetToken();
    Exit()
  end;
 
  HTTPTokenGetter := THTTPTokenGetter.Create(nil);
  try
    WSClient := TSliteSymfonyWebServiceClient(FRESTRequester.Parent);
    HTTPTokenGetter.OnAuthorization := WSClient.RESTRequesterAuthorizationEventHandler;
    HTTPTokenGetter.Request.ContentType := GET_TOKEN_CONTENT_TYPE;
    Source := TStringStream.Create();
    try
      Source.WriteString(Format(GET_TOKEN_JSON_PARAM_FMT, [FToken, FRefreshToken, FRefreshTokenKey]));
      Source.Seek(0, soBeginning);
 
      ReponseContent := TStringStream.Create();
      try
        try
          HTTPTokenGetter.Post(BuildURL(FRESTRequester.URIBase, '', GET_TOKEN_METHOD_NAME), Source, ReponseContent);
          if ReponseContent.Size > 0 then
          begin
            ReponseObject := Data.DBXJSON.TJSONObject.Create();
            try
              ReponseObject.Parse(ReponseContent.Bytes, 0);
              FToken := ReponseObject.Get(GET_TOKEN_JSON_VALUE_TOKEN).JsonValue.Value;
              FRefreshToken := ReponseObject.Get(GET_TOKEN_JSON_VALUE_REFRESH_TOKEN).JsonValue.Value;
              FTokenTimeStamp := Now();
 
              THTTPBearerAuthenticationCache.Token[WSClient.UserName] := FToken;
              THTTPBearerAuthenticationCache.RefreshToken[WSClient.UserName] := FRefreshToken;
              THTTPBearerAuthenticationCache.RefreshTokenKey[WSClient.UserName] := FRefreshTokenKey;
              THTTPBearerAuthenticationCache.TokenTimeStamp[WSClient.UserName] := FTokenTimeStamp;
 
              Result := True;
            finally
              ReponseObject.Free();
            end;
          end;
        except
          on E: Exception do
          begin
            FToken := '';
            FRefreshToken := '';
            FRefreshTokenKey := '';
          end;
        end;
      finally
        ReponseContent.Free();
      end;
    finally
      Source.Free();
    end;
  finally
    HTTPTokenGetter.Free();
  end;
end;
 
{ TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache }
 
//------------------------------------------------------------------------------
class constructor TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.Create();
begin
  FTokenValiditySeconds := DEFAULT_TOKEN_VALIDITY_DURATION;
  FCache := TCache.Create([doOwnsValues]);
end;
 
//------------------------------------------------------------------------------
class destructor TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.Destroy();
begin
  FreeAndNil(FCache);
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.FindCacheItem(const UserName: string): TCacheItem;
begin
  if not FCache.TryGetValue(UserName, Result) then
  begin
    Result := TCacheItem.Create();
    FCache.AddOrSetValue(UserName, Result);
  end;
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.GetRefreshToken(const UserName: string): string;
var
  CacheItem: TCacheItem;
begin
  if FCache.TryGetValue(UserName, CacheItem) then
    Result := CacheItem.RefreshToken
  else
    Result := '';
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.GetRefreshTokenKey(const UserName: string): string;
var
  CacheItem: TCacheItem;
begin
  if FCache.TryGetValue(UserName, CacheItem) then
    Result := CacheItem.RefreshTokenKey
  else
    Result := '';
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.GetRoles(const UserName: string): TStrings;
var
  CacheItem: TCacheItem;
begin
  if FCache.TryGetValue(UserName, CacheItem) then
    Result := CacheItem.Roles
  else
    Result := nil;
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.GetToken(const UserName: string): string;
var
  CacheItem: TCacheItem;
begin
  if FCache.TryGetValue(UserName, CacheItem) then
    Result := CacheItem.Token
  else
    Result := '';
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.GetTokenTimeStamp(const UserName: string): TDateTime;
var
  CacheItem: TCacheItem;
begin
  if FCache.TryGetValue(UserName, CacheItem) then
    Result := CacheItem.TokenTimeStamp
  else
    Result := 0;
end;
 
//------------------------------------------------------------------------------
class function TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.IsTokenOutOfDate(const UserName: string): Boolean;
begin
  // On ne prend pas le risque d'utiliser un token presque périmé !
  Result := (TokenTimeStamp[UserName] = 0) or (System.Math.Ceil(SecondSpan(Now(), TokenTimeStamp[UserName])) > FTokenValiditySeconds - 1);
end;
 
//------------------------------------------------------------------------------
class procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.SetRefreshToken(const UserName: string; const Value: string);
begin
  FindCacheItem(UserName).RefreshToken := Value;
end;
 
//------------------------------------------------------------------------------
class procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.SetRefreshTokenKey(const UserName: string; const Value: string);
begin
  FindCacheItem(UserName).RefreshTokenKey := Value;
end;
 
//------------------------------------------------------------------------------
class procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.SetRoles(const UserName: string; const Value: TStrings);
begin
  FindCacheItem(UserName).Roles := Value;
end;
 
//------------------------------------------------------------------------------
class procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.SetToken(const UserName: string; const Value: string);
begin
  with FindCacheItem(UserName) do
  begin
    Token := Value;
    if Value = '' then
      TokenTimeStamp := 0;
  end;
end;
 
//------------------------------------------------------------------------------
class procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.SetTokenTimeStamp(const UserName: string; const Value: TDateTime);
begin
  FindCacheItem(UserName).TokenTimeStamp := Value;
end;
 
{ TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.TCacheItem }
 
//------------------------------------------------------------------------------
constructor TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.TCacheItem.Create();
begin
  inherited Create();
 
  FRoles := TStringList.Create();
end;
 
//------------------------------------------------------------------------------
destructor TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.TCacheItem.Destroy();
begin
  FreeAndNil(FRoles);
 
  inherited Destroy();
end;
 
//------------------------------------------------------------------------------
procedure TSliteSymfonyWebServiceClient.THTTPBearerAuthenticationCache.TCacheItem.SetRoles(const Value: TStrings);
begin
  FRoles.Assign(Value);
end;
 
end.

**aladin95** · 06/03/2019, 10h28

Merci mais je vais plutôt, pour l'instant, tenter les objets Delphi.

J'ai donc mis en place 3 objets:
- 1 restclient,
RESTClient1.BaseURL := RESTClient1.HTTPClient.URLEncode('https://apis.goflipr.com/Oauth2/token');

- 1 Oauth2Authenticator
parametres de base

- 1 RestRequest
j'ai defini les 3 parametres
defini methode post

qui sont issus de rest debuggeur

a l'execution j'ai une erreur

RESTRequest1.Execute>exception [REST request failed! Erreur de socket n° 10054
Connexion réinitialisée par l'homologue (peer).]

si vous avez des idées ..

**blonde** · 07/03/2019, 12h34

J'ai déjà eu ce même message d'erreur, mais cela venait du partenaire en face. Leur serveur était "en rade".

Si tu passes les même paramètres via un outil comme ARC (extension chrome), est-ce que tu obtiens la même erreur ?

**aladin95** · 07/03/2019, 13h42

je ne connais pas ARC, je vais essayer.

j'utilise Postman et Rest Debugeur
est-ce la chance mais avec Postman chaque essai a été reussi.

je n'ai jamais réussi avec les mêmes paramètres d'obtenir une réponse avec REST Debugger
400:bad request - 34 bytes of data returned; Pre:0ms - Exec:78ms - Post: 0ms - Total: 78ms

si quelqu’un utilise cet outil, j'aimerais un avis

je vais tenter de créer une boucle et laisser tourner pour voir car il y a, me semble-t-il des possibilités de capteur non atteignable

merci donc pour ta réponse

Objets connectés : comment récupérer des données apis, web-services, Json, etc

Delphi

Discussions similaires

Partager

Partager