diff --git a/microblogs/pumpio/pumpiomicroblog.cpp b/microblogs/pumpio/pumpiomicroblog.cpp
index 69f170c4..14c28692 100644
--- a/microblogs/pumpio/pumpiomicroblog.cpp
+++ b/microblogs/pumpio/pumpiomicroblog.cpp
@@ -1,336 +1,415 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013  Andrea Scarpino <scarpino@kde.org>
 
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of
     the License or (at your option) version 3 or any later version
     accepted by the membership of KDE e.V. (or its successor approved
     by the membership of KDE e.V.), which shall act as a proxy
     defined in Section 14 of version 3 of the license.
 
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, see http://www.gnu.org/licenses/
 */
 
 #include "pumpiomicroblog.h"
 
 #include <QTextDocument>
 
 #include <qjson/parser.h>
+#include <qjson/serializer.h>
 
 #include <KGenericFactory>
 #include <KIO/Job>
 #include <KIO/StoredTransferJob>
 
 #include "accountmanager.h"
 #include "application.h"
+#include "choqokbehaviorsettings.h"
+#include "notifymanager.h"
 
 #include "pumpioaccount.h"
 #include "pumpioeditaccountwidget.h"
 #include "pumpiopostwidget.h"
 
 K_PLUGIN_FACTORY( MyPluginFactory, registerPlugin < PumpIOMicroBlog > (); )
 K_EXPORT_PLUGIN( MyPluginFactory( "choqok_pumpio" ) )
 
 PumpIOMicroBlog::PumpIOMicroBlog(QObject* parent, const QVariantList& args):
     MicroBlog(MyPluginFactory::componentData(), parent)
 {
     Q_UNUSED(args)
     setServiceName("Pump.io");
     setServiceHomepageUrl("http://pump.io");
     QStringList timelineNames;
     timelineNames << "Activity";
     setTimelineNames(timelineNames);
     setTimelinesInfo();
 }
 
 PumpIOMicroBlog::~PumpIOMicroBlog()
 {
 }
 
 void PumpIOMicroBlog::abortAllJobs(Choqok::Account* theAccount)
 {
     Q_FOREACH (KJob *job, m_accountJobs.keys(theAccount)) {
         job->kill(KJob::EmitResult);
     }
 }
 
 void PumpIOMicroBlog::abortCreatePost(Choqok::Account* theAccount, Choqok::Post* post)
 {
-    //TODO
-    Choqok::MicroBlog::abortCreatePost(theAccount, post);
+    if (m_createPostJobs.isEmpty()) {
+        return;
+    }
+    if (post) {
+        m_createPostJobs.key(post)->kill(KJob::EmitResult);
+        return;
+    }
+
+    Q_FOREACH (KJob *job, m_createPostJobs.keys()){
+        if( m_accountJobs[job] == theAccount) {
+            job->kill(KJob::EmitResult);
+        }
+    }
 }
 
 void PumpIOMicroBlog::aboutToUnload()
 {
     emit saveTimelines();
 }
 
 ChoqokEditAccountWidget* PumpIOMicroBlog::createEditAccountWidget(Choqok::Account* account, QWidget* parent)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount* >(account);
     if (acc || !account) {
         return new PumpIOEditAccountWidget(this, acc, parent);
     } else {
         kDebug() << "Account passed here was not a valid PumpIOAccount!";
         return 0;
     }
 }
 
 Choqok::Account* PumpIOMicroBlog::createNewAccount(const QString& alias)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>( Choqok::AccountManager::self()->findAccount(alias) );
     if (!acc) {
         return new PumpIOAccount(this, alias);
     } else {
         kDebug() << "Cannot create a new PumpIOAccount!";
         return 0;
     }
 }
 
 void PumpIOMicroBlog::createPost(Choqok::Account* theAccount, Choqok::Post* post)
 {
-    //TODO
-    Choqok::MicroBlog::createPost(theAccount, post);
+    PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
+    if (acc) {
+        QVariantMap object;
+        object.insert("objectType", "note");
+        object.insert("content", QUrl::toPercentEncoding(post->content));
+
+        QVariantList to;
+        QVariantMap thePublic;
+        thePublic.insert("objectType", "collection");
+        thePublic.insert("id", "http://activityschema.org/collection/public");
+        to.prepend(thePublic);
+
+        QVariantMap item;
+        item.insert("verb", "post");
+        item.insert("object", object);
+        item.insert("to", to);
+
+        QJson::Serializer serializer;
+        const QByteArray data = serializer.serialize(item);
+
+        KUrl url(acc->host());
+        url.addPath("/api/user/" + acc->username() + "/feed");
+        const QByteArray authorization = acc->oAuth()->createParametersString(url.url(), QOAuth::POST, acc->token().toLocal8Bit(),
+                                                                        acc->tokenSecret().toLocal8Bit(), QOAuth::HMAC_SHA1,
+                                                                        QOAuth::ParamMap(), QOAuth::ParseForHeaderArguments);
+        KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
+        job->addMetaData("content-type", "Content-Type: application/json");
+        job->addMetaData("customHTTPHeader", "Authorization: " + authorization);
+        if (!job) {
+            kDebug() << "Cannot create an http POST request!";
+            return;
+        }
+        m_accountJobs[job] = acc;
+        m_createPostJobs[job] = post;
+        connect(job, SIGNAL(result(KJob*)), this, SLOT(slotCreatePost(KJob*)));
+        job->start();
+    } else {
+        kDebug() << "Cannot create a note!";
+    }
 }
 
 Choqok::UI::PostWidget* PumpIOMicroBlog::createPostWidget(Choqok::Account* account, Choqok::Post* post, QWidget* parent)
 {
     return new PumpIOPostWidget(account, post, parent);
 }
 
 void PumpIOMicroBlog::fetchPost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     //TODO
     Choqok::MicroBlog::fetchPost(theAccount, post);
 }
 
 void PumpIOMicroBlog::removePost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     //TODO
     Choqok::MicroBlog::removePost(theAccount, post);
 }
 
 QList< Choqok::Post* > PumpIOMicroBlog::loadTimeline(Choqok::Account* account, const QString& timelineName)
 {
     QList< Choqok::Post* > list;
     const QString fileName = Choqok::AccountManager::generatePostBackupFileName(account->alias(), timelineName);
     const KConfig postsBackup( "choqok/" + fileName, KConfig::NoGlobals, "data" );
     const QStringList tmpList = postsBackup.groupList();
 
     // don't load old archives
     if (tmpList.isEmpty() || !(QDateTime::fromString(tmpList.first()).isValid())) {
         return list;
     }
 
     QList<QDateTime> groupList;
     Q_FOREACH (const QString& str, tmpList) {
         groupList.append(QDateTime::fromString(str));
     }
     qSort(groupList);
     Choqok::Post *st;
     Q_FOREACH (const QDateTime& datetime, groupList) {
         st = new Choqok::Post;
         KConfigGroup grp( &postsBackup, datetime.toString() );
         st->creationDateTime = grp.readEntry( "creationDateTime", QDateTime::currentDateTime() );
         st->postId = grp.readEntry( "postId", QString() );
         st->link = grp.readEntry( "link", QString() );
         st->content = grp.readEntry( "content", QString() );
         st->source = grp.readEntry( "source", QString() );
         st->isFavorited = grp.readEntry( "favorited", false );
         st->author.userId = grp.readEntry( "authorId", QString() );
         st->author.userName = grp.readEntry( "authorUserName", QString() );
         st->author.realName = grp.readEntry( "authorRealName", QString() );
         st->author.location = grp.readEntry("authorLocation", QString());
         st->author.description = grp.readEntry( "authorDescription" , QString() );
         st->author.profileImageUrl = grp.readEntry( "authorProfileImageUrl", QString() );
         st->author.homePageUrl = grp.readEntry("authorHomePageUrl", QString());
         st->type = grp.readEntry("type", QString());
         st->isRead = grp.readEntry("isRead", true);
         st->conversationId = grp.readEntry("conversationId", QString());
         list.append( st );
     }
 
     setLastTimelineId(account, timelineName, st->postId);
 
     return list;
 }
 
 QString PumpIOMicroBlog::postUrl(Choqok::Account* account, const QString& username, const QString& postId) const
 {
     //TODO
     return Choqok::MicroBlog::postUrl(account, username, postId);
 }
 
 QString PumpIOMicroBlog::profileUrl(Choqok::Account* account, const QString& username) const
 {
     Q_UNUSED(account)
     return username;
 }
 
 void PumpIOMicroBlog::saveTimeline(Choqok::Account* account, const QString& timelineName,
                                    const QList< Choqok::UI::PostWidget* >& timeline)
 {
     const QString fileName = Choqok::AccountManager::generatePostBackupFileName(account->alias(), timelineName);
     KConfig postsBackup("choqok/" + fileName, KConfig::NoGlobals, "data");
 
     ///Clear previous data:
     Q_FOREACH (const QString& group, postsBackup.groupList()) {
         postsBackup.deleteGroup(group);
     }
 
     QList< Choqok::UI::PostWidget *>::const_iterator it, endIt = timeline.constEnd();
     for ( it = timeline.constBegin(); it != endIt; ++it ) {
         const Choqok::Post *post = ((*it)->currentPost());
         KConfigGroup grp( &postsBackup, post->creationDateTime.toString() );
         grp.writeEntry( "creationDateTime", post->creationDateTime );
         grp.writeEntry( "postId", post->postId.toString() );
         grp.writeEntry( "link", post->link );
         grp.writeEntry( "content", post->content );
         grp.writeEntry( "source", post->source );
         grp.writeEntry( "favorited", post->isFavorited );
         grp.writeEntry( "authorId", post->author.userId.toString() );
         grp.writeEntry( "authorRealName", post->author.realName );
         grp.writeEntry( "authorUserName", post->author.userName );
         grp.writeEntry( "authorLocation" , post->author.location );
         grp.writeEntry( "authorDescription" , post->author.description );
         grp.writeEntry( "authorProfileImageUrl", post->author.profileImageUrl );
         grp.writeEntry( "authorHomePageUrl" , post->author.homePageUrl );
         grp.writeEntry( "type" , post->type );
         grp.writeEntry( "isRead" , post->isRead );
         grp.writeEntry( "conversationId", post->conversationId.toString() );
     }
     postsBackup.sync();
 
     emit readyForUnload();
 }
 
 Choqok::TimelineInfo* PumpIOMicroBlog::timelineInfo(const QString& timelineName)
 {
     return m_timelinesInfos.value(timelineName);
 }
 
 void PumpIOMicroBlog::updateTimelines(Choqok::Account* theAccount)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         Q_FOREACH (const QString timeline, acc->timelineNames()) {
             KUrl url(acc->host());
             url.addPath(m_timelinesPaths[timeline].arg(acc->username()));
             KIO::StoredTransferJob *job = KIO::storedGet(url, KIO::Reload, KIO::HideProgressInfo);
             if (!job) {
                 kDebug() << "Cannot create an http GET request!";
                 continue;
             }
+
             QOAuth::ParamMap oAuthParams;
-            oAuthParams.insert("count", "20");
-            oAuthParams.insert("since", lastTimelineId(theAccount, timeline).toLocal8Bit());
+            const ChoqokId lastActivityId = lastTimelineId(theAccount, timeline);
+            if (!lastActivityId.isNull()) {
+                oAuthParams.insert("count", QByteArray::number(200));
+                oAuthParams.insert("since", lastActivityId.toLocal8Bit());
+            } else {
+                oAuthParams.insert("count", QByteArray::number(Choqok::BehaviorSettings::countOfPosts()));
+            }
             QByteArray authorization = acc->oAuth()->createParametersString(url.url(), QOAuth::GET, acc->token().toLocal8Bit(),
                                                                     acc->tokenSecret().toLocal8Bit(), QOAuth::HMAC_SHA1,
                                                                     oAuthParams, QOAuth::ParseForHeaderArguments);
             job->addMetaData("customHTTPHeader", "Authorization: " + authorization);
             m_timelinesRequests[job] = timeline;
             m_accountJobs[job] = acc;
             connect(job, SIGNAL(result(KJob*)), this, SLOT(slotUpdateTimeline(KJob*)));
             job->start();
         }
     } else {
         kDebug() << "Error updating timelines";
     }
 }
 
+void PumpIOMicroBlog::slotCreatePost(KJob* job)
+{
+    if (!job) {
+        kDebug() << "Job is null pointer";
+        return;
+    }
+    Choqok::Post *post = m_createPostJobs.take(job);
+    Choqok::Account *theAccount = m_accountJobs.take(job);
+    if(!post || !theAccount) {
+        kDebug() << "Account or Post is NULL pointer";
+        return;
+    }
+    if (job->error()) {
+        kDebug() << "Job Error: " << job->errorString();
+        emit errorPost(theAccount, post, Choqok::MicroBlog::CommunicationError,
+                       i18n("Creating the new post failed. %1", job->errorString()), MicroBlog::Critical);
+    } else {
+        Choqok::NotifyManager::success(i18n("New post submitted successfully"));
+        emit postCreated(theAccount, post);
+    }
+}
+
 void PumpIOMicroBlog::slotUpdateTimeline(KJob* job)
 {
     Choqok::Account *account = m_accountJobs.take(job);
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
         emit error(account, Choqok::MicroBlog::CommunicationError, i18n("An error occurred when fetching the timeline"));
         return;
     }
     KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
     QList<Choqok::Post* > list = readTimeline(account, j->data());
 
     emit timelineDataReceived(account, m_timelinesRequests.take(job), list);
 }
 
 Choqok::Post* PumpIOMicroBlog::readPost(Choqok::Account* theAccount, const QVariantMap& var,
                                         Choqok::Post* post)
 {
     Q_UNUSED(theAccount)
     const QVariantMap object = var["object"].toMap();
     QTextDocument content;
     content.setHtml(object["content"].toString());
     if (object["displayName"].toString().isEmpty()) {
         post->content = content.toPlainText();
     } else {
         post->content = object["displayName"].toString() + '\n' + content.toPlainText();
     }
     if (!object["fullImage"].toMap().isEmpty()) {
         const QString imagePath = object["fullImage"].toMap().take("url").toString();
         if (!imagePath.isEmpty()) {
             post->content += '\n' + imagePath;
         }
     }
     post->creationDateTime = QDateTime::fromString(var["published"].toString(),
                                                    "yyyy-MM-dd'T'hh:mm:ss'Z'");
     post->link = object["url"].toString();
     post->type = object["objectType"].toString();
     const QVariantMap actor = var["actor"].toMap();
     post->author.userId = actor["id"].toString();
     post->author.userName = actor["preferredUsername"].toString();
     post->author.realName = actor["displayName"].toString();
     post->author.homePageUrl = actor["url"].toString();
     post->author.location = actor["location"].toMap().take("displayName").toString();
     post->author.description = actor["summary"].toString();
     post->author.profileImageUrl = actor["image"].toMap().take("url").toString();
     post->source = var["generator"].toMap().take("displayName").toString();
     post->postId = var["id"].toString();
 
     return post;
 }
 
 QList< Choqok::Post* > PumpIOMicroBlog::readTimeline(Choqok::Account* theAccount,
                                                      const QByteArray& buffer)
 {
     QList<Choqok::Post* > posts;
     QJson::Parser parser;
     const QVariantList list = parser.parse(buffer).toMap().take("items").toList();
     Q_FOREACH (const QVariant element, list) {
         if (!element.toMap().take("object").toMap().take("deleted").toString().isEmpty()) {
             // Skip deleted posts
             continue;
         }
         posts.prepend(readPost(theAccount, element.toMap(), new Choqok::Post));
     }
 
     return posts;
 }
 
 ChoqokId PumpIOMicroBlog::lastTimelineId(Choqok::Account* theAccount, const QString& timeline) const
 {
     return m_timelinesLatestIds[theAccount][timeline];
 }
 
 void PumpIOMicroBlog::setLastTimelineId(Choqok::Account* theAccount, const QString& timeline, const ChoqokId& id)
 {
     m_timelinesLatestIds[theAccount][timeline] = id;
 }
 
 void PumpIOMicroBlog::setTimelinesInfo()
 {
     Choqok::TimelineInfo *t = new Choqok::TimelineInfo;
     t->name = i18nc("Timeline Name", "Activity");
     t->description = i18nc("Timeline description", "You and your friends");
     t->icon = "user-home";
     m_timelinesInfos["Activity"] = t;
     m_timelinesPaths["Activity"] = "/api/user/%1/inbox/major";
 }
diff --git a/microblogs/pumpio/pumpiomicroblog.h b/microblogs/pumpio/pumpiomicroblog.h
index e4409fc5..8f2abe5f 100644
--- a/microblogs/pumpio/pumpiomicroblog.h
+++ b/microblogs/pumpio/pumpiomicroblog.h
@@ -1,72 +1,74 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013 Andrea Scarpino <scarpino@kde.org>
 
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of
     the License or (at your option) version 3 or any later version
     accepted by the membership of KDE e.V. (or its successor approved
     by the membership of KDE e.V.), which shall act as a proxy
     defined in Section 14 of version 3 of the license.
 
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, see http://www.gnu.org/licenses/
 */
 
 #ifndef PUMPIOMICROBLOG_H
 #define PUMPIOMICROBLOG_H
 
 #include "microblog.h"
 
 class KJob;
 
 class PumpIOMicroBlog : public Choqok::MicroBlog
 {
     Q_OBJECT
 public:
     explicit PumpIOMicroBlog(QObject* parent, const QVariantList& args);
     virtual ~PumpIOMicroBlog();
 
     virtual void abortAllJobs(Choqok::Account* theAccount);
     virtual void abortCreatePost(Choqok::Account* theAccount, Choqok::Post* post = 0);
     virtual void aboutToUnload();
     virtual ChoqokEditAccountWidget* createEditAccountWidget(Choqok::Account* account, QWidget* parent);
     virtual Choqok::Account* createNewAccount(const QString& alias);
     virtual void createPost(Choqok::Account* theAccount, Choqok::Post* post);
     virtual Choqok::UI::PostWidget* createPostWidget(Choqok::Account* account, Choqok::Post* post, QWidget* parent);
     virtual void fetchPost(Choqok::Account* theAccount, Choqok::Post* post);
     virtual QList<Choqok::Post* > loadTimeline(Choqok::Account* account, const QString& timelineName);
     virtual void removePost(Choqok::Account* theAccount, Choqok::Post* post);
     virtual QString postUrl(Choqok::Account* account, const QString& username, const QString& postId) const;
     virtual QString profileUrl(Choqok::Account* account, const QString& username) const;
     virtual void saveTimeline(Choqok::Account* account, const QString& timelineName, const QList< Choqok::UI::PostWidget* >& timeline);
     virtual Choqok::TimelineInfo* timelineInfo(const QString& timelineName);
     virtual void updateTimelines(Choqok::Account* theAccount);
 
 private Q_SLOTS:
+    void slotCreatePost(KJob* job);
     void slotUpdateTimeline(KJob* job);
 
 private:
     Choqok::Post* readPost(Choqok::Account* theAccount, const QVariantMap& var, Choqok::Post* post);
     QList<Choqok::Post* > readTimeline(Choqok::Account* theAccount, const QByteArray& buffer);
     ChoqokId lastTimelineId(Choqok::Account* theAccount, const QString& timeline) const;
     void setLastTimelineId(Choqok::Account* theAccount, const QString& timeline, const ChoqokId& id);
     void setTimelinesInfo();
 
     QMap<KJob*, Choqok::Account* > m_accountJobs;
+    QMap<KJob*, Choqok::Post* > m_createPostJobs;
     QMap<QString, Choqok::TimelineInfo* > m_timelinesInfos;
     QHash<Choqok::Account*, QMap<QString, ChoqokId> > m_timelinesLatestIds;
     QHash<QString, QString> m_timelinesPaths;
     QMap<KJob*, QString> m_timelinesRequests;
 
 };
 
 #endif // PUMPIOMICROBLOG_H
\ No newline at end of file