diff --git a/src/ddpclient.cpp b/src/ddpclient.cpp
index b9cb508f..dfdd5ee4 100644
--- a/src/ddpclient.cpp
+++ b/src/ddpclient.cpp
@@ -1,327 +1,323 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@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 "ddpclient.h"
 
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
 #include <QtCore/QJsonArray>
 
 #include <iostream>
 #include <QLabel>
 #include "ruqola.h"
 
 void process_test(QJsonDocument doc)
 {
     qDebug() << "Callback test:" << doc;
     qDebug() << "End callback";
 }
 
 void login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     Ruqola::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 void DDPClient::resume_login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     Ruqola::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 
 void empty_callback(QJsonDocument doc)
 {
     Q_UNUSED(doc);
 }
 
 DDPClient::DDPClient(const QString& url, QObject* parent)
  : QObject(parent),
   m_url(url),
   m_uid(1),
   m_loginJob(0),
   m_loginStatus(NotConnected),
   m_connected(false),
   m_attemptedPasswordLogin(false),
   m_attemptedTokenLogin(false)
 {
     m_webSocket.ignoreSslErrors();
     connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
     connect(&m_webSocket, &QWebSocket::textMessageReceived, this, &DDPClient::onTextMessageReceived);
     connect(&m_webSocket, &QWebSocket::disconnected, this, &DDPClient::WSclosed);
     connect(Ruqola::self(), &Ruqola::serverURLChanged, this, &DDPClient::onServerURLChange);    
     
     if (!url.isEmpty()) {
         m_webSocket.open(QUrl("wss://"+url+"/websocket"));
     }
     qDebug() << "Trying to connect to URL" << url;
     
 }
 
 DDPClient::~DDPClient()
 {
     m_webSocket.close();
 }
 
 void DDPClient::onServerURLChange()
 {
     if (Ruqola::self()->serverURL() != m_url || !m_webSocket.isValid()) {
         if (m_webSocket.isValid()) {
             m_webSocket.flush();
             m_webSocket.close();
         }
         m_url = Ruqola::self()->serverURL();
         m_webSocket.open(QUrl("wss://"+m_url+"/websocket"));
         connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
         qDebug() << "Reconnecting" << m_url; //<< m_webSocket.st;
     }
 }
 
 DDPClient::LoginStatus DDPClient::loginStatus() const
 {
     return m_loginStatus;
 }
 
 bool DDPClient::isConnected() const
 {
     return m_connected;
 }
 
 bool DDPClient::isLoggedIn() const
 {
     return m_loginStatus == LoggedIn;
 }
 
 unsigned int DDPClient::method(const QString& m, const QJsonDocument& params)
 {
     return method(m, params, empty_callback);
 }
 
 unsigned int DDPClient::method(const QString& method, const QJsonDocument& params, std::function<void (QJsonDocument)> callback)
 {
     QJsonObject json;
     json["msg"] = "method";
     json["method"] = method;
     json["id"] = QString::number(m_uid);
 
     if (params.isArray()){
         json["params"] = params.array();
     } else if (params.isObject()) {
         QJsonArray arr;
         arr.append(params.object());
         json["params"] = arr;
 //         params.object();
     }
         
     qint64 bytes = m_webSocket.sendTextMessage(QJsonDocument(json).toJson(QJsonDocument::Compact));
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
         qDebug() << m_webSocket.isValid() << m_webSocket.error() << m_webSocket.requestUrl();
     } else {
         qDebug() << "Successfully sent " << json;
     }
 
     //callback(QJsonDocument::fromJson(json.toUtf8()));
     m_callbackHash[m_uid] = callback;
 
     m_uid++;
     return m_uid - 1 ;
 }
 
 void DDPClient::subscribe(const QString& collection, const QJsonArray& params)
 {
     QJsonObject json;
     json["msg"] = "sub";
     json["id"] = QString::number(m_uid);
     json["name"] = collection;
     json["params"] = params;
     
     qint64 bytes = m_webSocket.sendTextMessage(QJsonDocument(json).toJson(QJsonDocument::Compact));
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     }
     
     m_uid++;
 }
 
 void DDPClient::onTextMessageReceived(QString message)
 {
     QJsonDocument response = QJsonDocument::fromJson(message.toUtf8());
-    qDebug() << "Response- " << response;
-
-    qDebug() << "----------------------";
-    qDebug() << "----------------------";
-    qDebug() << "----------------------";
-    qDebug() << "----------------------";
     if (!response.isNull() && response.isObject()) {
 
         QJsonObject root = response.object();
         QString messageType = root.value("msg").toString();
 
         if (messageType == "updated") {
 
         } else if (messageType == "result") {            
             unsigned id = root.value("id").toString().toInt();
             
         if (m_callbackHash.contains(id)) {
                 std::function<void (QJsonDocument)> callback = m_callbackHash.take(id);
 
-                QByteArray ba;
-                ba.append(root.value("result").toString());
-
                 //check message type
                 QJsonDocument res = QJsonDocument(root.value("result").toObject());
                 QJsonObject result = res.object();
                 QString type = result.value("type").toString();
+                QString msg = result.value("msg").toString();
 
                 if (type == "image"){
-                    QByteArray decodedImage = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh");
+                    QByteArray decodedImage;
+                    QByteArray image;
                     QPixmap pixmap;
-                    pixmap.loadFromData(decodedImage,0,Qt::AutoColor);
                     QLabel label;
+
+                    decodedImage.append(msg);
+                    image = QByteArray::fromBase64(decodedImage);
+                    pixmap.loadFromData(image,0,Qt::AutoColor);
                     label.setPixmap(pixmap);
                     label.show();
                 } else if (type == "text"){
 
                 }
 
                 callback( QJsonDocument(root.value("result").toObject()) );
          }
             emit result(id, QJsonDocument(root.value("result").toObject()));
 
             if (id == m_loginJob) {
                 if (root.value("error").toObject().value("error").toInt() == 403) {
                     qDebug() << "Wrong password or token expired";
                     
                     login(); // Let's keep trying to log in
                 } else {
                     Ruqola::self()->setAuthToken(root.value("result").toObject().value("token").toString());
 
                     setLoginStatus(DDPClient::LoggedIn);
                 }
 //                 emit loggedInChanged();
             }
             
         } else if (messageType == "connected") {
             qDebug() << "Connected";
             m_connected = true;
             emit connectedChanged();
             setLoginStatus(DDPClient::LoggingIn);
             login(); // Try to resume auth token login         
         } else if (messageType == "error") {
             qDebug() << "ERROR!!" << message;
         } else if (messageType == "ping") {
             qDebug() << "Ping - Pong";
             QJsonObject pong;
             pong["msg"] = "pong";
             m_webSocket.sendBinaryMessage(QJsonDocument(pong).toJson(QJsonDocument::Compact));
         } else if (messageType == "added"){
             qDebug() << "ADDING" <<root;
             emit added(root);
         } else if (messageType == "changed") {
             emit changed(root);
         } else if (messageType == "ready") {
             // do nothing
         } else {
             qDebug() << "received something unhandled:" << message;
         }
     }
     
 }
 
 void DDPClient::setLoginStatus(DDPClient::LoginStatus l)
 {
     qDebug() << "Setting login status to" << l;
     m_loginStatus = l;
     emit loginStatusChanged();
     
     // reset flags
     if (l == LoginFailed) {
         m_attemptedPasswordLogin = false;
         m_attemptedTokenLogin = false;
     }
 }
 
 void DDPClient::login()
 {
     if (!Ruqola::self()->password().isEmpty()) {
  
         // If we have a password and we couldn't log in, let's stop here
         if (m_attemptedPasswordLogin) {
             setLoginStatus(LoginFailed);
             return;
         }
         
         m_attemptedPasswordLogin = true;
         QJsonObject user;
         user["username"] = Ruqola::self()->userName();
         QJsonObject json;
         json["password"] = Ruqola::self()->password();
         json["user"] = user;
         m_loginJob = method("login", QJsonDocument(json));
         
     } else if (!Ruqola::self()->authToken().isEmpty() && !m_attemptedTokenLogin) {
         m_attemptedPasswordLogin = true;
         QJsonObject json;
         json["resume"] = Ruqola::self()->authToken();
         m_loginJob = method("login", QJsonDocument(json));
     } else {
         setLoginStatus(LoginFailed);
     }
 }
 
 void DDPClient::logOut()
 {
 //     setLoginStatus(NotConnected);
     m_webSocket.close();
 }
 
 void DDPClient::onWSConnected()
 {
     qDebug() << "Websocket connected at URL" << m_url;
     
     QJsonArray supportedVersions;
     supportedVersions.append("1");
     QJsonObject protocol;
     protocol["msg"] = "connect";
     protocol["version"] = "1";
     protocol["support"] = supportedVersions;
 //     QString json("{\"msg\":\"connect\", \"version\": \"1\", \"support\": [\"1\"]}");
     QByteArray serialize = QJsonDocument(protocol).toJson(QJsonDocument::Compact);
     qint64 bytes = m_webSocket.sendTextMessage(serialize);
     if (bytes < serialize.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     } else {
         qDebug() << "Successfully sent " << serialize;
     }
 }
 
 void DDPClient::WSclosed()
 {
     qDebug() << "WebSocket CLOSED" << m_webSocket.closeReason() << m_webSocket.error() << m_webSocket.closeCode();
     setLoginStatus(NotConnected);
 //     m_connected = false;
 }
 
 
diff --git a/src/ruqola.cpp b/src/ruqola.cpp
index 5f69c892..2f3c7736 100644
--- a/src/ruqola.cpp
+++ b/src/ruqola.cpp
@@ -1,275 +1,274 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@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 "ruqola.h"
 #include "roommodel.h"
 #include "ddpclient.h"
 #include "notification.h"
 #include <QFileDialog>
 #include <QTcpSocket>
 #include <QDataStream>
 #include <QString>
 
 Ruqola *Ruqola::m_self = 0;
 
 QString Ruqola::authToken() const
 {
     return m_authToken;
 }
 
 QString Ruqola::userName() const
 {
     return m_userName;
 }
 
 QString Ruqola::userID() const
 {
     return m_userID;
 }
 
 QString Ruqola::password() const
 {
     return m_password;
 }
 
 void Ruqola::setAuthToken(const QString& token)
 {
     qDebug() << "Setting token to" << token;
     QSettings s;
     m_authToken = token;
     s.setValue("authToken", token);
 }
 
 void Ruqola::setPassword(const QString& password)
 {
     m_password = password;
 }
 
 void Ruqola::setUserName(const QString& username)
 {
     m_userName = username;
     QSettings s;
     s.setValue("username", username);
     emit userNameChanged();
 }
 
 void Ruqola::setUserID(const QString& userID)
 {
     m_userName = userID;
     QSettings s;
     s.setValue("userID", userID);
     emit userIDChanged();
 }
 
 RoomModel * Ruqola::roomModel()
 {
     if (!m_roomModel) {
         qDebug() << "creating new RoomModel";
         m_roomModel = new RoomModel(this);
         qDebug() << m_roomModel;
     }
     return m_roomModel;
 }
 
 DDPClient * Ruqola::ddp()
 {
     if (!m_ddp) {
         m_ddp = new DDPClient(serverURL());
         connect(m_ddp, &DDPClient::loginStatusChanged, this, &Ruqola::loginStatusChanged);
 //         connect(m_ddp, &DDPClient::loginStatusChanged, this, [=](){qDebug() << "Signal received";});
     }
     return m_ddp;
 }
 
 Notification * Ruqola::notification()
 {
     if (m_notification == NULL) {
         m_notification = new Notification();
         m_notification->show();
     }
     return m_notification;
 }
 
 void Ruqola::attachmentButtonClicked()
 {
     //open fileDialogBox, select an image, encode and send to server
     QString fileName = QFileDialog::getOpenFileName(Q_NULLPTR,
                                               "Select one or more files to open",
                                               QDir::homePath(),
                                               "Images (*.png *.jpeg *.jpg)");
 
     qDebug() << "Selected Image " << fileName;
 
         QFile file(fileName);
         if (!file.open(QFile::ReadOnly)) {
             qDebug() << "Cannot open the selected file";
             return;
         }
-
         QByteArray block; // Data that will be sent
         block = file.readAll();
         block.toBase64();
 
         QString message(block);
         QString roomID("3cGRyFLWgnPL7B79n"); //hard code roomID for now
         QString type("image");
         qDebug() << "base64 image- " << message;
 
         sendMessage(roomID,message,type);
 }
 
 void Ruqola::sendMessage(const QString &roomID, const QString &message, const QString type)
 {
     QString json = "{\"rid\": \"%1\", \"msg\": \"%2\", \"type\": \"%3\"}";
     json = json.arg(roomID, message, type);
     qDebug() << "Sending json: " << json;
 
     ddp()->method("sendMessage", QJsonDocument::fromJson(json.toUtf8()));
 }
 
 MessageModel * Ruqola::getModelForRoom(const QString& roomID)
 {
     if (m_messageModels.contains(roomID)) {
 //         qDebug() << "Returning old model for " << roomID;
         return m_messageModels.value(roomID);
     } else {
 //         qDebug() << "Creating a new model";
         m_messageModels[roomID] = new MessageModel(roomID, this);
 
         return m_messageModels[roomID];
     }
 }
 
 QString Ruqola::serverURL() const
 {
     return m_serverURL;
 }
 
 void Ruqola::setServerURL(const QString& serverURL)
 {
     if (m_serverURL == serverURL) {
         return;
     }
 
     QSettings s;
     s.setValue("serverURL", serverURL);
     m_serverURL = serverURL;
 //     m_roomModel->reset();
     emit serverURLChanged();
 }
 
 DDPClient::LoginStatus Ruqola::loginStatus()
 {
     if (m_ddp) {
         return ddp()->loginStatus();
     } else {
         return DDPClient::LoggedOut;
     }
 }
 
 void Ruqola::tryLogin()
 {
     qDebug() << "Attempting login" << userName() << "on" << serverURL();
 
     // Reset model views
     foreach (const QString key, m_messageModels.keys()) {
         MessageModel *m = m_messageModels.take(key);
         delete m;
     }
     delete m_ddp;
     m_ddp = 0;
 
     // In the meantime, load cache...
     m_roomModel->reset();
 
     // This creates a new ddp() object.
     // DDP will automatically try to connect and login.
     ddp();
 }
 
 void Ruqola::logOut()
 {
     setAuthToken(QString());
     setPassword(QString());
     foreach (const QString key, m_messageModels.keys()) {
         MessageModel *m = m_messageModels.take(key);
         delete m;
     }
     delete m_ddp;
     m_ddp = 0;
     emit loginStatusChanged();
 
     m_roomModel->clear();
 }
 
 QString Ruqola::cacheBasePath() const
 {
     if (m_serverURL.isEmpty()) {
         return QString();
     }
     return QStandardPaths::writableLocation(QStandardPaths::CacheLocation)+'/'+m_serverURL;
 }
 
 // QString Ruqola::activeRoom() const
 // {
 //     return m_activeRoom;
 // }
 // void Ruqola::setActiveRoom(const QString& activeRoom)
 // {
 //     m_activeRoom = activeRoom;
 // //     roomModel()->setActiveRoom(activeRoom);
 //     emit activeRoomChanged();
 // }
 
 RoomWrapper * Ruqola::getRoom(const QString& roomID)
 {
     return roomModel()->findRoom(roomID);
 }
 
 
 Ruqola::Ruqola(QObject* parent): QObject(parent), m_ddp(0), m_roomModel(0), m_notification(0)
 {
     QSettings s;
     m_serverURL = s.value("serverURL", "demo.rocket.chat").toString();
     m_userName = s.value("username").toString();
     m_userID = s.value("userID").toString();
     m_authToken = s.value("authToken").toString();
 }
 
 Ruqola * Ruqola::self()
 {
     if (!m_self) {
         m_self = new Ruqola;
 
         // Create DDP object so we try to connect at startup
         m_self->ddp();
 
         // Clear rooms data and refill it with data in the cache, if there is
         m_self->roomModel()->reset();
 
         // Create systray to show notifications
         m_self->notification();
     }
     return m_self;
 }