← Back to branch summary

~ubuntu-branches/ubuntu/trusty/digikam/trusty

« back to all changes in this revision

Viewing changes to extra/kipi-plugins/imgurexport/imgurtalker.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg
  • Date: 2012-11-26 18:24:20 UTC
  • mfrom: (1.9.1) (3.1.23 experimental)
  • Revision ID: package-import@ubuntu.com-20121126182420-qoy6z0nx4ai0wzcl
Tags: 4:3.0.0~beta3-0ubuntu1
https://launchpad.net/bugs/890059
https://launchpad.net/bugs/1011211
https://launchpad.net/bugs/658047
* New upstream release
  - Add build-deps :  libhupnp-dev, libqtgstreamer-dev, libmagickcore-dev
* Merge from debian, remaining changes:
  - Make sure libqt4-opengl-dev, libgl1-mesa-dev and libglu1-mesa-dev only
    install on i386,amd64 and powerpc
  - Depend on libtiff-dev instead of libtiff4-dev
  - Drop digikam breaks/replaces kipi-plugins-common since we're past the
    LTS release now
  - digikam to recommend mplayerthumbs | ffmpegthumbs. We currently only
    have latter in the archives, even though former is also supposed to
    be part of kdemultimedia. (LP: #890059)
  - kipi-plugins to recommend www-browser rather than konqueror directly
    since 2.8 no direct usage of konqueror is present in the flickr
    plugin anymore (LP: #1011211)
  - Keep kubuntu_mysqld_executable_name.diff
  - Don't install libkipi translations
  - Keep deps on libcv-dev, libcvaux-dev
  - Keep split packaging of libraries
  - Replace icons from KDE 3 time in debian/xpm.d/*.xpm with the new
    versions (LP: #658047)
* Update debian/not-installed

Show diffs side-by-side

added added

removed removed

Lines of Context:
extra/kipi-plugins/imgurexport/imgurtalker.cpp
43
43
 
44
44
#include "mpform.h"
45
45
#include "kpversion.h"
 
46
#include "plugin_imgurexport.h"
46
47
 
47
48
namespace KIPIImgurExportPlugin
48
49
{
 
50
typedef QMultiMap<QString, QString> KQOAuthParameters;
49
51
 
50
52
class ImgurTalker::ImgurTalkerPriv
51
53
{
56
58
        parent    = 0;
57
59
        interface = 0;
58
60
        job       = 0;
59
 
        queue     = 0;
 
61
        continueUpload       = true;
 
62
 
 
63
        userAgent = QString("KIPI-Plugins-" + Plugin_ImgurExport::name() + "/" + kipipluginsVersion());
 
64
 
 
65
        const char _imgurApiKey[] = _IMGUR_API_ANONYMOUS_KEY;
 
66
        anonymousKey = QByteArray( _imgurApiKey );
60
67
    }
61
68
 
62
 
    QString     apiKey;
63
 
    QString     userAgent;
 
69
    bool           continueUpload;
 
70
    QString        userAgent;
 
71
 
 
72
    QByteArray     anonymousKey;
64
73
 
65
74
    QWidget*    parent;
66
75
    Interface*  interface;
67
76
    QByteArray  buffer;
68
77
 
69
 
    State       state;
70
 
    KUrl        currentUrl;
71
78
    KIO::Job*   job;
72
 
 
73
 
    KUrl::List* queue;
74
79
};
75
80
 
76
81
ImgurTalker::ImgurTalker(Interface* const interface, QWidget* const parent)
80
85
    d->interface           = interface;
81
86
 
82
87
    d->job                 = 0;
83
 
    d->userAgent           = QString("KIPI-Plugins-ImgurTalker/" + kipipluginsVersion());
84
 
 
85
 
    d->apiKey              = _IMGUR_API_KEY;
86
 
 
87
 
    d->queue               = new KUrl::List();
88
 
 
89
 
    connect(this, SIGNAL(signalUploadDone()),
90
 
            this, SLOT(slotUploadDone()));
91
 
 
 
88
 
 
89
    m_queue               = new KUrl::List();
 
90
 
 
91
    connect(this, SIGNAL(signalUploadDone(KUrl)),
 
92
            this, SLOT(slotUploadDone(KUrl)));
 
93
 
 
94
    // -------------------------------------------------------------------------
 
95
/**/
92
96
    ImageCollection images = interface->currentSelection();
93
97
    if (images.isValid())
94
98
    {
95
99
        slotAddItems(images.images());
96
100
    }
 
101
/**/
97
102
}
98
103
 
99
104
ImgurTalker::~ImgurTalker()
121
126
    emit signalUploadProgress(j->percent());
122
127
}
123
128
 
 
129
void ImgurTalker::parseResponse(QByteArray buffer)
 
130
{
 
131
    bool parseOk = false;
 
132
    emit signalUploadDone(m_currentUrl);
 
133
 
 
134
    switch(state)
 
135
    {
 
136
        case IE_REMOVEPHOTO:
 
137
            parseOk = parseResponseImageRemove(buffer);
 
138
            break;
 
139
 
 
140
        case IE_ADDPHOTO:
 
141
            parseOk = parseResponseImageUpload(buffer);
 
142
            break;
 
143
        default:
 
144
            break;
 
145
    }
 
146
 
 
147
    if (!parseOk)
 
148
    {
 
149
        // received something unexpected
 
150
        kDebug() <<  "Unexpected response from the web-service";
 
151
    }
 
152
 
 
153
    emit signalBusy(false);
 
154
}
 
155
 
124
156
void ImgurTalker::slotResult(KJob* kjob)
125
157
{
126
158
    KIO::Job* job = static_cast<KIO::Job*>(kjob);
129
161
    {
130
162
        ImgurError err;
131
163
        err.message = tr("Upload failed");
132
 
        emit signalError(err); //job->errorString()
 
164
        emit signalError(m_currentUrl, err); //job->errorString()
133
165
        kDebug() << "Error :" << job->errorString();
134
166
    }
135
167
 
136
 
    bool parseOk = false;
137
 
 
138
 
    switch(d->state)
139
 
    {
140
 
        case IE_REMOVEPHOTO:
141
 
            parseOk = parseResponseImageRemove(d->buffer);
142
 
            break;
143
 
 
144
 
        case IE_ADDPHOTO:
145
 
            parseOk = parseResponseImageUpload(d->buffer);
146
 
            break;
147
 
        default:
148
 
            break;
149
 
    }
150
 
    kDebug() << "ParseOk :" << parseOk;
 
168
    parseResponse(d->buffer);
151
169
 
152
170
    d->buffer.resize(0);
153
171
 
154
 
    emit signalBusy(false);
155
 
 
156
172
    return;
157
173
}
158
174
 
159
 
void ImgurTalker::slotUploadDone()
 
175
void ImgurTalker::slotUploadDone(KUrl currentFile)
160
176
{
161
 
    if (d->queue->isEmpty())
 
177
    // removing the top of the queue
 
178
    if (!m_queue->isEmpty())
162
179
    {
163
 
        return;
164
 
    }
165
 
 
166
 
    kDebug () << "Upload done for" << d->currentUrl << "Queue has" << d->queue->length() << "items";
167
 
    d->queue->removeFirst();
168
 
 
169
 
    emit signalQueueChanged();
 
180
        m_queue->removeFirst();
 
181
        emit signalQueueChanged();
 
182
    }
 
183
    kDebug () << "Upload done for" << currentFile << "Queue has" << m_queue->length() << "items";
 
184
}
 
185
 
 
186
void ImgurTalker::slotContinueUpload(bool yes)
 
187
{
 
188
    d->continueUpload = yes;
 
189
    if (yes && !m_queue->isEmpty()) {
 
190
        // the top of the queue was already removed - first() is a new image
 
191
        imageUpload(m_queue->first());
 
192
    }
 
193
    return;
170
194
}
171
195
 
172
196
bool ImgurTalker::parseResponseImageRemove(const QByteArray& data)
173
197
{
174
 
    emit signalUploadDone();
175
198
    if (data.isEmpty())
176
199
    {
177
200
        // TODO
189
212
    QJson::Parser* p = new QJson::Parser();
190
213
    QVariant       r = p->parse(data, &ok);
191
214
 
192
 
    emit signalUploadDone();
 
215
//    kDebug() << data;
193
216
    if (ok)
194
217
    {
195
218
        QMap<QString, QVariant> m = r.toMap();
243
266
                }
244
267
            }
245
268
 
246
 
            emit signalError(error); // p->errorString()
247
 
            return false;
 
269
            emit signalError(m_currentUrl, error); // p->errorString()
 
270
            kDebug() << "Imgur Error:" << p->errorString();
248
271
        }
249
272
 
250
273
        if (responseType == "upload" )
277
300
                        {
278
301
                            success.image.hash = value;
279
302
                        }
280
 
                        if (it.key() == "deleteHash")
 
303
                        if (it.key() == "deletehash")
281
304
                        {
282
305
                            success.image.deletehash = value;
283
306
                        }
284
 
                        if (it.key() == "dateTime")
 
307
                        if (it.key() == "datetime")
285
308
                        {
286
 
                            //success.image.datetime = QDateTime(value);
 
309
//                            success.image.datetime = QDateTime(value);
287
310
                        }
288
311
                        if (it.key() == "type")
289
312
                        {
347
370
                }
348
371
            }
349
372
 
350
 
            emit signalSuccess(success);
 
373
            emit signalSuccess(m_currentUrl, success);
351
374
        }
352
375
    }
353
376
    else
355
378
        ImgurError error;
356
379
        error.message = "Parse error";
357
380
 
358
 
        emit signalError (error); // p->errorString()
359
 
        kDebug() << "Parser error :" << p->errorString();
360
 
        return false;
 
381
        emit signalError (m_currentUrl, error);
 
382
        kDebug() << "Parse Error:" << p->errorString();
361
383
    }
362
384
 
363
 
    return true;
 
385
    return ok;
364
386
}
365
387
 
366
 
bool ImgurTalker::imageUpload(const KUrl& filePath)
 
388
void ImgurTalker::imageUpload (const KUrl& filePath)
367
389
{
368
 
    d->currentUrl  = filePath;
 
390
    state = IE_ADDPHOTO;
 
391
 
 
392
    setCurrentUrl(filePath);
 
393
 
 
394
    kDebug() << "Anonymous upload of " << filePath;
 
395
 
 
396
    emit signalUploadStart(filePath);
 
397
    emit signalBusy(true);
369
398
 
370
399
    MPForm form;
371
400
 
372
 
    KUrl exportUrl = KUrl("http://api.imgur.com/2/upload.json");
373
 
    exportUrl.addQueryItem("key", d->apiKey);
 
401
    KUrl exportUrl = KUrl(ImgurConnection::APIuploadURL());
374
402
 
 
403
    exportUrl.addQueryItem("key", d->anonymousKey.data());
375
404
    exportUrl.addQueryItem("name", filePath.fileName());
376
405
    exportUrl.addQueryItem("title", filePath.fileName()); // this should be replaced with something the user submits
377
406
//    exportUrl.addQueryItem("caption", ""); // this should be replaced with something the user submits
391
420
 
392
421
    connect(job, SIGNAL(result(KJob*)),
393
422
            this, SLOT(slotResult(KJob*)));
394
 
 
395
 
    d->state = IE_ADDPHOTO;
396
 
 
397
 
    emit signalUploadStart(filePath);
398
 
    emit signalBusy(true);
399
 
 
400
 
    return true;
401
423
}
402
424
 
403
425
bool ImgurTalker::imageRemove(const QString& delete_hash)
405
427
    // @TODO : make sure it works
406
428
    MPForm form;
407
429
 
408
 
    KUrl removeUrl = KUrl("http://api.imgur.com/2/delete/");
 
430
    KUrl removeUrl = KUrl(ImgurConnection::APIdeleteURL());
409
431
    removeUrl.addPath(delete_hash + ".json");
410
432
 
411
433
    form.finish();
414
436
    job->addMetaData("content-type", form.contentType());
415
437
    job->addMetaData("UserAgent", d->userAgent);
416
438
 
417
 
    d->state = IE_REMOVEPHOTO;
 
439
    state = IE_REMOVEPHOTO;
418
440
 
419
441
    emit signalBusy(true);
420
442
    emit signalQueueChanged();
442
464
 
443
465
    for( KUrl::List::ConstIterator it = list.begin(); it != list.end(); ++it )
444
466
    {
445
 
        if (!d->queue->contains(*it))
 
467
        if (!m_queue->contains(*it))
446
468
        {
447
 
            d->queue->append(*it);
 
469
            m_queue->append(*it);
448
470
        }
449
471
    }
450
472
 
451
473
    emit signalQueueChanged();
452
474
}
453
475
 
454
 
void ImgurTalker::slotRemoveItems(const KUrl::List list)
 
476
void ImgurTalker::slotRemoveItems(const KUrl::List &list)
455
477
{
456
478
    if (list.isEmpty())
457
479
    {
460
482
 
461
483
    for( KUrl::List::ConstIterator it = list.begin(); it != list.end(); ++it )
462
484
    {
463
 
        d->queue->removeAll(*it);
 
485
        m_queue->removeAll(*it);
464
486
    }
465
487
 
466
488
    emit signalQueueChanged();
467
489
}
468
490
 
 
491
void ImgurTalker::setCurrentUrl(const KUrl url)
 
492
{
 
493
    m_currentUrl = url;
 
494
}
 
495
 
469
496
KUrl::List* ImgurTalker::imageQueue() const
470
497
{
471
 
    return d->queue;
 
498
    return m_queue;
472
499
}
473
500
 
474
 
KUrl ImgurTalker::geCurrentUrl() const
 
501
KUrl ImgurTalker::currentUrl() const
475
502
{
476
 
    return d->currentUrl;
 
503
    return m_currentUrl;
477
504
}
478
505
 
479
506
} // namespace KIPIImgurExportPlugin