← Back to branch summary

~mateo-salta/touch-rss-scope/utfeed1

« back to all changes in this revision

Viewing changes to src/api/client.cpp

  • Committer: Mateo Salta
  • Date: 2014-11-30 22:43:28 UTC
  • Revision ID: mateo_salta@yahoo.com-20141130224328-1bshkjh7chb1kwvs
- Added 4 more custom feeds

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/api/client.cpp
 
1
#include <api/client.h>
 
2
 
 
3
#include <core/net/error.h>
 
4
#include <core/net/http/client.h>
 
5
#include <core/net/http/content_type.h>
 
6
#include <core/net/http/response.h>
 
7
#include <QVariantMap>
 
8
#include <iostream>
 
9
 
 
10
namespace http = core::net::http;
 
11
namespace net = core::net;
 
12
 
 
13
using namespace api;
 
14
using namespace std;
 
15
 
 
16
Client::Client(Config::Ptr config) :
 
17
    config_(config), cancelled_(false) {
 
18
}
 
19
 
 
20
 
 
21
void Client::get(const net::Uri::Path &path,
 
22
                 const net::Uri::QueryParameters &parameters, QJsonDocument &root) {
 
23
    // Create a new HTTP client
 
24
    auto client = http::make_client();
 
25
 
 
26
    // Start building the request configuration
 
27
    http::Request::Configuration configuration;
 
28
 
 
29
    // Build the URI from its components
 
30
    net::Uri uri = net::make_uri(config_->apiroot, path, parameters);
 
31
    configuration.uri = client->uri_to_string(uri);
 
32
 
 
33
    // Give out a user agent string
 
34
    configuration.header.add("User-Agent", config_->user_agent);
 
35
 
 
36
    // Build a HTTP request object from our configuration
 
37
    auto request = client->head(configuration);
 
38
 
 
39
    try {
 
40
        // Synchronously make the HTTP request
 
41
        // We bind the cancellable callback to #progress_report
 
42
        auto response = request->execute(
 
43
                    bind(&Client::progress_report, this, placeholders::_1));
 
44
 
 
45
        // Check that we got a sensible HTTP status code
 
46
        if (response.status != http::Status::ok) {
 
47
            throw domain_error(response.body);
 
48
        }
 
49
        // Parse the JSON from the response
 
50
        root = QJsonDocument::fromJson(response.body.c_str());
 
51
 
 
52
 
 
53
 
 
54
    } catch (net::Error &) {
 
55
    }
 
56
}
 
57
 
 
58
///
 
59
/// \brief Client::query_feeds
 
60
/// \param query
 
61
/// \param lang_sys
 
62
/// \return
 
63
///
 
64
 
 
65
 
 
66
Client::Feeds Client::query_feeds(const string& query, std::string const& lang_sys) {
 
67
    QJsonDocument root;
 
68
 
 
69
 
 
70
    // Build a URI and get the contents
 
71
    // The fist parameter forms the path part of the URI.
 
72
    // The second parameter forms the CGI parameters.
 
73
    get( { "feed", "find" }, {{ "q", query }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
74
    // e.g. https://ajax.googleapis.com/ajax/services/feed/find?q=Ubuntu&v=1.0
 
75
 
 
76
    Feeds result;
 
77
 
 
78
    QVariantMap variant = root.toVariant().toMap();
 
79
 
 
80
 
 
81
    QVariantMap responseData = variant["responseData"].toMap();
 
82
    // Iterate
 
83
    for (const QVariant &i : responseData["entries"].toList()) {
 
84
        QVariantMap item = i.toMap();
 
85
        // Add a result to the list
 
86
        result.feed.emplace_back(
 
87
                    Feed { item["title"].toString().toStdString(),
 
88
                            item["contentSnippet"].toString().toStdString(),
 
89
                            item["url"].toString().toStdString(),
 
90
                            item["link"].toString().toStdString(),
 
91
                    });
 
92
 
 
93
    }
 
94
    return result;
 
95
}
 
96
///
 
97
///
 
98
/// \brief Client::query_feedouts
 
99
/// \param query
 
100
/// \param lang_sys
 
101
/// \return
 
102
///
 
103
Client::Feedouts Client::query_feedouts(const string& linky, std::string const& lang_sys) {
 
104
    QJsonDocument root;
 
105
 
 
106
 
 
107
        get( { "feed", "load" }, {{ "q", linky }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
108
        // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
109
        ///
 
110
        /// \brief result
 
111
        ///
 
112
        Feedouts result;
 
113
        QVariantMap variant = root.toVariant().toMap();
 
114
 
 
115
 
 
116
        QVariantMap responseData = variant["responseData"].toMap();
 
117
 
 
118
        QVariantMap feed = responseData["feed"].toMap();
 
119
        // Iterate through the data
 
120
        for (const QVariant &i : feed["entries"].toList()) {
 
121
            QVariantMap item = i.toMap();
 
122
            // Add a result to the list
 
123
            result.feedout.emplace_back(
 
124
                        Feedout { item["title"].toString().toStdString(),
 
125
                                item["link"].toString().toStdString(),
 
126
                                item["publishedDate"].toString().toStdString(),
 
127
                                item["author"].toString().toStdString(),
 
128
                                item["content"].toString().toStdString(),
 
129
                        });
 
130
 
 
131
 
 
132
   }
 
133
 
 
134
 
 
135
 
 
136
    return result;
 
137
}
 
138
///
 
139
 
 
140
///
 
141
/// \brief Client::add_loads
 
142
/// \param add
 
143
/// \param lang_sys
 
144
/// \return
 
145
///
 
146
Client::Omgs Client::add_omgs(const string& add, std::string const& lang_sys) {
 
147
    QJsonDocument root;
 
148
 
 
149
    // Build a URI and get the contents
 
150
    // The fist parameter forms the path part of the URI.
 
151
    // The second parameter forms the CGI parameters.
 
152
    get( { "feed", "load" }, {{ "q", add }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
153
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
154
 
 
155
    Omgs result;
 
156
 
 
157
    QVariantMap variant = root.toVariant().toMap();
 
158
 
 
159
 
 
160
    QVariantMap responseData = variant["responseData"].toMap();
 
161
 
 
162
    QVariantMap feed = responseData["feed"].toMap();
 
163
    // Iterate through the data
 
164
    for (const QVariant &i : feed["entries"].toList()) {
 
165
        QVariantMap item = i.toMap();
 
166
        // Add a result to the list
 
167
        result.omg.emplace_back(
 
168
                    Omg { item["title"].toString().toStdString(),
 
169
                            item["link"].toString().toStdString(),
 
170
                            item["publishedDate"].toString().toStdString(),
 
171
                            item["author"].toString().toStdString(),
 
172
                            item["content"].toString().toStdString(),
 
173
                    });
 
174
    }
 
175
 
 
176
    return result;
 
177
}
 
178
///
 
179
 
 
180
 
 
181
///
 
182
/// \brief Client::add_loads
 
183
/// \param add
 
184
/// \param lang_sys
 
185
/// \return
 
186
///
 
187
Client::Loads Client::add_loads(const string& add, std::string const& lang_sys) {
 
188
    QJsonDocument root;
 
189
 
 
190
    // Build a URI and get the contents
 
191
    // The fist parameter forms the path part of the URI.
 
192
    // The second parameter forms the CGI parameters.
 
193
    get( { "feed", "load" }, {{ "q", add }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
194
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
195
 
 
196
    Loads result;
 
197
 
 
198
    QVariantMap variant = root.toVariant().toMap();
 
199
 
 
200
 
 
201
    QVariantMap responseData = variant["responseData"].toMap();
 
202
 
 
203
    QVariantMap feed = responseData["feed"].toMap();
 
204
    // Iterate through the data
 
205
    for (const QVariant &i : feed["entries"].toList()) {
 
206
        QVariantMap item = i.toMap();
 
207
        // Add a result to the list
 
208
        result.load.emplace_back(
 
209
                    Load { item["title"].toString().toStdString(),
 
210
                            item["link"].toString().toStdString(),
 
211
                            item["publishedDate"].toString().toStdString(),
 
212
                            item["author"].toString().toStdString(),
 
213
                            item["content"].toString().toStdString()
 
214
                    });
 
215
    }
 
216
 
 
217
    return result;
 
218
}
 
219
///
 
220
 
 
221
///
 
222
/// \brief Client::add_buntus
 
223
/// \param add
 
224
/// \param lang_sys
 
225
/// \return
 
226
///
 
227
Client::Buntus Client::add_buntus(const string& add, std::string const& lang_sys) {
 
228
    QJsonDocument root;
 
229
 
 
230
    // Build a URI and get the contents
 
231
    // The fist parameter forms the path part of the URI.
 
232
    // The second parameter forms the CGI parameters.
 
233
    get( { "feed", "load" }, {{ "q", add }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
234
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
235
 
 
236
    Buntus result;
 
237
 
 
238
    QVariantMap variant = root.toVariant().toMap();
 
239
 
 
240
 
 
241
    QVariantMap responseData = variant["responseData"].toMap();
 
242
 
 
243
    QVariantMap feed = responseData["feed"].toMap();
 
244
    // Iterate through the data
 
245
    for (const QVariant &i : feed["entries"].toList()) {
 
246
        QVariantMap item = i.toMap();
 
247
        // Add a result to the list
 
248
        result.buntu.emplace_back(
 
249
                    Buntu { item["title"].toString().toStdString(),
 
250
                            item["link"].toString().toStdString(),
 
251
                            item["author"].toString().toStdString(),
 
252
                            item["publishedDate"].toString().toStdString(),
 
253
                            item["content"].toString().toStdString(),
 
254
                    });
 
255
    }
 
256
 
 
257
    return result;
 
258
}
 
259
///
 
260
 
 
261
///
 
262
/// \brief Client::add_launchs
 
263
/// \param add
 
264
/// \param lang_sys
 
265
/// \return
 
266
///
 
267
Client::Plans Client::add_plans(const string& add, std::string const& lang_sys) {
 
268
    QJsonDocument root;
 
269
 
 
270
    // Build a URI and get the contents
 
271
    // The fist parameter forms the path part of the URI.
 
272
    // The second parameter forms the CGI parameters.
 
273
    get( { "feed", "load" }, {{ "q", add }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
274
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
275
 
 
276
    Plans result;
 
277
 
 
278
    QVariantMap variant = root.toVariant().toMap();
 
279
 
 
280
 
 
281
    QVariantMap responseData = variant["responseData"].toMap();
 
282
 
 
283
    QVariantMap feed = responseData["feed"].toMap();
 
284
    // Iterate through the data
 
285
    for (const QVariant &i : feed["entries"].toList()) {
 
286
        QVariantMap item = i.toMap();
 
287
        // Add a result to the list
 
288
        result.plan.emplace_back(
 
289
                    Plan { item["title"].toString().toStdString(),
 
290
                            item["link"].toString().toStdString(),
 
291
                            item["author"].toString().toStdString(),
 
292
                            item["publishedDate"].toString().toStdString(),
 
293
                            item["content"].toString().toStdString(),
 
294
                    });
 
295
    }
 
296
 
 
297
    return result;
 
298
}
 
299
///
 
300
 
 
301
///
 
302
/// \brief Client::add_launchs
 
303
/// \param add
 
304
/// \param lang_sys
 
305
/// \return
 
306
///
 
307
Client::Launchs Client::add_launchs(const string& add, std::string const& lang_sys) {
 
308
    QJsonDocument root;
 
309
 
 
310
    // Build a URI and get the contents
 
311
    // The fist parameter forms the path part of the URI.
 
312
    // The second parameter forms the CGI parameters.
 
313
    get( { "feed", "load" }, {{ "q", add }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
314
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
315
 
 
316
    Launchs result;
 
317
 
 
318
    QVariantMap variant = root.toVariant().toMap();
 
319
 
 
320
 
 
321
    QVariantMap responseData = variant["responseData"].toMap();
 
322
 
 
323
    QVariantMap feed = responseData["feed"].toMap();
 
324
    // Iterate through the data
 
325
    for (const QVariant &i : feed["entries"].toList()) {
 
326
        QVariantMap item = i.toMap();
 
327
        // Add a result to the list
 
328
        result.launch.emplace_back(
 
329
                    Launch { item["title"].toString().toStdString(),
 
330
                            item["link"].toString().toStdString(),
 
331
                            item["author"].toString().toStdString(),
 
332
                            item["publishedDate"].toString().toStdString(),
 
333
                            item["content"].toString().toStdString(),
 
334
                    });
 
335
    }
 
336
 
 
337
    return result;
 
338
}
 
339
///
 
340
 
 
341
///
 
342
/// \brief Client::add_customs
 
343
/// \param cust_sys
 
344
/// \param lang_sys
 
345
/// \return
 
346
///
 
347
Client::Customs Client::add_customs(std::string const& cust_sys, std::string const& lang_sys) {
 
348
    QJsonDocument root;
 
349
 
 
350
    // Build a URI and get the contents
 
351
    // The fist parameter forms the path part of the URI.
 
352
    // The second parameter forms the CGI parameters.
 
353
    get( { "feed", "load" }, {{ "q", "http://" + cust_sys }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
354
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
355
 
 
356
    Customs result;
 
357
 
 
358
    QVariantMap variant = root.toVariant().toMap();
 
359
 
 
360
 
 
361
     QVariantMap responseData = variant["responseData"].toMap();
 
362
 
 
363
     QVariantMap feed = responseData["feed"].toMap();
 
364
    // Iterate through the  data
 
365
    for (const QVariant &i : feed["entries"].toList()) {
 
366
        QVariantMap item = i.toMap();
 
367
       // QVariantMap images = item["image"].toMap();
 
368
        // Add a result to the list
 
369
        result.custom.emplace_back(
 
370
                    Custom { item["title"].toString().toStdString(),
 
371
                            item["link"].toString().toStdString(),
 
372
                            item["author"].toString().toStdString(),
 
373
                            item["publishedDate"].toString().toStdString(),
 
374
                            item["content"].toString().toStdString(),
 
375
                    });
 
376
    }
 
377
 
 
378
    return result;
 
379
}
 
380
///
 
381
 
 
382
///
 
383
/// \brief Client::add_customs
 
384
/// \param cust_sys
 
385
/// \param lang_sys
 
386
/// \return
 
387
///
 
388
Client::Custom1s Client::add_custom1s(std::string const& cust_sys1, std::string const& lang_sys) {
 
389
    QJsonDocument root;
 
390
 
 
391
    // Build a URI and get the contents
 
392
    // The fist parameter forms the path part of the URI.
 
393
    // The second parameter forms the CGI parameters.
 
394
    get( { "feed", "load" }, {{ "q", "http://" + cust_sys1 }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
395
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
396
 
 
397
    Custom1s result;
 
398
 
 
399
    QVariantMap variant = root.toVariant().toMap();
 
400
 
 
401
 
 
402
     QVariantMap responseData = variant["responseData"].toMap();
 
403
 
 
404
     QVariantMap feed = responseData["feed"].toMap();
 
405
    // Iterate through the  data
 
406
    for (const QVariant &i : feed["entries"].toList()) {
 
407
        QVariantMap item = i.toMap();
 
408
       // QVariantMap images = item["image"].toMap();
 
409
        // Add a result to the list
 
410
        result.custom1.emplace_back(
 
411
                    Custom1 { item["title"].toString().toStdString(),
 
412
                            item["link"].toString().toStdString(),
 
413
                            item["author"].toString().toStdString(),
 
414
                            item["publishedDate"].toString().toStdString(),
 
415
                            item["content"].toString().toStdString(),
 
416
                    });
 
417
    }
 
418
 
 
419
    return result;
 
420
}
 
421
///
 
422
///
 
423
 
 
424
///
 
425
/// \brief Client::add_customs
 
426
/// \param cust_sys
 
427
/// \param lang_sys
 
428
/// \return
 
429
///
 
430
Client::Custom2s Client::add_custom2s(std::string const& cust_sys2, std::string const& lang_sys) {
 
431
    QJsonDocument root;
 
432
 
 
433
    // Build a URI and get the contents
 
434
    // The fist parameter forms the path part of the URI.
 
435
    // The second parameter forms the CGI parameters.
 
436
    get( { "feed", "load" }, {{ "q", "http://" + cust_sys2 }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
437
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
438
 
 
439
    Custom2s result;
 
440
 
 
441
    QVariantMap variant = root.toVariant().toMap();
 
442
 
 
443
 
 
444
     QVariantMap responseData = variant["responseData"].toMap();
 
445
 
 
446
     QVariantMap feed = responseData["feed"].toMap();
 
447
    // Iterate through the  data
 
448
    for (const QVariant &i : feed["entries"].toList()) {
 
449
        QVariantMap item = i.toMap();
 
450
       // QVariantMap images = item["image"].toMap();
 
451
        // Add a result to the list
 
452
        result.custom2.emplace_back(
 
453
                    Custom2 { item["title"].toString().toStdString(),
 
454
                            item["link"].toString().toStdString(),
 
455
                            item["author"].toString().toStdString(),
 
456
                            item["publishedDate"].toString().toStdString(),
 
457
                            item["content"].toString().toStdString(),
 
458
                    });
 
459
    }
 
460
 
 
461
    return result;
 
462
}
 
463
///
 
464
 
 
465
///
 
466
/// \brief Client::add_customs
 
467
/// \param cust_sys
 
468
/// \param lang_sys
 
469
/// \return
 
470
///
 
471
Client::Custom3s Client::add_custom3s(std::string const& cust_sys3, std::string const& lang_sys) {
 
472
    QJsonDocument root;
 
473
 
 
474
    // Build a URI and get the contents
 
475
    // The fist parameter forms the path part of the URI.
 
476
    // The second parameter forms the CGI parameters.
 
477
    get( { "feed", "load" }, {{ "q", "http://" + cust_sys3 }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
478
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
479
 
 
480
    Custom3s result;
 
481
 
 
482
    QVariantMap variant = root.toVariant().toMap();
 
483
 
 
484
 
 
485
     QVariantMap responseData = variant["responseData"].toMap();
 
486
 
 
487
     QVariantMap feed = responseData["feed"].toMap();
 
488
    // Iterate through the  data
 
489
    for (const QVariant &i : feed["entries"].toList()) {
 
490
        QVariantMap item = i.toMap();
 
491
       // QVariantMap images = item["image"].toMap();
 
492
        // Add a result to the list
 
493
        result.custom3.emplace_back(
 
494
                    Custom3 { item["title"].toString().toStdString(),
 
495
                            item["link"].toString().toStdString(),
 
496
                            item["author"].toString().toStdString(),
 
497
                            item["publishedDate"].toString().toStdString(),
 
498
                            item["content"].toString().toStdString(),
 
499
                    });
 
500
    }
 
501
 
 
502
    return result;
 
503
}
 
504
///
 
505
 
 
506
///
 
507
/// \brief Client::add_customs
 
508
/// \param cust_sys
 
509
/// \param lang_sys
 
510
/// \return
 
511
///
 
512
Client::Custom4s Client::add_custom4s(std::string const& cust_sys4, std::string const& lang_sys) {
 
513
    QJsonDocument root;
 
514
 
 
515
    // Build a URI and get the contents
 
516
    // The fist parameter forms the path part of the URI.
 
517
    // The second parameter forms the CGI parameters.
 
518
    get( { "feed", "load" }, {{ "q", "http://" + cust_sys4 }, {"v", "1.0"}, { "hl", lang_sys }}, root);
 
519
    // e.g. https://ajax.googleapis.com/ajax/services/feed/load?q=Ubuntu&v=1.0
 
520
 
 
521
    Custom4s result;
 
522
 
 
523
    QVariantMap variant = root.toVariant().toMap();
 
524
 
 
525
 
 
526
     QVariantMap responseData = variant["responseData"].toMap();
 
527
 
 
528
     QVariantMap feed = responseData["feed"].toMap();
 
529
    // Iterate through the  data
 
530
    for (const QVariant &i : feed["entries"].toList()) {
 
531
        QVariantMap item = i.toMap();
 
532
       // QVariantMap images = item["image"].toMap();
 
533
        // Add a result to the list
 
534
        result.custom4.emplace_back(
 
535
                    Custom4 { item["title"].toString().toStdString(),
 
536
                            item["link"].toString().toStdString(),
 
537
                            item["author"].toString().toStdString(),
 
538
                            item["publishedDate"].toString().toStdString(),
 
539
                            item["content"].toString().toStdString(),
 
540
                    });
 
541
    }
 
542
 
 
543
    return result;
 
544
}
 
545
///
 
546
 
 
547
/// \brief Client::progress_report
 
548
/// \return
 
549
///
 
550
http::Request::Progress::Next Client::progress_report(
 
551
        const http::Request::Progress&) {
 
552
 
 
553
    return cancelled_ ?
 
554
                http::Request::Progress::Next::abort_operation :
 
555
                http::Request::Progress::Next::continue_operation;
 
556
}
 
557
 
 
558
void Client::cancel() {
 
559
    cancelled_ = true;
 
560
}
 
561
 
 
562
Config::Ptr Client::config() {
 
563
    return config_;
 
564
}
 
565