SharePoint y Azure - El Microsoft Translator API

1[FunctionName("TranslationFunction")]
2
3public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)]HttpRequestMessage req, TraceWriter log)
4
5{
6
7// Registration
8
9string validationToken = req.GetQueryNameValuePairs()
10
11.FirstOrDefault(q => string.Compare(q.Key, "validationtoken", true) == 0)
12
13.Value;
14
15if (validationToken != null)
16
17{
18
19var myResponse = req.CreateResponse(HttpStatusCode.OK);
20
21myResponse.Content = new StringContent(validationToken);
22
23return myResponse;
24
25}
26
27
28
29// Changes
30
31var myContent = await req.Content.ReadAsStringAsync();
32
33var allNotifications = JsonConvert.DeserializeObject<ResponseModel<NotificationModel>>(myContent).Value;
34
35
36
37if (allNotifications.Count > 0)
38
39{
40
41foreach (var oneNotification in allNotifications)
42
43{
44
45// Login in SharePoint
46
47string baseUrl = "https://gustavo.sharepoint.com";
48
49string myUserName = "gustavo@gustavo.onmicrosoft.com";
50
51string myPassword = ConfigurationManager.AppSettings["gustavoPW"];
52
53
54
55SecureString securePassword = new SecureString();
56
57foreach (char oneChar in myPassword) securePassword.AppendChar(oneChar);
58
59SharePointOnlineCredentials myCredentials = new SharePointOnlineCredentials(myUserName, securePassword);
60
61
62
63ClientContext SPClientContext = new ClientContext(baseUrl + oneNotification.SiteUrl);
64
65SPClientContext.Credentials = myCredentials;
66
67
68
69// Get the Changes
70
71GetChanges(SPClientContext, oneNotification.Resource, log);
72
73}
74
75}
76
77
78
79return new HttpResponseMessage(HttpStatusCode.OK);
80
81}
82

1static void GetChanges(ClientContext SPClientContext, string ListId, TraceWriter log)
2
3{
4
5// Get the List
6
7Web spWeb = SPClientContext.Site.RootWeb;
8
9List listaAnunciosES = spWeb.Lists.GetByTitle("AnnouncementsES");
10
11SPClientContext.Load(listaAnunciosES);
12
13List listaAnunciosEN = spWeb.Lists.GetByTitle("AnnouncementsEN");
14
15SPClientContext.Load(listaAnunciosEN);
16
17SPClientContext.ExecuteQuery();
18
19
20
21// Create the ChangeToken and Change Query
22
23ChangeToken lastChangeToken = new ChangeToken();
24
25lastChangeToken.StringValue = string.Format("1;3;{0};{1};-1", ListId, DateTime.Now.AddMinutes(-1).ToUniversalTime().Ticks.ToString());
26
27ChangeToken newChangeToken = new ChangeToken();
28
29newChangeToken.StringValue = string.Format("1;3;{0};{1};-1", ListId, DateTime.Now.ToUniversalTime().Ticks.ToString());
30
31ChangeQuery myChangeQuery = new ChangeQuery(false, false);
32
33myChangeQuery.Item = true;  // Get only Item changes
34
35myChangeQuery.Add = true;   // Get only the new Items
36
37myChangeQuery.ChangeTokenStart = lastChangeToken;
38
39myChangeQuery.ChangeTokenEnd = newChangeToken;
40
41
42
43// Get all the Changes
44
45var allChanges = listaAnunciosES.GetChanges(myChangeQuery);
46
47SPClientContext.Load(allChanges);
48
49SPClientContext.ExecuteQuery();
50
51
52
53foreach (Change oneChange in allChanges)
54
55{
56
57if (oneChange is ChangeItem)
58
59{
60
61// Get what is changed
62
63ListItem anuncioES = listaAnunciosES.GetItemById((oneChange as ChangeItem).ItemId);
64
65SPClientContext.Load(anuncioES);
66
67SPClientContext.ExecuteQuery();
68
69
70
71string textoParaTraducir = anuncioES["Body"].ToString().Replace("\"", "'");
72
73string lenguajeDe = "es";
74
75string lenguajeA = "en";
76
77string apiKey = ConfigurationManager.AppSettings["apiKey"];
78
79string textoTraducido = getTraduccion(textoParaTraducir, lenguajeDe, lenguajeA, apiKey);
80
81
82
83// Insert the values in the EN List
84
85ListItemCreationInformation newAnuncioENInfo = new ListItemCreationInformation();
86
87ListItem anuncioEN = listaAnunciosEN.AddItem(newAnuncioENInfo);
88
89anuncioEN["Title"] = anuncioES["Title"];
90
91anuncioEN["Body"] = textoTraducido;
92
93anuncioEN.Update();
94
95SPClientContext.ExecuteQuery();
96
97}
98
99}
100
101}
102

1static string getTraduccion(string TextoParaTraducir, string LenguajeDe, string LenguajeA, string ApiKey)
2
3{
4
5string txtTraducido = string.Empty;
6
7
8
9AzureAuthToken authTokenSource = new AzureAuthToken(ApiKey.Trim());
10
11string authToken = authTokenSource.GetAccessTokenAsync().Result;
12
13
14
15string uriTraduccion = "https://api.microsofttranslator.com/v2/Http.svc/Translate?text=" +
16
17HttpUtility.UrlEncode(TextoParaTraducir) +
18
19"&from=" + LenguajeDe + "&to=" + LenguajeA;
20
21HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uriTraduccion);
22
23httpWebRequest.Headers.Add("Authorization", authToken);
24
25using (WebResponse myResponse = httpWebRequest.GetResponse())
26
27using (Stream stream = myResponse.GetResponseStream())
28
29{
30
31DataContractSerializer mySerializer = new DataContractSerializer(Type.GetType("System.String"));
32
33txtTraducido = (string)mySerializer.ReadObject(stream);
34
35}
36
37
38
39return txtTraducido;
40
41}
42

1using System;
2
3using System.Net;
4
5using System.Net.Http;
6
7using System.Threading.Tasks;
8
9
10
11namespace TranslationFunction
12
13{
14
15/// <summary>
16
17/// Client to call Cognitive Services Azure Auth Token service in order to get an access token.
18
19/// Exposes asynchronous as well as synchronous methods.
20
21/// </summary>
22
23public class AzureAuthToken
24
25{
26
27/// URL of the token service
28
29private static readonly Uri ServiceUrl = new Uri("https://api.cognitive.microsoft.com/sts/v1.0/issueToken");
30
31
32
33/// Name of header used to pass the subscription key to the token service
34
35private const string OcpApimSubscriptionKeyHeader = "Ocp-Apim-Subscription-Key";
36
37
38
39/// After obtaining a valid token, this class will cache it for this duration.
40
41/// Use a duration of 5 minutes, which is less than the actual token lifetime of 10 minutes.
42
43private static readonly TimeSpan TokenCacheDuration = new TimeSpan(0, 5, 0);
44
45
46
47/// Cache the value of the last valid token obtained from the token service.
48
49private string \_storedTokenValue = string.Empty;
50
51
52
53/// When the last valid token was obtained.
54
55private DateTime \_storedTokenTime = DateTime.MinValue;
56
57
58
59/// Gets the subscription key.
60
61public string SubscriptionKey { get; }
62
63
64
65/// Gets the HTTP status code for the most recent request to the token service.
66
67public HttpStatusCode RequestStatusCode { get; private set; }
68
69
70
71/// <summary>
72
73/// Creates a client to obtain an access token.
74
75/// </summary>
76
77/// <param name="key">Subscription key to use to get an authentication token.</param>
78
79public AzureAuthToken(string key)
80
81{
82
83if (string.IsNullOrEmpty(key))
84
85{
86
87throw new ArgumentNullException(nameof(key), "A subscription key is required");
88
89}
90
91
92
93this.SubscriptionKey = key;
94
95this.RequestStatusCode = HttpStatusCode.InternalServerError;
96
97}
98
99
100
101/// <summary>
102
103/// Gets a token for the specified subscription.
104
105/// </summary>
106
107/// <returns>The encoded JWT token prefixed with the string "Bearer ".</returns>
108
109/// <remarks>
110
111/// This method uses a cache to limit the number of request to the token service.
112
113/// A fresh token can be re-used during its lifetime of 10 minutes. After a successful
114
115/// request to the token service, this method caches the access token. Subsequent
116
117/// invocations of the method return the cached token for the next 5 minutes. After
118
119/// 5 minutes, a new token is fetched from the token service and the cache is updated.
120
121/// </remarks>
122
123public async Task<string> GetAccessTokenAsync()
124
125{
126
127if (string.IsNullOrWhiteSpace(this.SubscriptionKey))
128
129{
130
131return string.Empty;
132
133}
134
135
136
137// Re-use the cached token if there is one.
138
139if ((DateTime.Now - \_storedTokenTime) < TokenCacheDuration)
140
141{
142
143return \_storedTokenValue;
144
145}
146
147
148
149using (var client = new HttpClient())
150
151using (var request = new HttpRequestMessage())
152
153{
154
155request.Method = HttpMethod.Post;
156
157request.RequestUri = ServiceUrl;
158
159request.Content = new StringContent(string.Empty);
160
161request.Headers.TryAddWithoutValidation(OcpApimSubscriptionKeyHeader, this.SubscriptionKey);
162
163client.Timeout = TimeSpan.FromSeconds(2);
164
165var response = await client.SendAsync(request);
166
167this.RequestStatusCode = response.StatusCode;
168
169response.EnsureSuccessStatusCode();
170
171var token = await response.Content.ReadAsStringAsync();
172
173\_storedTokenTime = DateTime.Now;
174
175\_storedTokenValue = "Bearer " + token;
176
177return \_storedTokenValue;
178
179}
180
181}
182
183
184
185/// <summary>
186
187/// Gets a token for the specified subscription. Synchronous version.
188
189/// Use of async version preferred
190
191/// </summary>
192
193/// <returns>The encoded JWT token prefixed with the string "Bearer ".</returns>
194
195/// <remarks>
196
197/// This method uses a cache to limit the number of request to the token service.
198
199/// A fresh token can be re-used during its lifetime of 10 minutes. After a successful
200
201/// request to the token service, this method caches the access token. Subsequent
202
203/// invocations of the method return the cached token for the next 5 minutes. After
204
205/// 5 minutes, a new token is fetched from the token service and the cache is updated.
206
207/// </remarks>
208
209public string GetAccessToken()
210
211{
212
213// Re-use the cached token if there is one.
214
215if ((DateTime.Now - \_storedTokenTime) < TokenCacheDuration)
216
217{
218
219return \_storedTokenValue;
220
221}
222
223
224
225string accessToken = null;
226
227var task = Task.Run(async () =>
228
229{
230
231accessToken = await this.GetAccessTokenAsync();
232
233});
234
235
236
237while (!task.IsCompleted)
238
239{
240
241System.Threading.Thread.Yield();
242
243}
244
245if (task.IsFaulted)
246
247{
248
249throw task.Exception;
250
251}
252
253if (task.IsCanceled)
254
255{
256
257throw new Exception("Timeout obtaining access token.");
258
259}
260
261return accessToken;
262
263}
264
265
266
267}
268
269}
270
27111  .          Otras tres clases definen objetos utilizados por el WebHook:
272
273public class ResponseModel<T>
274
275{
276
277[JsonProperty(PropertyName = "value")]
278
279public List<T> Value { get; set; }
280
281}
282
283
284
285public class NotificationModel
286
287{
288
289[JsonProperty(PropertyName = "subscriptionId")]
290
291public string SubscriptionId { get; set; }
292
293
294
295[JsonProperty(PropertyName = "clientState")]
296
297public string ClientState { get; set; }
298
299
300
301[JsonProperty(PropertyName = "expirationDateTime")]
302
303public DateTime ExpirationDateTime { get; set; }
304
305
306
307[JsonProperty(PropertyName = "resource")]
308
309public string Resource { get; set; }
310
311
312
313[JsonProperty(PropertyName = "tenantId")]
314
315public string TenantId { get; set; }
316
317
318
319[JsonProperty(PropertyName = "siteUrl")]
320
321public string SiteUrl { get; set; }
322
323
324
325[JsonProperty(PropertyName = "webId")]
326
327public string WebId { get; set; }
328
329}
330
331
332
333public class SubscriptionModel
334
335{
336
337[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
338
339public string Id { get; set; }
340
341
342
343[JsonProperty(PropertyName = "clientState", NullValueHandling = NullValueHandling.Ignore)]
344
345public string ClientState { get; set; }
346
347
348
349[JsonProperty(PropertyName = "expirationDateTime")]
350
351public DateTime ExpirationDateTime { get; set; }
352
353
354
355[JsonProperty(PropertyName = "notificationUrl")]
356
357public string NotificationUrl { get; set; }
358
359
360
361[JsonProperty(PropertyName = "resource", NullValueHandling = NullValueHandling.Ignore)]
362
363public string Resource { get; set; }
364
365}​
366