Graph API ajouter un membre à un groupchat Teams ?

R3dKap

Member

19 octobre 2024 at 12h25

Alors, si tu es un peu patient……… 😋 : https://www.linkedin.com/feed/update/urn:li:activity:7234857516994633728?utm_source=share&utm_medium=member_desktop

En attendant, pour faire des appels au Graph API depuis Power Apps, il faut utiliser le connecteur Groupes Office 365. Mais c’est pas forcément trivial. Voici rapidement comment ça marche :

Ajouter le connecteur Groupes Office 365 à l’application
Faire appel à la fonction HttpRequest avec les paramètres suivants :
- Uri = l’url vers le point de terminaison Graph API -> dans ton cas : https://graph.microsoft.com/v1.0/chats/{chat-id}/members
- Method = l’opération d’API -> dans ton cas “POST”
- file = le body de ton appel API -> dans ton cas au format :
```
{
    "@odata.type": "#microsoft.graph.aadUserConversationMember",
    "user@odata.bind": "https://graph.microsoft.com/v1.0/users/{user-id}",
    "visibleHistoryStartDateTime": "0001-01-01T00:00:00Z",
    "roles": ["owner"]
}
```

C’est sur ce dernier paramètre que ça se complique car sa valeur doit être encodé en Base64. Pour faire ça il faut utiliser ceci : https://ppfc.fr/groupes/ressources/forum/topic/power-apps-encoder-une-chaine-en-base64

Evidemment, dans le composant que je suis en train de créer, tout ça sera beaucoup plus simple puisque tu auras à ta disposition une fonction à appeler et à laquelle tu fourniras juste l’ID du chat et l’ID ou le mail du membre à ajouter… 😉

Simon

Member

20 octobre 2024 at 23h50

Merci pour ta réponse R3dkap 😊

Peux-tu m’en dire plus sur la transformation en Base64 ? 🤔

Je suis bloqué au moment de la transformation du input :

“data:text/plain;base64,” & With(
{
InputText:

{
“@odata.type”: “#microsoft.graph.aadUserConversationMember”,
“user@odata.bind”: “https://graph.microsoft.com/v1.0/users/8b081ef6-4792-4def-b2c9-c363a1bf41d5”,
“visibleHistoryStartDateTime”: “0001-01-01T00:00:00Z”,
“roles”: [“owner”]
};
AsciiTable: AddColumns(
Sequence(
2 ^ 8 – 1;
1
);
char;
Char(Value)
);
CharBinTable: Table(
{
car: Blank();
bin: “00000000”;
index: 0
};
{
car: Char(1);
bin: “00000001”;
index: 1
};
{
car: Char(2);
bin: “00000010”;
index: 2
};
{
car: Char(3);
bin: “00000011”;
index: 3
};
{
car: Char(4);
bin: “00000100”;
index: 4
};
{
car: Char(5);
bin: “00000101”;
index: 5
};
{
car: Char(6);
bin: “00000110”;
index: 6
};
{
car: Char(7);
bin: “00000111”;
index: 7
};
{
car: Char(8);
bin: “00001000”;
index: 8
};
{
car: Char(9);
bin: “00001001”;
index: 9
};
{
car: Char(10);
bin: “00001010”;
index: 10
};
{
car: Char(11);
bin: “00001011”;
index: 11
};
{
car: Char(12);
bin: “00001100”;
index: 12
};
{
car: Char(13);
bin: “00001101”;
index: 13
};
{
car: Char(14);
bin: “00001110”;
index: 14
};
{
car: Char(15);
bin: “00001111”;
index: 15
};
{
car: Char(16);
bin: “00010000”;
index: 16
};
{
car: Char(17);
bin: “00010001”;
index: 17
};
{
car: Char(18);
bin: “00010010”;
index: 18
};
{
car: Char(19);
bin: “00010011”;
index: 19
};
{
car: Char(20);
bin: “00010100”;
index: 20
};
{
car: Char(21);
bin: “00010101”;
index: 21
};
{
car: Char(22);
bin: “00010110”;
index: 22
};
{
car: Char(23);
bin: “00010111”;
index: 23
};
{
car: Char(24);
bin: “00011000”;
index: 24
};
{
car: Char(25);
bin: “00011001”;
index: 25
};
{
car: Char(26);
bin: “00011010”;
index: 26
};
{
car: Char(27);
bin: “00011011”;
index: 27
};
{
car: Char(28);
bin: “00011100”;
index: 28
};
{
car: Char(29);
bin: “00011101”;
index: 29
};
{
car: Char(30);
bin: “00011110”;
index: 30
};
{
car: Char(31);
bin: “00011111”;
index: 31
};
{
car: Char(32);
bin: “00100000”;
index: 32
};
{
car: Char(33);
bin: “00100001”;
index: 33
};
{
car: Char(34);
bin: “00100010”;
index: 34
};
{
car: Char(35);
bin: “00100011”;
index: 35
};
{
car: Char(36);
bin: “00100100”;
index: 36
};
{
car: Char(37);
bin: “00100101”;
index: 37
};
{
car: Char(38);
bin: “00100110”;
index: 38
};
{
car: Char(39);
bin: “00100111”;
index: 39
};
{
car: Char(40);
bin: “00101000”;
index: 40
};
{
car: Char(41);
bin: “00101001”;
index: 41
};
{
car: Char(42);
bin: “00101010”;
index: 42
};
{
car: Char(43);
bin: “00101011”;
index: 43
};
{
car: Char(44);
bin: “00101100”;
index: 44
};
{
car: Char(45);
bin: “00101101”;
index: 45
};
{
car: Char(46);
bin: “00101110”;
index: 46
};
{
car: Char(47);
bin: “00101111”;
index: 47
};
{
car: Char(48);
bin: “00110000”;
index: 48
};
{
car: Char(49);
bin: “00110001”;
index: 49
};
{
car: Char(50);
bin: “00110010”;
index: 50
};
{
car: Char(51);
bin: “00110011”;
index: 51
};
{
car: Char(52);
bin: “00110100”;
index: 52
};
{
car: Char(53);
bin: “00110101”;
index: 53
};
{
car: Char(54);
bin: “00110110”;
index: 54
};
{
car: Char(55);
bin: “00110111”;
index: 55
};
{
car: Char(56);
bin: “00111000”;
index: 56
};
{
car: Char(57);
bin: “00111001”;
index: 57
};
{
car: Char(58);
bin: “00111010”;
index: 58
};
{
car: Char(59);
bin: “00111011”;
index: 59
};
{
car: Char(60);
bin: “00111100”;
index: 60
};
{
car: Char(61);
bin: “00111101”;
index: 61
};
{
car: Char(62);
bin: “00111110”;
index: 62
};
{
car: Char(63);
bin: “00111111”;
index: 63
};
{
car: Char(64);
bin: “01000000”;
index: 64
};
{
car: Char(65);
bin: “01000001”;
index: 65
};
{
car: Char(66);
bin: “01000010”;
index: 66
};
{
car: Char(67);
bin: “01000011”;
index: 67
};
{
car: Char(68);
bin: “01000100”;
index: 68
};
{
car: Char(69);
bin: “01000101”;
index: 69
};
{
car: Char(70);
bin: “01000110”;
index: 70
};
{
car: Char(71);
bin: “01000111”;
index: 71
};
{
car: Char(72);
bin: “01001000”;
index: 72
};
{
car: Char(73);
bin: “01001001”;
index: 73
};
{
car: Char(74);
bin: “01001010”;
index: 74
};
{
car: Char(75);
bin: “01001011”;
index: 75
};
{
car: Char(76);
bin: “01001100”;
index: 76
};
{
car: Char(77);
bin: “01001101”;
index: 77
};
{
car: Char(78);
bin: “01001110”;
index: 78
};
{
car: Char(79);
bin: “01001111”;
index: 79
};
{
car: Char(80);
bin: “01010000”;
index: 80
};
{
car: Char(81);
bin: “01010001”;
index: 81
};
{
car: Char(82);
bin: “01010010”;
index: 82
};
{
car: Char(83);
bin: “01010011”;
index: 83
};
{
car: Char(84);
bin: “01010100”;
index: 84
};
{
car: Char(85);
bin: “01010101”;
index: 85
};
{
car: Char(86);
bin: “01010110”;
index: 86
};
{
car: Char(87);
bin: “01010111”;
index: 87
};
{
car: Char(88);
bin: “01011000”;
index: 88
};
{
car: Char(89);
bin: “01011001”;
index: 89
};
{
car: Char(90);
bin: “01011010”;
index: 90
};
{
car: Char(91);
bin: “01011011”;
index: 91
};
{
car: Char(92);
bin: “01011100”;
index: 92
};
{
car: Char(93);
bin: “01011101”;
index: 93
};
{
car: Char(94);
bin: “01011110”;
index: 94
};
{
car: Char(95);
bin: “01011111”;
index: 95
};
{
car: Char(96);
bin: “01100000”;
index: 96
};
{
car: Char(97);
bin: “01100001”;
index: 97
};
{
car: Char(98);
bin: “01100010”;
index: 98
};
{
car: Char(99);
bin: “01100011”;
index: 99
};
{
car: Char(100);
bin: “01100100”;
index: 100
};
{
car: Char(101);
bin: “01100101”;
index: 101
};
{
car: Char(102);
bin: “01100110”;
index: 102
};
{
car: Char(103);
bin: “01100111”;
index: 103
};
{
car: Char(104);
bin: “01101000”;
index: 104
};
{
car: Char(105);
bin: “01101001”;
index: 105
};
{
car: Char(106);
bin: “01101010”;
index: 106
};
{
car: Char(107);
bin: “01101011”;
index: 107
};
{
car: Char(108);
bin: “01101100”;
index: 108
};
{
car: Char(109);
bin: “01101101”;
index: 109
};
{
car: Char(110);
bin: “01101110”;
index: 110
};
{
car: Char(111);
bin: “01101111”;
index: 111
};
{
car: Char(112);
bin: “01110000”;
index: 112
};
{
car: Char(113);
bin: “01110001”;
index: 113
};
{
car: Char(114);
bin: “01110010”;
index: 114
};
{
car: Char(115);
bin: “01110011”;
index: 115
};
{
car: Char(116);
bin: “01110100”;
index: 116
};
{
car: Char(117);
bin: “01110101”;
index: 117
};
{
car: Char(118);
bin: “01110110”;
index: 118
};
{
car: Char(119);
bin: “01110111”;
index: 119
};
{
car: Char(120);
bin: “01111000”;
index: 120
};
{
car: Char(121);
bin: “01111001”;
index: 121
};
{
car: Char(122);
bin: “01111010”;
index: 122
};
{
car: Char(123);
bin: “01111011”;
index: 123
};
{
car: Char(124);
bin: “01111100”;
index: 124
};
{
car: Char(125);
bin: “01111101”;
index: 125
};
{
car: Char(126);
bin: “01111110”;
index: 126
};
{
car: Char(127);
bin: “01111111”;
index: 127
};
{
car: Char(128);
bin: “10000000”;
index: 128
};
{
car: Char(129);
bin: “10000001”;
index: 129
};
{
car: Char(130);
bin: “10000010”;
index: 130
};
{
car: Char(131);
bin: “10000011”;
index: 131
};
{
car: Char(132);
bin: “10000100”;
index: 132
};
{
car: Char(133);
bin: “1100001010000101”;
index: 133
};
{
car: Char(134);
bin: “1100001010000110”;
index: 134
};
{
car: Char(135);
bin: “1100001010000111”;
index: 135
};
{
car: Char(136);
bin: “1100001010001000”;
index: 136
};
{
car: Char(137);
bin: “1100001010001001”;
index: 137
};
{
car: Char(138);
bin: “1100001010001010”;
index: 138
};
{
car: Char(139);
bin: “1100001010001011”;
index: 139
};
{
car: Char(140);
bin: “1100001010001100”;
index: 140
};
{
car: Char(141);
bin: “1100001010001101”;
index: 141
};
{
car: Char(142);
bin: “1100001010001110”;
index: 142
};
{
car: Char(143);
bin: “1100001010001111”;
index: 143
};
{
car: Char(144);
bin: “1100001010010000”;
index: 144
};
{
car: Char(145);
bin: “1100001010010001”;
index: 145
};
{
car: Char(146);
bin: “1100001010010010”;
index: 146
};
{
car: Char(147);
bin: “1100001010010011”;
index: 147
};
{
car: Char(148);
bin: “1100001010010100”;
index: 148
};
{
car: Char(149);
bin: “1100001010010101”;
index: 149
};
{
car: Char(150);
bin: “1100001010010110”;
index: 150
};
{
car: Char(151);
bin: “1100001010010111”;
index: 151
};
{
car: Char(152);
bin: “1100001010011000”;
index: 152
};
{
car: Char(153);
bin: “1100001010011001”;
index: 153
};
{
car: Char(154);
bin: “1100001010011010”;
index: 154
};
{
car: Char(155);
bin: “1100001010011011”;
index: 155
};
{
car: Char(156);
bin: “1100001010011100”;
index: 156
};
{
car: Char(157);
bin: “1100001010011101”;
index: 157
};
{
car: Char(158);
bin: “1100001010011110”;
index: 158
};
{
car: Char(159);
bin: “1100001010011111”;
index: 159
};
{
car: Char(160);
bin: “1100001010100000”;
index: 160
};
{
car: Char(161);
bin: “1100001010100001”;
index: 161
};
{
car: Char(162);
bin: “1100001010100010”;
index: 162
};
{
car: Char(163);
bin: “1100001010100011”;
index: 163
};
{
car: Char(164);
bin: “1100001010100100”;
index: 164
};
{
car: Char(165);
bin: “1100001010100101”;
index: 165
};
{
car: Char(166);
bin: “1100001010100110”;
index: 166
};
{
car: Char(167);
bin: “1100001010100111”;
index: 167
};
{
car: Char(168);
bin: “1100001010101000”;
index: 168
};
{
car: Char(169);
bin: “1100001010101001”;
index: 169
};
{
car: Char(170);
bin: “1100001010101010”;
index: 170
};
{
car: Char(171);
bin: “1100001010101011”;
index: 171
};
{
car: Char(172);
bin: “1100001010101100”;
index: 172
};
{
car: Char(173);
bin: “1100001010101101”;
index: 173
};
{
car: Char(174);
bin: “1100001010101110”;
index: 174
};
{
car: Char(175);
bin: “1100001010101111”;
index: 175
};
{
car: Char(176);
bin: “1100001010110000”;
index: 176
};
{
car: Char(177);
bin: “1100001010110001”;
index: 177
};
{
car: Char(178);
bin: “1100001010110010”;
index: 178
};
{
car: Char(179);
bin: “1100001010110011”;
index: 179
};
{
car: Char(180);
bin: “1100001010110100”;
index: 180
};
{
car: Char(181);
bin: “1100001010110101”;
index: 181
};
{
car: Char(182);
bin: “1100001010110110”;
index: 182
};
{
car: Char(183);
bin: “1100001010110111”;
index: 183
};
{
car: Char(184);
bin: “1100001010111000”;
index: 184
};
{
car: Char(185);
bin: “1100001010111001”;
index: 185
};
{
car: Char(186);
bin: “1100001010111010”;
index: 186
};
{
car: Char(187);
bin: “1100001010111011”;
index: 187
};
{
car: Char(188);
bin: “1100001010111100”;
index: 188
};
{
car: Char(189);
bin: “1100001010111101”;
index: 189
};
{
car: Char(190);
bin: “1100001010111110”;
index: 190
};
{
car: Char(191);
bin: “1100001010111111”;
index: 191
};
{
car: Char(192);
bin: “1100001110000000”;
index: 192
};
{
car: Char(193);
bin: “1100001110000001”;
index: 193
};
{
car: Char(194);
bin: “1100001110000010”;
index: 194
};
{
car: Char(195);
bin: “1100001110000011”;
index: 195
};
{
car: Char(196);
bin: “1100001110000100”;
index: 196
};
{
car: Char(197);
bin: “1100001110000101”;
index: 197
};
{
car: Char(198);
bin: “1100001110000110”;
index: 198
};
{
car: Char(199);
bin: “1100001110000111”;
index: 199
};
{
car: Char(200);
bin: “1100001110001000”;
index: 200
};
{
car: Char(201);
bin: “1100001110001001”;
index: 201
};
{
car: Char(202);
bin: “1100001110001010”;
index: 202
};
{
car: Char(203);
bin: “1100001110001011”;
index: 203
};
{
car: Char(204);
bin: “1100001110001100”;
index: 204
};
{
car: Char(205);
bin: “1100001110001101”;
index: 205
};
{
car: Char(206);
bin: “1100001110001110”;
index: 206
};
{
car: Char(207);
bin: “1100001110001111”;
index: 207
};
{
car: Char(208);
bin: “1100001110010000”;
index: 208
};
{
car: Char(209);
bin: “1100001110010001”;
index: 209
};
{
car: Char(210);
bin: “1100001110010010”;
index: 210
};
{
car: Char(211);
bin: “1100001110010011”;
index: 211
};
{
car: Char(212);
bin: “1100001110010100”;
index: 212
};
{
car: Char(213);
bin: “1100001110010101”;
index: 213
};
{
car: Char(214);
bin: “1100001110010110”;
index: 214
};
{
car: Char(215);
bin: “1100001110010111”;
index: 215
};
{
car: Char(216);
bin: “1100001110011000”;
index: 216
};
{
car: Char(217);
bin: “1100001110011001”;
index: 217
};
{
car: Char(218);
bin: “1100001110011010”;
index: 218
};
{
car: Char(219);
bin: “1100001110011011”;
index: 219
};
{
car: Char(220);
bin: “1100001110011100”;
index: 220
};
{
car: Char(221);
bin: “1100001110011101”;
index: 221
};
{
car: Char(222);
bin: “1100001110011110”;
index: 222
};
{
car: Char(223);
bin: “1100001110011111”;
index: 223
};
{
car: Char(224);
bin: “1100001110100000”;
index: 224
};
{
car: Char(225);
bin: “1100001110100001”;
index: 225
};
{
car: Char(226);
bin: “1100001110100010”;
index: 226
};
{
car: Char(227);
bin: “1100001110100011”;
index: 227
};
{
car: Char(228);
bin: “1100001110100100”;
index: 228
};
{
car: Char(229);
bin: “1100001110100101”;
index: 229
};
{
car: Char(230);
bin: “1100001110100110”;
index: 230
};
{
car: Char(231);
bin: “1100001110100111”;
index: 231
};
{
car: Char(232);
bin: “1100001110101000”;
index: 232
};
{
car: Char(233);
bin: “1100001110101001”;
index: 233
};
{
car: Char(234);
bin: “1100001110101010”;
index: 234
};
{
car: Char(235);
bin: “1100001110101011”;
index: 235
};
{
car: Char(236);
bin: “1100001110101100”;
index: 236
};
{
car: Char(237);
bin: “1100001110101101”;
index: 237
};
{
car: Char(238);
bin: “1100001110101110”;
index: 238
};
{
car: Char(239);
bin: “1100001110101111”;
index: 239
};
{
car: Char(240);
bin: “1100001110110000”;
index: 240
};
{
car: Char(241);
bin: “1100001110110001”;
index: 241
};
{
car: Char(242);
bin: “1100001110110010”;
index: 242
};
{
car: Char(243);
bin: “1100001110110011”;
index: 243
};
{
car: Char(244);
bin: “1100001110110100”;
index: 244
};
{
car: Char(245);
bin: “1100001110110101”;
index: 245
};
{
car: Char(246);
bin: “1100001110110110”;
index: 246
};
{
car: Char(247);
bin: “1100001110110111”;
index: 247
};
{
car: Char(248);
bin: “1100001110111000”;
index: 248
};
{
car: Char(249);
bin: “1100001110111001”;
index: 249
};
{
car: Char(250);
bin: “1100001110111010”;
index: 250
};
{
car: Char(251);
bin: “1100001110111011”;
index: 251
};
{
car: Char(252);
bin: “1100001110111100”;
index: 252
};
{
car: Char(253);
bin: “1100001110111101”;
index: 253
};
{
car: Char(254);
bin: “1100001110111110”;
index: 254
};
{
car: Char(255);
bin: “1100001110111111”;
index: 255
}
);
B64ToBin: Table(
{
b64: “A”;
bin: “000000”
};
{
b64: “B”;
bin: “000001”
};
{
b64: “C”;
bin: “000010”
};
{
b64: “D”;
bin: “000011”
};
{
b64: “E”;
bin: “000100”
};
{
b64: “F”;
bin: “000101”
};
{
b64: “G”;
bin: “000110”
};
{
b64: “H”;
bin: “000111”
};
{
b64: “I”;
bin: “001000”
};
{
b64: “J”;
bin: “001001”
};
{
b64: “K”;
bin: “001010”
};
{
b64: “L”;
bin: “001011”
};
{
b64: “M”;
bin: “001100”
};
{
b64: “N”;
bin: “001101”
};
{
b64: “O”;
bin: “001110”
};
{
b64: “P”;
bin: “001111”
};
{
b64: “Q”;
bin: “010000”
};
{
b64: “R”;
bin: “010001”
};
{
b64: “S”;
bin: “010010”
};
{
b64: “T”;
bin: “010011”
};
{
b64: “U”;
bin: “010100”
};
{
b64: “V”;
bin: “010101”
};
{
b64: “W”;
bin: “010110”
};
{
b64: “X”;
bin: “010111”
};
{
b64: “Y”;
bin: “011000”
};
{
b64: “Z”;
bin: “011001”
};
{
b64: “a”;
bin: “011010”
};
{
b64: “b”;
bin: “011011”
};
{
b64: “c”;
bin: “011100”
};
{
b64: “d”;
bin: “011101”
};
{
b64: “e”;
bin: “011110”
};
{
b64: “f”;
bin: “011111”
};
{
b64: “g”;
bin: “100000”
};
{
b64: “h”;
bin: “100001”
};
{
b64: “i”;
bin: “100010”
};
{
b64: “j”;
bin: “100011”
};
{
b64: “k”;
bin: “100100”
};
{
b64: “l”;
bin: “100101”
};
{
b64: “m”;
bin: “100110”
};
{
b64: “n”;
bin: “100111”
};
{
b64: “o”;
bin: “101000”
};
{
b64: “p”;
bin: “101001”
};
{
b64: “q”;
bin: “101010”
};
{
b64: “r”;
bin: “101011”
};
{
b64: “s”;
bin: “101100”
};
{
b64: “t”;
bin: “101101”
};
{
b64: “u”;
bin: “101110”
};
{
b64: “v”;
bin: “101111”
};
{
b64: “w”;
bin: “110000”
};
{
b64: “x”;
bin: “110001”
};
{
b64: “y”;
bin: “110010”
};
{
b64: “z”;
bin: “110011”
};
{
b64: “0”;
bin: “110100”
};
{
b64: “1”;
bin: “110101”
};
{
b64: “2”;
bin: “110110”
};
{
b64: “3”;
bin: “110111”
};
{
b64: “4”;
bin: “111000”
};
{
b64: “5”;
bin: “111001”
};
{
b64: “6”;
bin: “111010”
};
{
b64: “7”;
bin: “111011”
};
{
b64: “8”;
bin: “111100”
};
{
b64: “9”;
bin: “111101”
};
{
b64: “+”;
bin: “111110”
};
{
b64: “/”;
bin: “111111”
}
)
};
With(
{
BinRep: Concat(
AddColumns(
ForAll(
Split(
InputText;
“”
);
{Result: ThisRecord.Value}
);
dec;
LookUp(
AsciiTable;
char = Result
).Value
);//Convert text to Ascii character code (decimal)
LookUp(CharBinTable;index=dec).bin
)//Convert decimal to binary
};
With(
{
b64string: Concat(
Sequence(
RoundUp(
Len(BinRep) / 6;
0
);
0
);
LookUp(
B64ToBin;
bin = Mid(
BinRep & Left(
“000000”;
6 – Mod(
Len(BinRep);
6
)
);
6 * Value + 1;
6
)//Left(“000000″….) is padding right with zero
).b64
)
};
b64string & Left(
“====”;
Mod(
4 – Mod(
Len(b64string);
4
);
4
)
)//Convert binary to base64
)
)
)
)

Power Apps m’affiche une erreur sur le “@odata.type”:

D’avance merci à toi et je suivrai avec impatience le développement de ton composant 😉

R3dKap

Member

21 octobre 2024 at 11h23

En fait, ce que tu veux encoder doit être une chaîne de caractères. Ce que tu veux encoder c’est ceci :

{
“@odata.type”: “#microsoft.graph.aadUserConversationMember”,
“user@odata.bind”: “https://graph.microsoft.com/v1.0/users/8b081ef6-4792-4def-b2c9-c363a1bf41d5”,
“visibleHistoryStartDateTime”: “0001-01-01T00:00:00Z”,
“roles”: [“owner”]
}

Donc, faut que tu mettes tout ça entre guillemets mais comme il y a déjà des guillemets dedans, soit tu les doubles, soit tu mets des apostrophes à la place.

😉

Simon

Member

21 octobre 2024 at 21h33

Parfait, merci R3dKap 💪 cela fonctionne en effet mais à présent j’ai un message d’erreur concernant des permissions manquantes 😥

J’ai tenté d’octroyer les permissions en inscrivant une application dans Entra (Azure AD) mais ça ne fonctionne pas mieux… Je nage un peu 😅

Quelqu’un sait-il comment octroyer les permissions nécessaires pour une app Power Apps ? 🤔

R3dKap

Member

22 octobre 2024 at 11h38

L’authentification auprès de Graph API étant gérée par le connecteur Groupes Office 365, c’est forcément les permissions de l’utilisateur connecté qui vont être vérifiées.

Chaque utilisateur doit donc posséder les bonnes permissions pour les points de terminaison Graph API appelés dans l’application.

Sur la page de la documentation du point de terminaison tu as un onglet Permissions où tu verras les permissions nécessaires pour effectuer l’opération que tu veux faire :

Tu choisis :

celle de gauche pour le strict minimum
celle de droite pour le maximum

Cette permission doit être attribuée soit directement à l’utilisateur soit à un groupe de sécurité AD dans lequel figureront les utilisateurs qui auront le droit de faire cette opération. Si c’est un groupe de sécu :

Crée le groupe de sécurité dans Azure AD
Ajoute-lui les permissions du point de terminaison
Ajoutes-y les utilisateurs qui vont utiliser l’application
Crée une équipe Dataverse liée à ce groupe de sécu dans l’admin de l’environnement où se trouve ton app
Partage ton application à cette équipe Dataverse

As-tu besoin d’aide là-dessus ?

———-

Ah et j’ai complètement oublié un aspect important de l’appel à Graph API : l’interprétation des résultats…

Pas trivial non plus :

impossible de récupérer actuellement le statut de l’appel (donc on sait pas si ça c’est bien passé ou pas)
impossible de récupérer la valeur du paramètre OData $Count (bon pas très grave mais ça aurait pu être pratique quand même)
les données renvoyées par la fonction GroupesOffice365.HttpRequest() sont dans un état indéfini (l’application ne sait pas quels sont les champs qui constituent le résultat, ni de quel type ils sont)

Sur ce dernier point c’est donc à toi de le spécifier de la manière suivante :

Set(
  myProfile;
  With({resultAPI: GroupesOffice365.HttpRequest("https://graph.microsoft.com/v1.0/me"; "GET"; "")};
  {
    aboutMe: Text(resultAPI.aboutMe);
    birthday: DateTimeValue(resultAPI.birthday);
    businessPhones: ForAll(
      wValue.businessPhones As loopValue;
      Text(loopValue)
    );
    ...etc...
  }
)

Comme tu le vois il faut forcer le typage de chaque colonne. Et parfois, les colonnes sont des tableaux et donc il faut boucler sur les valeurs du tableau (comme pour le businessPhones). La liste des champs est celle décrite dans l’objet de retour détaillé au format JSON par la documentation officielle du point de terminaison.

Selon les points de terminaison et selon l’opération, parfois rien n’est renvoyé -> et encore une fois impossible de savoir si ça c’est bien passé. C’est ton cas pour l’ajout d’un membre à un chat : il renvoie un statut 201 mais comme on ne peut pas le récupérer… Donc si tu veux vraiment vérifier faut refaire un appel API pour vérifier qu’il est bien dans le chat.

Voilà… Y’a un peu de taf quoi… D’où le composant que je vais sortir (mais qui sera payant vu le temps phénoménal que ça va me demander)…

Simon

Member

23 octobre 2024 at 21h59

En effet, j’ai encore besoin d’aide 😅

Concernant le second point

– Ajoute-lui les permissions du point de terminaison… je suis perdu comment puis-je ajouter des permissions du point de terminaison à un groupe de sécurité dans Azure AD ? 🤔

R3dKap

Member

26 octobre 2024 at 21h38

Salut @Simon,

Pour l’instant en termes de droits j’utilise l’onglet Permissions du Graph Explorer. Mais je n’ai pas encore réussi à mettre en place des droits propres et “automatisés” pour les utilisateurs d’une application de canevas utilisant le connecteur Groupes Office 365 et sa fonction HttpRequest.

Je te tiens au courant dès que c’est bon… 😉

Power Apps

Organizer:

Graph API ajouter un membre à un groupchat Teams ?

R3dKap

Simon

R3dKap

Simon

R3dKap

Simon

R3dKap