← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/kdepim/oneiric-updates

« back to all changes in this revision

Viewing changes to blogilo/src/backend.cpp

  • Committer: Package Import Robot
  • Author(s): Philip Muškovac
  • Date: 2011-06-28 19:33:24 UTC
  • mfrom: (0.2.13) (0.1.13 sid)
  • Revision ID: package-import@ubuntu.com-20110628193324-8yvjs8sdv9rdoo6c
Tags: 4:4.7.0-0ubuntu1
* New upstream release
  - update install files
  - add missing kdepim-doc package to control file
  - Fix Vcs lines
  - kontact breaks/replaces korganizer << 4:4.6.80
  - tighten the dependency of kdepim-dev on libkdepim4 to fix lintian error

Show diffs side-by-side

added added

removed removed

Lines of Context:
blogilo/src/backend.cpp
1
1
/*
2
2
    This file is part of Blogilo, A KDE Blogging Client
3
3
 
4
 
    Copyright (C) 2008-2009 Mehrdad Momeny <mehrdad.momeny@gmail.com>
5
 
    Copyright (C) 2008-2009 Golnaz Nilieh <g382nilieh@gmail.com>
 
4
    Copyright (C) 2008-2010 Mehrdad Momeny <mehrdad.momeny@gmail.com>
 
5
    Copyright (C) 2008-2010 Golnaz Nilieh <g382nilieh@gmail.com>
6
6
 
7
7
    This program is free software; you can redistribute it and/or
8
8
    modify it under the terms of the GNU General Public License as
42
42
#include <kio/job.h>
43
43
#include <settings.h>
44
44
 
45
 
Backend::Backend( int blog_id, QObject* parent ): QObject( parent )
 
45
const QRegExp splitRX("((<hr/?>)?<!--split-->)");
 
46
 
 
47
class Backend::Private
 
48
{
 
49
public:
 
50
    Private()
 
51
    :categoryListNotSet(false)
 
52
    {}
 
53
    KBlog::Blog *kBlog;
 
54
    BilboBlog *bBlog;
 
55
//     quint16 mChecksum;
 
56
//     QString mediaLocalUrl;
 
57
    QList<Category> mCreatePostCategories;
 
58
    QMap<QString, KBlog::BlogPost *> mSetPostCategoriesMap;
 
59
    QMap<KBlog::BlogPost *, BilboPost::Status> mSubmitPostStatusMap;
 
60
    QMap<KBlog::BlogMedia *, BilboMedia *> mPublishMediaMap;
 
61
    bool categoryListNotSet;
 
62
};
 
63
 
 
64
Backend::Backend( int blog_id, QObject* parent )
 
65
: QObject( parent ), d(new Private)
46
66
{
47
67
    kDebug() << "with blog id: " << blog_id;
48
 
    mBBlog = new BilboBlog( DBMan::self()->blog( blog_id ) );
49
 
    switch ( mBBlog->api() ) {
50
 
        case BilboBlog::BLOGGER1_API:
51
 
            mKBlog = new KBlog::Blogger1( KUrl(), this );
52
 
            break;
53
 
        case BilboBlog::GDATA_API:
54
 
            mKBlog = new KBlog::GData( KUrl(), this );
55
 
            break;
56
 
        case BilboBlog::METAWEBLOG_API:
57
 
            mKBlog = new KBlog::MetaWeblog( KUrl(), this );
58
 
            break;
59
 
        case BilboBlog::MOVABLETYPE_API:
60
 
            mKBlog = new KBlog::MovableType( KUrl(), this );
61
 
            break;
62
 
        case BilboBlog::WORDPRESSBUGGY_API:
63
 
            mKBlog = new KBlog::WordpressBuggy( KUrl(), this );
64
 
    }
65
 
    mKBlog->setUserAgent(APPNAME, VERSION);
66
 
    mKBlog->setUsername( mBBlog->username() );
67
 
    mKBlog->setPassword( mBBlog->password() );
68
 
    mKBlog->setUrl( KUrl( mBBlog->url() ) );
69
 
    mKBlog->setBlogId( mBBlog->blogid() );
70
 
    categoryListNotSet = false;
 
68
    d->bBlog = DBMan::self()->blog( blog_id );
 
69
    d->kBlog = d->bBlog->blogBackend();
71
70
 
72
 
    connect( mKBlog, SIGNAL( error( KBlog::Blog::ErrorType, const QString& ) ),
73
 
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
74
 
    connect( mKBlog, SIGNAL( errorPost( KBlog::Blog::ErrorType, const QString &, KBlog::BlogPost* ) ),
75
 
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
76
 
    connect( mKBlog, SIGNAL( errorComment( KBlog::Blog::ErrorType, const QString &, KBlog::BlogPost*,
 
71
    connect( d->kBlog, SIGNAL( error( KBlog::Blog::ErrorType, const QString& ) ),
 
72
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
 
73
    connect( d->kBlog, SIGNAL( errorPost( KBlog::Blog::ErrorType, const QString &, KBlog::BlogPost* ) ),
 
74
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
 
75
    connect( d->kBlog, SIGNAL( errorComment( KBlog::Blog::ErrorType, const QString &, KBlog::BlogPost*,
77
76
                                           KBlog::BlogComment* ) ),
78
77
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
79
 
    connect( mKBlog, SIGNAL( errorMedia( KBlog::Blog::ErrorType, const QString &, KBlog::BlogMedia* ) ),
 
78
    connect( d->kBlog, SIGNAL( errorMedia( KBlog::Blog::ErrorType, const QString &, KBlog::BlogMedia* ) ),
80
79
             this, SLOT( error( KBlog::Blog::ErrorType, const QString& ) ) );
81
80
}
82
81
 
83
82
Backend::~Backend()
84
83
{
85
84
    kDebug();
86
 
    mBBlog->deleteLater();
 
85
    delete d;
87
86
}
88
87
 
89
88
void Backend::getCategoryListFromServer()
90
89
{
91
 
    kDebug() << "Blog Id: " << mBBlog->id();
92
 
    if ( mBBlog->api() == BilboBlog::METAWEBLOG_API || mBBlog->api() == BilboBlog::MOVABLETYPE_API ||
93
 
         mBBlog->api() == BilboBlog::WORDPRESSBUGGY_API ) {
94
 
        KBlog::MetaWeblog *tmp = dynamic_cast<KBlog::MetaWeblog*>( mKBlog );
 
90
    kDebug() << "Blog Id: " << d->bBlog->id();
 
91
    if ( d->bBlog->api() == BilboBlog::METAWEBLOG_API || d->bBlog->api() == BilboBlog::MOVABLETYPE_API ||
 
92
         d->bBlog->api() == BilboBlog::WORDPRESSBUGGY_API ) {
 
93
        KBlog::MetaWeblog *tmp = dynamic_cast<KBlog::MetaWeblog*>( d->kBlog );
95
94
        connect( tmp, SIGNAL( listedCategories( const QList< QMap< QString, QString > > & ) ),
96
95
                 this, SLOT( categoriesListed( const QList< QMap< QString, QString > > & ) ) );
97
96
        tmp->listCategories();
98
97
    } else {
99
98
        char err[] = "Blog API doesn't support getting Category list.";
100
99
        kDebug() << err;
101
 
        QString tmp = i18n( err );
102
 
        error( KBlog::Blog::NotSupported, tmp );
 
100
        error( KBlog::Blog::NotSupported, i18n( err ) );
103
101
    }
104
102
}
105
103
 
106
104
void Backend::categoriesListed( const QList< QMap < QString , QString > > & categories )
107
105
{
108
 
    kDebug() << "Blog Id: " << mBBlog->id();
109
 
    DBMan::self()->clearCategories( mBBlog->id() );
 
106
    kDebug() << "Blog Id: " << d->bBlog->id();
 
107
    DBMan::self()->clearCategories( d->bBlog->id() );
110
108
 
111
109
    for ( int i = 0; i < categories.count(); ++i ) {
112
110
        QString name, description, htmlUrl, rssUrl, categoryId, parentId;
123
121
            categoryId = QString::number(i);
124
122
        }
125
123
 
126
 
        DBMan::self()->addCategory( name, description, htmlUrl, rssUrl, categoryId, parentId, mBBlog->id() );
 
124
        DBMan::self()->addCategory( name, description, htmlUrl, rssUrl, categoryId, parentId, d->bBlog->id() );
127
125
    }
128
126
    kDebug() << "Emitting sigCategoryListFetched...";
129
 
    Q_EMIT sigCategoryListFetched( mBBlog->id() );
 
127
    Q_EMIT sigCategoryListFetched( d->bBlog->id() );
130
128
}
131
129
 
132
130
void Backend::getEntriesListFromServer( int count )
133
131
{
134
 
    kDebug() << "Blog Id: " << mBBlog->id();
135
 
    connect( mKBlog, SIGNAL( listedRecentPosts( const QList<KBlog::BlogPost> & ) ),
 
132
    kDebug() << "Blog Id: " << d->bBlog->id();
 
133
    connect( d->kBlog, SIGNAL( listedRecentPosts( const QList<KBlog::BlogPost> & ) ),
136
134
             this, SLOT( entriesListed( const QList<KBlog::BlogPost >& ) ) );
137
 
    mKBlog->listRecentPosts( count );
 
135
    d->kBlog->listRecentPosts( count );
138
136
}
139
137
 
140
138
void Backend::entriesListed( const QList< KBlog::BlogPost > & posts )
141
139
{
142
 
    kDebug() << "Blog Id: " << mBBlog->id();
143
 
//     DBMan::self()->clearPosts( mBBlog->id() );
 
140
    kDebug() << "Blog Id: " << d->bBlog->id();
 
141
//     DBMan::self()->clearPosts( d->bBlog->id() );
144
142
 
145
143
    for ( int i = 0; i < posts.count(); i++ ) {
146
144
        BilboPost tempPost( posts[i] );
148
146
            tempPost.setContent( tempPost.content().replace( '\n', "<br/>" ) );
149
147
            tempPost.setAdditionalContent( tempPost.additionalContent().replace( '\n', "<br/>" ) );
150
148
        }
151
 
        DBMan::self()->addPost( tempPost, mBBlog->id() );
 
149
        DBMan::self()->addPost( tempPost, d->bBlog->id() );
152
150
    }
153
151
    kDebug() << "Emitting sigEntriesListFetched ...";
154
 
    Q_EMIT sigEntriesListFetched( mBBlog->id() );
 
152
    Q_EMIT sigEntriesListFetched( d->bBlog->id() );
155
153
}
156
154
 
157
 
void Backend::publishPost( const BilboPost &post )
 
155
void Backend::publishPost( BilboPost* post )
158
156
{
159
 
    kDebug() << "Blog Id: " << mBBlog->id();
160
 
    BilboPost tmpPost = post;
 
157
    kDebug() << "Blog Id: " << d->bBlog->id();
 
158
//     BilboPost tmpPost = post;
161
159
    if( Settings::addPoweredBy() ) {
162
160
        QString poweredStr = "<p>=-=-=-=-=<br/>"
163
161
        "<i>Powered by <b><a href='http://blogilo.gnufolks.org/'>Blogilo</a></b></i></p>";
164
 
        tmpPost.setContent(post.content() + poweredStr);
 
162
        post->setContent(post->content() + poweredStr);
165
163
    }
166
 
    KBlog::BlogPost *bp = preparePost( tmpPost );
167
 
    connect( mKBlog, SIGNAL( createdPost( KBlog::BlogPost * ) ),
 
164
    preparePost( post );
 
165
    connect( d->kBlog, SIGNAL( createdPost( KBlog::BlogPost * ) ),
168
166
             this, SLOT( postPublished( KBlog::BlogPost * ) ) );
169
 
    mKBlog->createPost( bp );
 
167
    d->kBlog->createPost( post );
170
168
}
171
169
 
172
170
void Backend::postPublished( KBlog::BlogPost *post )
173
171
{
174
 
    kDebug() << "Blog Id: " << mBBlog->id();
 
172
    kDebug() << "Blog Id: " << d->bBlog->id();
175
173
    if ( post->status() == KBlog::BlogPost::Error ) {
176
174
        kDebug() << "Publishing/Modifying Failed";
177
175
        const QString tmp( i18n( "Publishing/Modifying post failed: %1", post->error() ) );
179
177
        Q_EMIT sigError( tmp );
180
178
        return;
181
179
    }
182
 
//     if ( categoryListNotSet ) {
183
 
//         categoryListNotSet = false;
184
 
//         mSetPostCategoriesMap[ post->postId()] = post;
185
 
//         QMap<QString, bool> cats;
186
 
//         int count = mCreatePostCategories.count();
187
 
//         for ( int i = 0; i < count; ++i ) {
188
 
//             cats.insert( mCreatePostCategories[i].categoryId, false );
189
 
//         }
190
 
//         setPostCategories( post->postId(), cats );
191
 
//     } else {
192
 
        kDebug()<<"isPrivate: "<<post->isPrivate();
193
 
        mSubmitPostStatusMap[ post ] = post->status();
194
 
        connect( mKBlog, SIGNAL( fetchedPost(KBlog::BlogPost*)),
195
 
                 this, SLOT( savePostInDbAndEmitResult(KBlog::BlogPost*)) );
196
 
        mKBlog->fetchPost( post );
197
 
//     }
 
180
    kDebug()<<"isPrivate: "<<post->isPrivate();
 
181
    if(post->isPrivate() && d->bBlog->api() == BilboBlog::GDATA_API){
 
182
        //GData do not support fetching drafts!
 
183
        savePostInDbAndEmitResult(post);
 
184
        return;
 
185
    }
 
186
    d->mSubmitPostStatusMap[ post ] = post->status();
 
187
    connect( d->kBlog, SIGNAL( fetchedPost(KBlog::BlogPost*)),
 
188
             this, SLOT( savePostInDbAndEmitResult(KBlog::BlogPost*)) );
 
189
    d->kBlog->fetchPost( post );
198
190
}
199
191
 
200
192
void Backend::uploadMedia( BilboMedia * media )
201
193
{
202
 
    kDebug() << "Blog Id: " << mBBlog->id();
 
194
    kDebug() << "Blog Id: " << d->bBlog->id();
203
195
    QString tmp;
204
 
    switch ( mBBlog->api() ) {
 
196
    switch ( d->bBlog->api() ) {
205
197
        case BilboBlog::BLOGGER1_API:
206
198
        case BilboBlog::GDATA_API:
207
199
            kDebug() << "The Blogger1 and GData API type doesn't support uploading Media files.";
214
206
        case BilboBlog::MOVABLETYPE_API:
215
207
        case BilboBlog::WORDPRESSBUGGY_API:
216
208
            KBlog::BlogMedia *m = new KBlog::BlogMedia() ;
217
 
            KBlog::MetaWeblog *MWBlog = qobject_cast<KBlog::MetaWeblog*>( mKBlog );
 
209
            KBlog::MetaWeblog *MWBlog = qobject_cast<KBlog::MetaWeblog*>( d->kBlog );
218
210
 
219
211
            m->setMimetype( media->mimeType() );
220
212
 
258
250
                Q_EMIT sigError( tmp );
259
251
                return;
260
252
            }
261
 
            mPublishMediaMap[ m ] = media;
 
253
            d->mPublishMediaMap[ m ] = media;
262
254
            connect( MWBlog, SIGNAL( createdMedia( KBlog::BlogMedia* ) ), this, SLOT( mediaUploaded( KBlog::BlogMedia* ) ) );
263
255
            connect( MWBlog, SIGNAL( errorMedia( KBlog::Blog::ErrorType, const QString &, KBlog::BlogMedia* ) ),
264
 
                     this, SLOT( sltMediaError( KBlog::Blog::ErrorType, const QString &, KBlog::BlogMedia* ) ) );
 
256
                     this, SLOT( slotMediaError( KBlog::Blog::ErrorType, const QString &, KBlog::BlogMedia* ) ) );
265
257
            MWBlog->createMedia( m );
266
258
            return;
267
259
            break;
273
265
 
274
266
void Backend::mediaUploaded( KBlog::BlogMedia * media )
275
267
{
276
 
    kDebug() << "Blog Id: " << mBBlog->id() << "Media: "<<media->url();
 
268
    kDebug() << "Blog Id: " << d->bBlog->id() << "Media: "<<media->url();
277
269
    if(!media){
278
270
        kError()<<"ERROR! Media returned from KBlog is NULL!";
279
271
        return;
280
272
    }
281
 
    BilboMedia * m = mPublishMediaMap.value( media );
 
273
    BilboMedia * m = d->mPublishMediaMap.value( media );
282
274
    if(!m){
283
275
        kError()<<"ERROR! Media returned from KBlog doesn't exist on the Map! Url is:"
284
276
                << media->url();
285
277
        return;
286
278
    }
287
 
    mPublishMediaMap.remove( media );
 
279
    d->mPublishMediaMap.remove( media );
288
280
    if ( media->status() == KBlog::BlogMedia::Error ) {
289
281
        kError() << "Upload error! with this message: " << media->error();
290
282
        const QString tmp( i18n( "Uploading media failed: %1", media->error() ) );
308
300
    Q_EMIT sigMediaUploaded( m );
309
301
}
310
302
 
311
 
void Backend::modifyPost( const BilboPost &post )
 
303
void Backend::modifyPost( BilboPost* post )
312
304
{
313
 
    kDebug() << "Blog Id: " << mBBlog->id();
314
 
    BilboPost tmpPost = post;
315
 
    KBlog::BlogPost *bp = preparePost( tmpPost );
316
 
    connect( mKBlog, SIGNAL( modifiedPost(KBlog::BlogPost*)),
 
305
    kDebug() << "Blog Id: " << d->bBlog->id();
 
306
//     BilboPost tmpPost = post;
 
307
    preparePost( post );
 
308
    connect( d->kBlog, SIGNAL( modifiedPost(KBlog::BlogPost*)),
317
309
             this, SLOT( postPublished(KBlog::BlogPost*)) );
318
 
    mKBlog->modifyPost( bp );
 
310
    d->kBlog->modifyPost( post );
319
311
}
320
312
 
321
 
void Backend::removePost( BilboPost &post )
 
313
void Backend::removePost( BilboPost* post )
322
314
{
323
 
    kDebug() << "Blog Id: " << mBBlog->id();
 
315
    kDebug() << "Blog Id: " << d->bBlog->id();
324
316
 
325
 
    KBlog::BlogPost *bp = post.toKBlogPost();
326
 
    connect( mKBlog, SIGNAL( removedPost(KBlog::BlogPost*)),
 
317
//     KBlog::BlogPost *bp = post.toKBlogPost();
 
318
    connect( d->kBlog, SIGNAL( removedPost(KBlog::BlogPost*)),
327
319
             this, SLOT( slotPostRemoved(KBlog::BlogPost*)) );
328
 
    mKBlog->removePost( bp );
 
320
    d->kBlog->removePost( post );
329
321
}
330
322
 
331
323
void Backend::slotPostRemoved( KBlog::BlogPost *post )
334
326
        kDebug()<<"post returned from server is NULL";
335
327
        return;
336
328
    }
337
 
    if( !DBMan::self()->removePost(mBBlog->id(), post->postId()) ) {
 
329
    if( !DBMan::self()->removePost(d->bBlog->id(), post->postId()) ) {
338
330
        kDebug()<<"cannot remove post from database, error: "<<DBMan::self()->lastErrorText();
339
331
    }
340
 
    emit sigPostRemoved(mBBlog->id(), BilboPost(*post));
 
332
    emit sigPostRemoved(d->bBlog->id(), BilboPost(*post));
341
333
}
342
334
 
343
 
void Backend::fetchPost( BilboPost &post )
 
335
void Backend::fetchPost( BilboPost* post )
344
336
{
345
 
    KBlog::BlogPost *bp = post.toKBlogPost();
346
 
    connect( mKBlog, SIGNAL( fetchedPost(KBlog::BlogPost*)),
 
337
//     KBlog::BlogPost *bp = post.toKBlogPost();
 
338
    connect( d->kBlog, SIGNAL( fetchedPost(KBlog::BlogPost*)),
347
339
             this, SLOT( slotPostFetched(KBlog::BlogPost*)) );
348
 
    mKBlog->fetchPost( bp );
 
340
    d->kBlog->fetchPost( post );
349
341
}
350
342
 
351
343
void Backend::slotPostFetched( KBlog::BlogPost *post )
352
344
{
353
345
    emit sigPostFetched( new BilboPost(*post) );
354
 
    delete post;
 
346
//     delete post;
355
347
}
356
348
 
357
349
void Backend::error( KBlog::Blog::ErrorType type, const QString & errorMessage )
358
350
{
359
 
    kDebug() << "Blog Id: " << mBBlog->id();
 
351
    kDebug() << "Blog Id: " << d->bBlog->id();
360
352
    QString errType = errorTypeToString( type );
361
353
    errType += errorMessage;
362
354
    kDebug() << errType;
364
356
    Q_EMIT sigError( errType );
365
357
}
366
358
 
367
 
void Backend::sltMediaError( KBlog::Blog::ErrorType type, const QString & errorMessage, KBlog::BlogMedia * media )
 
359
void Backend::slotMediaError( KBlog::Blog::ErrorType type, const QString & errorMessage,
 
360
                              KBlog::BlogMedia * media )
368
361
{
369
362
    kDebug();
370
363
    QString errType = errorTypeToString( type );
371
364
    errType += errorMessage;
372
365
    kDebug() << errType;
373
366
    kDebug() << "Emitting sigMediaError ...";
374
 
    emit sigMediaError( errorMessage, mPublishMediaMap[ media ] );
375
 
    mPublishMediaMap.remove( media );
 
367
    emit sigMediaError( errorMessage, d->mPublishMediaMap[ media ] );
 
368
    d->mPublishMediaMap.remove( media );
376
369
}
377
370
 
378
371
QString Backend::errorTypeToString( KBlog::Blog::ErrorType type )
410
403
    kDebug()<<"isPrivate: "<<post->isPrivate();
411
404
    BilboPost *pp = new BilboPost( *post );
412
405
    int post_id;
413
 
    if( mSubmitPostStatusMap[ post ] == KBlog::BlogPost::Modified) {
414
 
        post_id = DBMan::self()->editPost( *pp, mBBlog->id() );
 
406
    if( d->mSubmitPostStatusMap[ post ] == KBlog::BlogPost::Modified) {
 
407
        post_id = DBMan::self()->editPost( *pp, d->bBlog->id() );
415
408
    } else {
416
 
        post_id = DBMan::self()->addPost( *pp, mBBlog->id() );
 
409
        post_id = DBMan::self()->addPost( *pp, d->bBlog->id() );
417
410
    }
418
 
    mSubmitPostStatusMap.remove(post);
 
411
    d->mSubmitPostStatusMap.remove(post);
419
412
    if ( post_id != -1 ) {
420
413
        pp->setPrivate( post->isPrivate() );
421
414
        pp->setId( post_id );
422
415
        kDebug() << "Emitting sigPostPublished ...";
423
 
        Q_EMIT sigPostPublished( mBBlog->id(), pp );
 
416
        Q_EMIT sigPostPublished( d->bBlog->id(), pp );
424
417
    }
425
418
    // TODO crashes stylegetter on GData. Somehow the post gets deleted before
426
419
    // slotFetchedPost as it seems. Don't get all the pointer copies done here.
427
420
    //delete post;
428
421
}
429
422
 
430
 
KBlog::BlogPost * Backend::preparePost( BilboPost &post )
 
423
KBlog::BlogPost* Backend::preparePost( KBlog::BlogPost* post )
431
424
{
432
 
    QString content = post.content();
 
425
    QString content = post->content();
433
426
    QString html1 = QString();
434
427
    int i = 0;
435
428
    int found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
436
429
    while ( found != -1 )
437
430
    {
438
 
        html1 += content.mid( i, found-i).remove('\n');
439
 
        i = found;
440
 
        found = content.indexOf("</pre>", i, Qt::CaseInsensitive);
441
 
        if ( found != -1 ) {
442
 
            html1 += content.mid( i, found+5-i);
443
 
            i = found + 5;
444
 
            found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
445
 
        } else {
446
 
            html1 += content.mid( i, content.length()-i );
447
 
            i = -1;
448
 
        }
 
431
    html1 += content.mid( i, found-i).remove('\n');
 
432
    i = found;
 
433
    found = content.indexOf("</pre>", i, Qt::CaseInsensitive);
 
434
    if ( found != -1 ) {
 
435
        html1 += content.mid( i, found+5-i);
 
436
        i = found + 5;
 
437
        found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
 
438
    } else {
 
439
        html1 += content.mid( i, content.length()-i );
 
440
        i = -1;
 
441
    }
449
442
    }
450
443
    if ( i != -1 )
451
 
        html1 += content.mid( i, content.length()-i).remove('\n');
452
 
    post.setContent( html1 );
453
 
    
454
 
    content = post.additionalContent();
 
444
    html1 += content.mid( i, content.length()-i).remove('\n');
 
445
    post->setContent( html1 );
 
446
 
 
447
    content = post->additionalContent();
455
448
    QString html2 = QString();
456
449
    i= 0;
457
450
    found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
458
451
    while ( found != -1 )
459
452
    {
460
 
        html2 += content.mid( i, found-i).remove('\n');
461
 
        i = found;
462
 
        found = content.indexOf("</pre>", i, Qt::CaseInsensitive);
463
 
        if ( found != -1 ) {
464
 
            html2 += content.mid( i, found+5-i);
465
 
            i = found + 5;
466
 
            found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
467
 
        } else {
468
 
            html2 += content.mid( i, content.length()-i );
469
 
            i = -1;
470
 
        }
 
453
    html2 += content.mid( i, found-i).remove('\n');
 
454
    i = found;
 
455
    found = content.indexOf("</pre>", i, Qt::CaseInsensitive);
 
456
    if ( found != -1 ) {
 
457
        html2 += content.mid( i, found+5-i);
 
458
        i = found + 5;
 
459
        found = content.indexOf("<pre>", i, Qt::CaseInsensitive);
 
460
    } else {
 
461
        html2 += content.mid( i, content.length()-i );
 
462
        i = -1;
 
463
    }
471
464
    }
472
465
    if ( i != -1 )
473
 
        html2 += content.mid( i, content.length()-i).remove('\n');
474
 
    post.setAdditionalContent( html2 );
 
466
    html2 += content.mid( i, content.length()-i).remove('\n');
 
467
    post->setAdditionalContent( html2 );
475
468
 
476
469
    //the following two lines are replaced by the above code, because '\n' characters shouldn't
477
 
    //be ommited inside <pre> blocks.
 
470
    //be omitted inside <pre> blocks.
478
471
 
479
472
    //post.setContent( post.content().remove('\n') );
480
473
    //post.setAdditionalContent( post.additionalContent().remove( '\n' ) );
481
 
    if ( mBBlog->api() == BilboBlog::MOVABLETYPE_API || mBBlog->api() == BilboBlog::WORDPRESSBUGGY_API ) {
482
 
        QStringList content = post.content().split("<!--split-->");
 
474
    if ( d->bBlog->api() == BilboBlog::MOVABLETYPE_API || d->bBlog->api() == BilboBlog::WORDPRESSBUGGY_API ) {
 
475
        QStringList content = post->content().split(splitRX);
483
476
        if( content.count() == 2 ) {
484
 
            post.setContent(content[0]);
485
 
            post.setAdditionalContent( content[1] );
 
477
            post->setContent(content[0]);
 
478
            post->setAdditionalContent( content[1] );
486
479
        }
487
480
    }
488
 
//     if( mBBlog->api() == BilboBlog::MOVABLETYPE_API && post.categoryList().count() > 0 ) {
 
481
//     if( d->bBlog->api() == BilboBlog::MOVABLETYPE_API && post.categoryList().count() > 0 ) {
489
482
//         mCreatePostCategories = post.categoryList();
490
483
//         categoryListNotSet = true;
491
484
//     }
492
 
    return post.toKBlogPost();
 
485
    return post;//.toKBlogPost();
493
486
}
494
487
 
495
488
#include "backend.moc"