Merge lp:~ahayzen/ubuntu-ui-extras/job-model-split-update into lp:~phablet-team/ubuntu-ui-extras/printer-staging

[Andrew Hayzen]

* Add a JobLoader for loading a specific jobId for a printer and loading the extended attributes
* Move the loading of creationTime, completedTime, processingTime, size and user to extended attributes as signals don't give us those
* Add method for PrinterBackend for getting a specific job
* Split up JobModel::update so there is jobCreated, jobState and jobCompleted which then call addJob, removeJob and updateJob
* Improve Printer::updateFrom to not call loadAttributes as this results in a possible UI block
* Add missing comparisions for PrinterJob deepCompare and updateFrom
* Change PrinterJob::setPrinter to not call loadDefaults and instead explicitly call it
* Change Printers to trigger requestJobExtendedAttributes which triggers a background thread rather than doing in foreground

* Add a JobLoader for loading a specific jobId for a printer and loading the extended attributes
* Move the loading of creationTime, completedTime, processingTime, size and user to extended attributes as signals don't give us those
* Add method for PrinterBackend for getting a specific job
* Split up JobModel::update so there is jobCreated, jobState and jobCompleted which then call addJob, removeJob and updateJob
* Improve Printer::updateFrom to not call loadAttributes as this results in a possible UI block
* Add missing comparisions for PrinterJob deepCompare and updateFrom
* Change PrinterJob::setPrinter to not call loadDefaults and instead explicitly call it
* Change Printers to trigger requestJobExtendedAttributes which triggers a background thread rather than doing in foreground

[Jonas G. Drange (jonas-drange)]

Looks good! A couple of requests for information.

review: Needs Information

[lp:~ahayzen/ubuntu-ui-extras/job-model-split-update]

149. By Andrew Hayzen on 2017-03-14

* Resolve failing tests with new JobLoader changes
* Add comments

150. By Andrew Hayzen on 2017-03-14

* Remove MockPrinters and use Printers directly

151. By Andrew Hayzen on 2017-03-14

* Rename m_activeRequests to m_activePrinterRequests
* Update JobModel::updateJob description

152. By Andrew Hayzen on 2017-03-14

* Pull of upstream

153. By Andrew Hayzen on 2017-03-14

* Fix missed renames
* Fix failing tests
* Actually set the printer from JobLoader to the PrinterJob in JobModel, even if it isn't loaded to keep the reference up to date
* Improve emulation to be closer to real

[Andrew Hayzen (ahayzen)]

1) I wonder if you could rename this to m_activePrinterRequests.

Yup, done

2) Could you inform me what will happen when a thread is locked out? Will it keep trying until it can get a lock? What's the behavior?

At the moment it will block the thread and keep trying. Do you think we should use tryLock? Note that the problem is not usually that the Ipp request blocks, it is that only one request should be done at a time. Otherwise if two requests done at the same one or both of them will fail with strange errors.

3) Maybe. For printer's we have this proxytype. Maybe you could introduce the same semantics?

I think this should be done in a future branch, also async cups requests would fix this.

4) Not entirely sure I understand this comment. Could you clarify?

JobLoader::load used to create it's own PrinterBackend to avoid threading issues that #2 resolved. This comment is now incorrect, I've updated it.

5) Good. I wonder why it wasn't like this in the first place.

Yeah exactly, this is probably one of the places that would cause the app to hang that we hadn't figured out :-)

Also are you able to test if we need to set the timezone information for creation/completion/processing times?

[lp:~ahayzen/ubuntu-ui-extras/job-model-split-update]

154. By Andrew Hayzen on 2017-03-14

* Use tryLock instead of lock and print a warning

[Jonas G. Drange (jonas-drange)]

Is this a bug in the API or PrinterQueue? http://i.imgur.com/s8CBHJM.png

Still getting:

    QObject::connect: Cannot queue arguments of type 'QVector<int>'
    (Make sure 'QVector<int>' is registered using qRegisterMetaType().)

I think this is introduced by this branch?

Otherwise, I'm at UNI and have 30 printers showing up that may or may not be reachable, and this is really snappy and non-crashy.

review: Needs Information

[Jonas G. Drange (jonas-drange)]

Couple of minor nitpicks. Also, /* … */ should be used for multi lined comments, please (super small nitpick).

review: Needs Fixing

[lp:~ahayzen/ubuntu-ui-extras/job-model-split-update]

155. By Andrew Hayzen on 2017-03-15

* Change JobLoader to only respond with a QMap of attributes and not a PrinterJob
* Change Printers to directly call JobModel::updateJobPrinter
* Remove headers we don't need in JobLoader
* Change FIXME to TODO
* Update tests

[Andrew Hayzen (ahayzen)]

1) Not sure it needs this header?

Yup removed

2) s/FIXME/TODO :)

Fixed

3) Are you fixing this? Otherwise, could you rewrite it to be a TODO? Fixme's I associate with "fix before merging". :)
And in what cases aren't the newJob's printer fully loaded?

Changed, when in the Queue app it only uses the list of jobs and doesn't load any printers, so they are all proxytype.

4) Seems the timezone is set, but the time stamp does not it reflect it. E.g. time was 13:51 (UTC+1) and the time stamp in the job appeared as 12:51 GMT+0100.

Investigating on next commit...

Made the changes to JobLoader to return a QMap rather than a 'new' job.

[lp:~ahayzen/ubuntu-ui-extras/job-model-split-update]

156. By Andrew Hayzen on 2017-03-15

* Set timezone for completedTime, creationTime, processingTime in PrinterJob

[Andrew Hayzen (ahayzen)]

4) Timezone stuff

Tried setting a timezone for the datetime's let me know if this works.

[lp:~ahayzen/ubuntu-ui-extras/job-model-split-update]

157. By Andrew Hayzen on 2017-03-16

* Fix timezones, internally use UTC then when exposing to QML set as local timezone

158. By Andrew Hayzen on 2017-03-16

* Set timezone after time_t

[Jonas G. Drange (jonas-drange)]

Very good, thanks!

review: Approve

=== modified file 'modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-03-08 14:47:16 +0000
+++ modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-03-16 15:26:32 +0000
@@ -31,6 +31,7 @@
 
     cups/devicesearcher.cpp
     cups/ippclient.cpp
+    cups/jobloader.cpp
     cups/printerdriverloader.cpp
     cups/printerloader.cpp
 

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-03-16 15:26:32 +0000
@@ -182,6 +182,14 @@
     return QList<QSharedPointer<PrinterJob>>{};
 }
 
+QSharedPointer<PrinterJob> PrinterBackend::printerGetJob(
+        const QString &printerName, const int jobId)
+{
+    Q_UNUSED(printerName);
+    Q_UNUSED(jobId);
+    return QSharedPointer<PrinterJob>(Q_NULLPTR);
+}
+
 QMap<QString, QVariant> PrinterBackend::printerGetJobAttributes(
         const QString &name, const int jobId)
 {
@@ -281,6 +289,13 @@
     return QString();
 }
 
+void PrinterBackend::requestJobExtendedAttributes(
+        QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job)
+{
+    Q_UNUSED(printer);
+    Q_UNUSED(job);
+}
+
 void PrinterBackend::requestPrinterDrivers()
 {
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-03-16 15:26:32 +0000
@@ -86,6 +86,8 @@
                                 const QString &title,
                                 const cups_dest_t *dest);
     virtual QList<QSharedPointer<PrinterJob>> printerGetJobs();
+    virtual QSharedPointer<PrinterJob> printerGetJob(const QString &printerName,
+                                                     const int jobId);
     virtual QMap<QString, QVariant> printerGetJobAttributes(
         const QString &name, const int jobId);
 
@@ -111,6 +113,8 @@
     virtual QSharedPointer<Printer> getPrinter(const QString &printerName);
     virtual QString defaultPrinterName();
 
+    virtual void requestJobExtendedAttributes(QSharedPointer<Printer> printer,
+                                              QSharedPointer<PrinterJob> job);
     virtual void requestPrinterDrivers();
     virtual void requestPrinter(const QString &printerName);
 
@@ -125,6 +129,7 @@
     void printerDriversLoaded(const QList<PrinterDriver> &drivers);
     void printerDriversFailedToLoad(const QString &errorMessage);
 
+    void jobLoaded(QString, int, QMap<QString, QVariant>);
     void printerLoaded(QSharedPointer<Printer> printers);
     void deviceFound(const Device &device);
     void deviceSearchFinished();

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-03-13 13:21:01 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-03-16 15:26:32 +0000
@@ -16,6 +16,7 @@
 
 #include "backend/backend_cups.h"
 #include "cups/devicesearcher.h"
+#include "cups/jobloader.h"
 #include "cups/printerdriverloader.h"
 #include "cups/printerloader.h"
 #include "utils.h"
@@ -468,6 +469,18 @@
         map.insert("ColorModel", QVariant(""));
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-completed", QDateTime)) {
+        map.insert("CompletedTime", rawMap.value("date-time-at-completed"));
+    } else {
+        map.insert("CompletedTime", QVariant(QDateTime()));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-creation", QDateTime)) {
+        map.insert("CreationTime", rawMap.value("date-time-at-creation"));
+    } else {
+        map.insert("CreationTime", QVariant(QDateTime()));
+    }
+
     if (__CUPS_ATTR_EXISTS(rawMap, "Duplex", QString)) {
         map.insert("Duplex", rawMap.value("Duplex"));
     } else {
@@ -493,6 +506,12 @@
         map.insert("page-ranges", QVariant(QStringList()));
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-processing", QDateTime)) {
+        map.insert("ProcessingTime", rawMap.value("date-time-at-processing"));
+    } else {
+        map.insert("ProcessingTime", QVariant(QDateTime()));
+    }
+
     Q_FOREACH(QString qualityOption, m_knownQualityOptions) {
         if (rawMap.contains(qualityOption)
                 && rawMap.value(qualityOption).canConvert<QString>()) {
@@ -510,6 +529,18 @@
         map.insert("OutputOrder", "Normal");
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-k-octets", int)) {
+        map.insert("Size", rawMap.value("job-k-octets"));
+    } else {
+        map.insert("Size", QVariant(0));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-originating-user-name", QString)) {
+        map.insert("User", rawMap.value("job-originating-user-name"));
+    } else {
+        map.insert("User", QVariant(""));
+    }
+
     // Generate a list of messages
     // TODO: for now just using job-printer-state-message, are there others?
     QStringList messages;
@@ -530,31 +561,13 @@
     QList<QSharedPointer<PrinterJob>> list;
 
     Q_FOREACH(auto job, jobs) {
+        // Note: extended attributes are not loaded here
+        // they are loaded in JobLoader
         auto newJob = QSharedPointer<PrinterJob>(
             new PrinterJob(QString::fromUtf8(job->dest), this, job->id)
         );
-
-        // Extract the times
-        QDateTime completedTime;
-        completedTime.setTimeZone(QTimeZone::systemTimeZone());
-        completedTime.setTime_t(job->completed_time);
-
-        QDateTime creationTime;
-        creationTime.setTimeZone(QTimeZone::systemTimeZone());
-        creationTime.setTime_t(job->creation_time);
-
-        QDateTime processingTime;
-        processingTime.setTimeZone(QTimeZone::systemTimeZone());
-        processingTime.setTime_t(job->processing_time);
-
-        // Load the information from the cups struct
-        newJob->setCompletedTime(completedTime);
-        newJob->setCreationTime(creationTime);
-        newJob->setProcessingTime(processingTime);
-        newJob->setSize(job->size);
         newJob->setState(static_cast<PrinterEnum::JobState>(job->state));
         newJob->setTitle(QString::fromLocal8Bit(job->title));
-        newJob->setUser(QString::fromLocal8Bit(job->user));
 
         list.append(newJob);
     }
@@ -564,6 +577,35 @@
     return list;
 }
 
+QSharedPointer<PrinterJob> PrinterCupsBackend::printerGetJob(
+        const QString &printerName, const int jobId)
+{
+    auto jobs = getCupsJobs(printerName);
+    cups_job_t *cupsJob = Q_NULLPTR;
+    QSharedPointer<PrinterJob> job(Q_NULLPTR);
+
+    for (int i=0; i < jobs.size(); i++) {
+        if (jobs.at(i)->id == jobId) {
+            cupsJob = jobs.at(i);
+            break;
+        }
+    }
+
+    if (cupsJob) {
+        job = QSharedPointer<PrinterJob>(
+            new PrinterJob(QString::fromUtf8(cupsJob->dest), this, cupsJob->id)
+        );
+
+        job->setState(static_cast<PrinterEnum::JobState>(cupsJob->state));
+        job->setTitle(QString::fromLocal8Bit(cupsJob->title));
+    }
+
+    if (!jobs.size())
+        cupsFreeJobs(jobs.size(), jobs.first());
+
+    return job;
+}
+
 QString PrinterCupsBackend::printerName() const
 {
     return m_printerName;
@@ -675,9 +717,35 @@
     return QPrinterInfo::defaultPrinterName();
 }
 
+void PrinterCupsBackend::requestJobExtendedAttributes(
+        QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job)
+{
+    QPair<QString, int> pair(printer->name(), job->jobId());
+
+    if (m_activeJobRequests.contains(pair)) {
+        return;
+    }
+
+    auto thread = new QThread;
+    auto loader = new JobLoader(this, printer->name(), job->jobId());
+    loader->moveToThread(thread);
+    connect(thread, SIGNAL(started()), loader, SLOT(load()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(QString, int, QMap<QString, QVariant>)),
+            this, SIGNAL(jobLoaded(QString, int, QMap<QString, QVariant>)));
+    connect(loader, SIGNAL(loaded(QString, int, QMap<QString, QVariant>)),
+            this, SLOT(onJobLoaded(QString, int, QMap<QString, QVariant>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+    m_activeJobRequests << pair;
+
+    thread->start();
+}
+
 void PrinterCupsBackend::requestPrinter(const QString &printerName)
 {
-    if (m_activeRequests.contains(printerName)) {
+    if (m_activePrinterRequests.contains(printerName)) {
         return;
     }
 
@@ -692,9 +760,10 @@
     connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
             this, SLOT(onPrinterLoaded(QSharedPointer<Printer>)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+    m_activePrinterRequests << printerName;
+
     thread->start();
-
-    m_activeRequests << printerName;
 }
 
 void PrinterCupsBackend::requestPrinterDrivers()
@@ -711,6 +780,7 @@
     connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
             this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
     thread->start();
 }
 
@@ -801,8 +871,17 @@
     return m_extendedAttributeNames.contains(attributeName);
 }
 
+void PrinterCupsBackend::onJobLoaded(QString printerName, int jobId,
+                                     QMap<QString, QVariant> attributes)
+{
+    Q_UNUSED(attributes);
+
+    QPair<QString, int> pair(printerName, jobId);
+    m_activeJobRequests.remove(pair);
+}
+
 void PrinterCupsBackend::onPrinterLoaded(QSharedPointer<Printer> printer)
 {
-    m_activeRequests.remove(printer->name());
+    m_activePrinterRequests.remove(printer->name());
 }
 

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-03-16 15:26:32 +0000
@@ -81,6 +81,8 @@
                                 const QString &title,
                                 const cups_dest_t *dest) override;
     virtual QList<QSharedPointer<PrinterJob>> printerGetJobs() override;
+    virtual QSharedPointer<PrinterJob> printerGetJob(
+            const QString &printerName, const int jobId) override;
 
     virtual QString printerName() const override;
     virtual QString description() const override;
@@ -103,6 +105,10 @@
     virtual QStringList availablePrinterNames() override;
     virtual QSharedPointer<Printer> getPrinter(const QString &printerName) override;
     virtual QString defaultPrinterName() override;
+
+    virtual void requestJobExtendedAttributes(
+            QSharedPointer<Printer> printer,
+            QSharedPointer<PrinterJob> job) override;
     virtual void requestPrinterDrivers() override;
     virtual void requestPrinter(const QString &printerName) override;
     virtual QMap<QString, QVariant> printerGetJobAttributes(
@@ -142,9 +148,12 @@
     int m_cupsSubscriptionId;
     mutable QMap<QString, cups_dest_t*> m_dests; // Printer name, dest.
     mutable QMap<QString, ppd_file_t*> m_ppds; // Printer name, ppd.
-    QSet<QString> m_activeRequests;
+    QSet<QString> m_activePrinterRequests;
+    QSet<QPair<QString, int>> m_activeJobRequests;
 
 private Q_SLOTS:
+    void onJobLoaded(QString printerName, int jobId,
+                     QMap<QString, QVariant> attributes);
     void onPrinterLoaded(QSharedPointer<Printer> printer);
 };
 

=== modified file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	2017-03-16 15:26:32 +0000
@@ -475,6 +475,14 @@
     ipp_t *request;
     QMap<QString, QVariant> map;
 
+    // Try to get the lock, if we can't after 5 seconds then fail and return
+    if (!m_thread_lock.tryLock(5000)) {
+        qWarning() << "Unable to get lock for IppClient::printerGetJobAttributes."
+                   << "Unable to load attributes for job:" << jobId << " for "
+                   << printerName;
+        return map;
+    }
+
     // Construct request
     request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
 
@@ -500,7 +508,8 @@
             map.insert(ippGetName(attr), value);
         }
     } else {
-        qWarning() << "Not able to get attributes of job:" << jobId;
+        qWarning() << "Not able to get attributes of job:" << jobId << " for "
+                   << printerName;
     }
 
     // Destruct the reply if valid
@@ -508,6 +517,8 @@
         ippDelete(reply);
     }
 
+    m_thread_lock.unlock();
+
     return map;
 }
 
@@ -1107,8 +1118,8 @@
         case IPP_TAG_DATE: {
             time_t time = ippDateToTime(ippGetDate(attr, index));
             QDateTime datetime;
-            datetime.setTimeZone(QTimeZone::systemTimeZone());
             datetime.setTime_t(time);
+            datetime.setTimeZone(QTimeZone::utc());
 
             var = QVariant::fromValue<QDateTime>(datetime);
             break;

=== modified file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	2017-03-14 13:35:58 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	2017-03-16 15:26:32 +0000
@@ -25,6 +25,7 @@
 #include <cups/ipp.h>
 #include <cups/ppd.h>
 
+#include <QMutex>
 #include <QString>
 #include <QStringList>
 
@@ -125,6 +126,7 @@
     http_t *m_connection;
     ipp_status_t m_lastStatus = IPP_OK;
     mutable QString m_internalStatus = QString::null;
+    QMutex m_thread_lock;
 };
 
 

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp	2017-03-16 15:26:32 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jobloader.h"
+
+#include "backend/backend.h"
+
+#include "printers/printers.h"
+
+#include <QDBusConnection>
+#include <QPrinterInfo>
+
+class PrinterCupsBackend;
+JobLoader::JobLoader(PrinterBackend *backend,
+                     QString printerName,
+                     int jobId,
+                     QObject *parent)
+    : QObject(parent)
+    , m_backend(backend)
+    , m_job_id(jobId)
+    , m_printer_name(printerName)
+{
+}
+
+JobLoader::~JobLoader()
+{
+}
+
+void JobLoader::load()
+{
+    QMap<QString, QVariant> map = m_backend->printerGetJobAttributes(
+        m_printer_name, m_job_id
+    );
+
+    Q_EMIT loaded(m_printer_name, m_job_id, map);
+    Q_EMIT finished();
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h	2017-03-16 15:26:32 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_CUPS_JOBLOADER_H
+#define USC_PRINTERS_CUPS_JOBLOADER_H
+
+#include "printer/printer.h"
+#include "printer/printerjob.h"
+
+#include <QList>
+#include <QObject>
+#include <QSharedPointer>
+
+class JobLoader : public QObject
+{
+    Q_OBJECT
+    PrinterBackend *m_backend;
+    int m_job_id;
+    QString m_printer_name;
+public:
+    explicit JobLoader(PrinterBackend *backend,
+                       QString printerName, int jobId,
+                       QObject *parent = Q_NULLPTR);
+    ~JobLoader();
+
+public Q_SLOTS:
+    void load();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(QString, int, QMap<QString, QVariant>);
+};
+
+#endif // USC_PRINTERS_CUPS_JOBLOADER_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-03-06 13:19:08 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-03-16 15:26:32 +0000
@@ -31,113 +31,169 @@
     : QAbstractListModel(parent)
     , m_backend(backend)
 {
-    update();
-
     QObject::connect(m_backend, &PrinterBackend::jobCreated,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobCreated);
     QObject::connect(m_backend, &PrinterBackend::jobState,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobState);
     QObject::connect(m_backend, &PrinterBackend::jobCompleted,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobCompleted);
+
+    connect(m_backend, SIGNAL(jobLoaded(QString, int, QMap<QString, QVariant>)),
+            this, SLOT(updateJob(QString, int, QMap<QString, QVariant>)));
+
+    // Add already existing jobs
+    // TODO: even this should probably be in a background thread?
+    // so that it doesn't block startup?
+    Q_FOREACH(auto job, m_backend->printerGetJobs()) {
+        addJob(job);
+    }
 }
 
 JobModel::~JobModel()
 {
 }
 
-void JobModel::jobSignalCatchAll(
-        const QString &text, const QString &printer_uri,
-        const QString &printer_name, uint printer_state,
-        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
-        uint job_id, uint job_state, const QString &job_state_reasons,
-        const QString &job_name, uint job_impressions_completed)
-{
-    Q_UNUSED(text);
-    Q_UNUSED(printer_uri);
-    Q_UNUSED(printer_name);
-    Q_UNUSED(printer_state);
-    Q_UNUSED(printer_state_reasons);
-    Q_UNUSED(printer_is_accepting_jobs);
-    Q_UNUSED(job_id);
+void JobModel::jobCreated(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);  // "Job Created"
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
+    Q_UNUSED(job_state_reasons);
+
+    QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(
+        new PrinterJob(printer_name, m_backend, job_id)
+    );
+    job->setImpressionsCompleted(job_impressions_completed);
+    job->setState(static_cast<PrinterEnum::JobState>(job_state));
+    job->setTitle(job_name);
+
+    // Printers listens to rowInserted and spawns a JobLoader to set the
+    // printer of the job, which triggers the extended attributes to be loaded
+    // once complete this triggers JobModel::updateJob
+    addJob(job);
+}
+
+void JobModel::jobState(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
+    Q_UNUSED(job_state_reasons);
+    Q_UNUSED(job_name);
+
+    QSharedPointer<PrinterJob> job = getJob(printer_name, job_id);
+
+    if (job) {
+        job->setImpressionsCompleted(job_impressions_completed);
+        job->setState(static_cast<PrinterEnum::JobState>(job_state));
+
+        updateJob(job);
+    } else {
+        qWarning() << "JobModel::jobState for unknown job: " << job_name << " ("
+                   << job_id << ") for " << printer_name;
+    }
+}
+
+void JobModel::jobCompleted(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
     Q_UNUSED(job_state);
     Q_UNUSED(job_state_reasons);
     Q_UNUSED(job_name);
-
-    auto job = getJobById(job_id);
-    if (job)
-        job->setImpressionsCompleted(job_impressions_completed);
-
-    update();
-}
-
-void JobModel::update()
-{
-    // Store the old count and get the new printers
-    int oldCount = m_jobs.size();
-    QList<QSharedPointer<PrinterJob>> newJobs = m_backend->printerGetJobs();
-
-    // Go through the old model
-    for (int i=0; i < m_jobs.count(); i++) {
-        // Determine if the old printer exists in the new model
-        bool exists = false;
-
-        Q_FOREACH(QSharedPointer<PrinterJob> p, newJobs) {
-            if (p->jobId() == m_jobs.at(i)->jobId()) {
-                exists = true;
-
-                // Ensure the other properties of the job are up to date
-                if (!m_jobs.at(i)->deepCompare(p)) {
-                    m_jobs.at(i)->updateFrom(p);
-
-                    Q_EMIT dataChanged(index(i), index(i));
-                }
-
-                break;
-            }
-        }
-
-        // If it doesn't exist then remove it from the old model
-        if (!exists) {
-            beginRemoveRows(QModelIndex(), i, i);
-            QSharedPointer<PrinterJob> p = m_jobs.takeAt(i);
-            endRemoveRows();
-
-            i--;  // as we have removed an item decrement
-        }
-    }
-
-    // Go through the new model
-    for (int i=0; i < newJobs.count(); i++) {
-        // Determine if the new printer exists in the old model
-        bool exists = false;
-        int j;
-
-        for (j=0; j < m_jobs.count(); j++) {
-            if (m_jobs.at(j)->jobId() == newJobs.at(i)->jobId()) {
-                exists = true;
-                break;
-            }
-        }
-
-        if (exists) {
-            if (j == i) {  // New printer exists and in correct position
-                continue;
-            } else {
-                // New printer does exist but needs to be moved in old model
-                beginMoveRows(QModelIndex(), j, 1, QModelIndex(), i);
-                m_jobs.move(j, i);
-                endMoveRows();
-            }
-        } else {
-            // New printer does not exist insert into model
-            beginInsertRows(QModelIndex(), i, i);
-            m_jobs.insert(i, newJobs.at(i));
-            endInsertRows();
-        }
-    }
-
-    if (oldCount != m_jobs.size()) {
-        Q_EMIT countChanged();
+    Q_UNUSED(job_impressions_completed);
+
+    auto job = getJob(printer_name, job_id);
+    if (job) {
+        removeJob(job);
+    } else {
+        qWarning() << "JobModel::jobCompleted for unknown job: " << job_name << " ("
+                   << job_id << ") for " << printer_name;
+    }
+}
+
+void JobModel::addJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.size();
+
+    beginInsertRows(QModelIndex(), i, i);
+    m_jobs.append(job);
+    endInsertRows();
+
+    Q_EMIT countChanged();
+}
+
+void JobModel::removeJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.indexOf(job);
+
+    beginRemoveRows(QModelIndex(), i, i);
+    m_jobs.removeAt(i);
+    endRemoveRows();
+
+    Q_EMIT countChanged();
+}
+
+// This is used by JobModel::jobState as it has modified an existing job
+void JobModel::updateJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+// This is used by JobLoader as it gives us the oldJob and a newJob which has
+// the extended attributes loaded. We then load the data from this newJob.
+void JobModel::updateJob(QString printerName, int jobId,
+                         QMap<QString, QVariant> attributes)
+{
+    QSharedPointer<PrinterJob> job = getJob(printerName, jobId);
+
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+
+    if (i > -1) {
+        job->loadAttributes(attributes);
+
+        Q_EMIT dataChanged(idx, idx);
+    } else {
+        qWarning() << "Tried to updateJob which doesn't exist:" << printerName << jobId;
+    }
+}
+
+void JobModel::updateJobPrinter(QSharedPointer<PrinterJob> job, QSharedPointer<Printer> printer)
+{
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+
+    if (i > -1) {
+        job->setPrinter(printer);
+
+        Q_EMIT dataChanged(idx, idx);
+    } else {
+        qWarning() << "Tried to updateJobPrinter which doesn't exist:" << printer->name() << job->jobId();
     }
 }
 
@@ -175,13 +231,13 @@
             break;
         }
         case CompletedTimeRole:
-            ret = job->completedTime();
+            ret = job->completedTime().toLocalTime();
             break;
         case CopiesRole:
             ret = job->copies();
             break;
         case CreationTimeRole:
-            ret = job->creationTime();
+            ret = job->creationTime().toLocalTime();
             break;
         case DuplexRole: {
             if (job->printer()) {
@@ -217,7 +273,7 @@
             ret = QVariant::fromValue<PrinterEnum::PrintRange>(job->printRangeMode());
             break;
         case ProcessingTimeRole:
-            ret = job->processingTime();
+            ret = job->processingTime().toLocalTime();
             break;
         case QualityRole: {
             if (job->printer()) {
@@ -307,10 +363,10 @@
     return result;
 }
 
-QSharedPointer<PrinterJob> JobModel::getJobById(const int &id)
+QSharedPointer<PrinterJob> JobModel::getJob(const QString &printerName, const int &id)
 {
     Q_FOREACH(auto job, m_jobs) {
-        if (job->jobId() == id) {
+        if (job->printerName() == printerName && job->jobId() == id) {
             return job;
         }
     }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-03-06 13:19:08 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-03-16 15:26:32 +0000
@@ -30,6 +30,8 @@
 #include <QTimer>
 #include <QVariant>
 
+class PrinterBackend;
+class PrinterJob;
 class PRINTERS_DECL_EXPORT JobModel : public QAbstractListModel
 {
     Q_OBJECT
@@ -76,20 +78,40 @@
     int count() const;
 
     Q_INVOKABLE QVariantMap get(const int row) const;
-    QSharedPointer<PrinterJob> getJobById(const int &id);
+    QSharedPointer<PrinterJob> getJob(const QString &printerName, const int &id);
+
+    void updateJobPrinter(QSharedPointer<PrinterJob> job, QSharedPointer<Printer> printer);
 private:
+    void addJob(QSharedPointer<PrinterJob> job);
+    void removeJob(QSharedPointer<PrinterJob> job);
+    void updateJob(QSharedPointer<PrinterJob> Job);
+
     PrinterBackend *m_backend;
 
     QList<QSharedPointer<PrinterJob>> m_jobs;
 private Q_SLOTS:
-    void update();
-    void jobSignalCatchAll(const QString &text, const QString &printer_uri,
-                           const QString &printer_name, uint printer_state,
-                           const QString &printer_state_reasons,
-                           bool printer_is_accepting_jobs, uint job_id,
-                           uint job_state, const QString &job_state_reasons,
-                           const QString &job_name,
-                           uint job_impressions_completed);
+    void jobCreated(const QString &text, const QString &printer_uri,
+                    const QString &printer_name, uint printer_state,
+                    const QString &printer_state_reasons,
+                    bool printer_is_accepting_jobs, uint job_id,
+                    uint job_state, const QString &job_state_reasons,
+                    const QString &job_name,
+                    uint job_impressions_completed);
+    void jobState(const QString &text, const QString &printer_uri,
+                  const QString &printer_name, uint printer_state,
+                  const QString &printer_state_reasons,
+                  bool printer_is_accepting_jobs, uint job_id,
+                  uint job_state, const QString &job_state_reasons,
+                  const QString &job_name,
+                  uint job_impressions_completed);
+    void jobCompleted(const QString &text, const QString &printer_uri,
+                      const QString &printer_name, uint printer_state,
+                      const QString &printer_state_reasons,
+                      bool printer_is_accepting_jobs, uint job_id,
+                      uint job_state, const QString &job_state_reasons,
+                      const QString &job_name,
+                      uint job_impressions_completed);
+    void updateJob(QString printerName, int jobId, QMap<QString, QVariant> attributes);
 
 Q_SIGNALS:
     void countChanged();

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-03-16 15:26:32 +0000
@@ -127,22 +127,6 @@
     return QSharedPointer<Printer>(Q_NULLPTR);
 }
 
-void PrinterModel::movePrinter(const int &from, const int &to)
-{
-    int size = m_printers.size();
-    if (from < 0 || to < 0 || from >= size || to >= size) {
-        qWarning() << Q_FUNC_INFO << "Illegal move operation from"
-                   << from << "to" << to << ". Size was" << size;
-        return;
-    }
-    if (!beginMoveRows(QModelIndex(), from, from, QModelIndex(), to)) {
-        qWarning() << Q_FUNC_INFO << "failed to move rows.";
-        return;
-    }
-    m_printers.move(from, to);
-    endMoveRows();
-}
-
 void PrinterModel::removePrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
 {
     int idx = m_printers.indexOf(printer);

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-03-16 15:26:32 +0000
@@ -99,7 +99,6 @@
         const CountChangeSignal &notify = CountChangeSignal::Defer);
     void removePrinter(QSharedPointer<Printer> printer,
         const CountChangeSignal &notify = CountChangeSignal::Defer);
-    void movePrinter(const int &from, const int &to);
     void updatePrinter(QSharedPointer<Printer> old,
                        QSharedPointer<Printer> newPrinter);
     PrinterBackend *m_backend;

=== modified file 'modules/Ubuntu/Components/Extras/Printers/plugin.cpp'
--- modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-03-08 11:29:01 +0000
+++ modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-03-16 15:26:32 +0000
@@ -54,6 +54,7 @@
 
     qmlRegisterUncreatableType<PrinterEnum>(uri, 0, 1, "PrinterEnum", "Is an enum");
     qRegisterMetaType<QList<PrinterDriver>>("QList<PrinterDriver>");
+    qRegisterMetaType<QSharedPointer<PrinterJob>>("QSharedPointer<PrinterJob>");
     qRegisterMetaType<QList<QSharedPointer<Printer>>>("QList<QSharedPointer<Printer>>");
     qRegisterMetaType<Device>("Device");
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp	2017-03-10 13:15:27 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp	2017-03-16 15:26:32 +0000
@@ -403,10 +403,20 @@
 void Printer::updateFrom(QSharedPointer<Printer> other)
 {
     PrinterBackend *tmp = m_backend;
+
+    // Copy values from other printer which has been loaded in another thread
+    // Note: do not use loadAttributes otherwise can cause UI block
+    m_acceptJobs = other->m_acceptJobs;
     m_backend = other->m_backend;
+    m_defaultColorModel = other->m_defaultColorModel;
+    m_defaultPrintQuality = other->m_defaultPrintQuality;
+    m_deviceUri = other->m_deviceUri;
+    m_shared = other->m_shared;
+    m_stateMessage = other->m_stateMessage;
+    m_supportedColorModels = other->m_supportedColorModels;
+    m_supportedPrintQualities = other->m_supportedPrintQualities;
+
     other->m_backend = tmp;
-
-    loadAttributes();
 }
 
 void Printer::onPrinterStateChanged(

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp	2017-03-14 12:01:48 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp	2017-03-16 15:26:32 +0000
@@ -145,6 +145,62 @@
     return m_landscape;
 }
 
+void PrinterJob::loadAttributes(const QMap<QString, QVariant> &attributes)
+{
+    // Load the extra attributes for the job
+    // NOTE: we don't need to type check them as they have been filtered for us
+
+    setCollate(attributes.value("Collate").toBool());
+    setCopies(attributes.value("copies").toInt());
+
+    // No colorModel will result in PrinterJob using defaultColorModel
+    QString colorModel = attributes.value("ColorModel").toString();
+    for (int i=0; i < m_printer->supportedColorModels().length(); i++) {
+        if (m_printer->supportedColorModels().at(i).name == colorModel) {
+            setColorModel(i);
+        }
+    }
+
+    setCompletedTime(attributes.value("CompletedTime").toDateTime());
+    setCreationTime(attributes.value("CreationTime").toDateTime());
+
+    // No duplexMode will result in PrinterJob using defaultDuplexMode
+    QString duplex = attributes.value("Duplex").toString();
+    PrinterEnum::DuplexMode duplexMode = Utils::ppdChoiceToDuplexMode(duplex);
+    for (int i=0; i < m_printer->supportedDuplexModes().length(); i++) {
+        if (m_printer->supportedDuplexModes().at(i) == duplexMode) {
+            setDuplexMode(i);
+        }
+    }
+
+    setLandscape(attributes.value("landscape").toBool());
+    setMessages(attributes.value("messages").toStringList());
+
+    QStringList pageRanges = attributes.value("page-ranges").toStringList();
+    if (pageRanges.isEmpty()) {
+        setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
+        setPrintRange(QStringLiteral(""));
+    } else {
+        setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
+        // Use groupSeparator as createSeparatedList adds "and" into the string
+        setPrintRange(pageRanges.join(QLocale::system().groupSeparator()));
+    }
+
+    setProcessingTime(attributes.value("ProcessingTime").toDateTime());
+
+    // No quality will result in PrinterJob using defaultPrintQuality
+    QString quality = attributes.value("quality").toString();
+    for (int i=0; i < m_printer->supportedPrintQualities().length(); i++) {
+        if (m_printer->supportedPrintQualities().at(i).name == quality) {
+            setQuality(i);
+        }
+    }
+
+    setReverse(attributes.value("OutputOrder").toString() == "Reverse");
+    setSize(attributes.value("Size").toInt());
+    setUser(attributes.value("User").toString());
+}
+
 void PrinterJob::loadDefaults()
 {
     if (!m_printer) {
@@ -152,62 +208,17 @@
         return;
     }
 
-    qWarning() << Q_FUNC_INFO << jobId();
-
     if (jobId() > 0) {
-        // Load the extra attributes for the job
-        // NOTE: we don't need to type check them as they have been filtered for us
-
-        QMap<QString, QVariant> attributes = m_backend->printerGetJobAttributes(
-            m_printer->name(), jobId());
-
-        setCollate(attributes.value("Collate").toBool());
-        setCopies(attributes.value("copies").toInt());
-
-        // No colorModel will result in PrinterJob using defaultColorModel
-        QString colorModel = attributes.value("ColorModel").toString();
-        for (int i=0; i < m_printer->supportedColorModels().length(); i++) {
-            if (m_printer->supportedColorModels().at(i).originalOption == colorModel) {
-                setColorModel(i);
-            }
-        }
-
-        // No duplexMode will result in PrinterJob using defaultDuplexMode
-        QString duplex = attributes.value("Duplex").toString();
-        PrinterEnum::DuplexMode duplexMode = Utils::ppdChoiceToDuplexMode(duplex);
-        for (int i=0; i < m_printer->supportedDuplexModes().length(); i++) {
-            if (m_printer->supportedDuplexModes().at(i) == duplexMode) {
-                setDuplexMode(i);
-            }
-        }
-
-        setLandscape(attributes.value("landscape").toBool());
-        setMessages(attributes.value("messages").toStringList());
-
-        QStringList pageRanges = attributes.value("page-ranges").toStringList();
-        if (pageRanges.isEmpty()) {
-            setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
-            setPrintRange(QStringLiteral(""));
-        } else {
-            setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
-            // Use groupSeparator as createSeparatedList adds "and" into the string
-            setPrintRange(pageRanges.join(QLocale::system().groupSeparator()));
-        }
-
-        // No quality will result in PrinterJob using defaultPrintQuality
-        QString quality = attributes.value("quality").toString();
-        for (int i=0; i < m_printer->supportedPrintQualities().length(); i++) {
-            if (m_printer->supportedPrintQualities().at(i).name == quality) {
-                setQuality(i);
-            }
-        }
-
-        setReverse(attributes.value("OutputOrder").toString() == "Reverse");
+        loadAttributes(
+            m_backend->printerGetJobAttributes(
+                printerName(), jobId()
+            )
+        );
+    } else {
+        setColorModel(m_printer->supportedColorModels().indexOf(m_printer->defaultColorModel()));
+        setDuplexMode(m_printer->supportedDuplexModes().indexOf(m_printer->defaultDuplexMode()));
+        setQuality(m_printer->supportedPrintQualities().indexOf(m_printer->defaultPrintQuality()));
     }
-
-    setColorModel(m_printer->supportedColorModels().indexOf(m_printer->defaultColorModel()));
-    setDuplexMode(m_printer->supportedDuplexModes().indexOf(m_printer->defaultDuplexMode()));
-    setQuality(m_printer->supportedPrintQualities().indexOf(m_printer->defaultPrintQuality()));
 }
 
 QStringList PrinterJob::messages() const
@@ -385,7 +396,6 @@
 
         Q_EMIT printerChanged();
    }
-   loadDefaults();
 }
 
 void PrinterJob::setPrintRange(const QString &printRange)
@@ -481,30 +491,44 @@
     // Return true if they are the same
     return collate() == other->collate()
             && colorModel() == other->colorModel()
+            && completedTime() == other->completedTime()
             && copies() == other->copies()
+            && creationTime() == other->creationTime()
             && duplexMode() == other->duplexMode()
+            && impressionsCompleted() == other->impressionsCompleted()
             && landscape() == other->landscape()
+            && messages() == other->messages()
             && printRange() == other->printRange()
             && printRangeMode() == other->printRangeMode()
+            && processingTime() == other->processingTime()
             && quality() == other->quality()
             && reverse() == other->reverse()
+            && size() == other->size()
             && state() == other->state()
-            && title() == other->title();
+            && title() == other->title()
+            && user() == other->user();
 }
 
 void PrinterJob::updateFrom(QSharedPointer<PrinterJob> other)
 {
     setCollate(other->collate());
     setColorModel(other->colorModel());
+    setCompletedTime(other->completedTime());
     setCopies(other->copies());
+    setCreationTime(other->creationTime());
     setDuplexMode(other->duplexMode());
+    setImpressionsCompleted(other->impressionsCompleted());
     setLandscape(other->landscape());
+    setMessages(other->messages());
     setPrintRange(other->printRange());
     setPrintRangeMode(other->printRangeMode());
+    setProcessingTime(other->processingTime());
     setQuality(other->quality());
     setReverse(other->reverse());
+    setSize(other->size());
     setState(other->state());
     setTitle(other->title());
+    setUser(other->user());
 }
 
 QString PrinterJob::user() const

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h'
--- modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-03-10 13:06:04 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-03-16 15:26:32 +0000
@@ -95,6 +95,8 @@
     PrinterEnum::DuplexMode getDuplexMode() const;
     ColorModel getColorModel() const;
     PrintQuality getPrintQuality() const;
+    void loadAttributes(const QMap<QString, QVariant>& attributes);
+    void loadDefaults();
     Q_INVOKABLE void printFile(const QUrl &url);
     void setCollate(const bool collate);
     void setColorModel(const int colorModel);
@@ -119,7 +121,6 @@
 
     void updateFrom(QSharedPointer<PrinterJob> other);
 private Q_SLOTS:
-    void loadDefaults();
     void onPrinterAboutToChange(QSharedPointer<Printer> old,
                                 QSharedPointer<Printer> replacement);
 Q_SIGNALS:

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp	2017-03-09 14:34:05 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp	2017-03-16 15:26:32 +0000
@@ -58,7 +58,12 @@
             const QModelIndex &parent, int first, int) {
         int jobId = m_jobs.data(m_jobs.index(first, 0, parent),
                                 JobModel::Roles::IdRole).toInt();
-        jobAdded(m_jobs.getJobById(jobId));
+        QString printerName = m_jobs.data(
+            m_jobs.index(first, 0, parent),
+            JobModel::Roles::PrinterNameRole
+        ).toString();
+
+        jobAdded(m_jobs.getJob(printerName, jobId));
     });
     connect(&m_model, &QAbstractItemModel::rowsInserted, [this](
             const QModelIndex &parent, int first, int) {
@@ -78,6 +83,17 @@
         );
     }
 
+    // Ensure existing jobs have been added, incase some were added before
+    // the connect to rowsInserted was done
+    for (int i = 0; i < m_jobs.rowCount(); i++) {
+        jobAdded(
+            m_jobs.getJob(
+                m_jobs.data(m_jobs.index(i), JobModel::Roles::PrinterNameRole).toString(),
+                m_jobs.data(m_jobs.index(i), JobModel::IdRole).toInt()
+            )
+        );
+    }
+
     if (m_backend->type() == PrinterEnum::PrinterType::CupsType) {
         ((PrinterCupsBackend*) m_backend)->createSubscription();
     }
@@ -271,8 +287,21 @@
 void Printers::jobAdded(QSharedPointer<PrinterJob> job)
 {
     auto printer = m_model.getPrinterByName(job->printerName());
-    if (printer && job)
-        job->setPrinter(printer);
+
+    // Check if we have a valid printer, does not need to be loaded as JobLoader
+    // creates it's own Backend.
+    if (printer && job) {
+        // TODO: this printer may not be fully loaded
+        // Which has the side affect of colorModel, duplex, quality not working
+        // in PrinterJob as Printer::supportedColorModels etc fail
+        // Potentially trigger loadPrinter and listen for the new printer?
+
+        // Set the printer to the job
+        m_jobs.updateJobPrinter(job, printer);
+
+        // Trigger JobLoader to load extended attributes in the background
+        m_backend->requestJobExtendedAttributes(printer, job);
+    }
 }
 
 void Printers::printerAdded(QSharedPointer<Printer> printer)
@@ -288,10 +317,9 @@
         ).toString();
 
         int jobId = m_jobs.data(idx, JobModel::Roles::IdRole).toInt();
-        auto job = m_jobs.getJobById(jobId);
+        auto job = m_jobs.getJob(printerName, jobId);
         if (printerName == printer->name() && !job->printer()) {
-            job->setPrinter(printer);
-            return;
+            jobAdded(job);
         }
     }
 }

=== modified file 'tests/unittests/Printers/mockbackend.h'
--- tests/unittests/Printers/mockbackend.h	2017-03-10 13:15:27 +0000
+++ tests/unittests/Printers/mockbackend.h	2017-03-16 15:26:32 +0000
@@ -176,36 +176,30 @@
         }
     }
 
-    virtual void holdJob(const QString &name, const int jobId) override
+    virtual void holdJob(const QString &printerName, const int jobId) override
     {
-        for (int i=0; i < m_jobs.count(); i++) {
-            QSharedPointer<PrinterJob> job = m_jobs[i];
-
-            if (job->printerName() == name && job->jobId() == jobId) {
-                auto jobHeld = QSharedPointer<PrinterJob>(new PrinterJob(job->printerName(), this, jobId));
-                jobHeld->setState(PrinterEnum::JobState::Held);
-                m_jobs.replace(0, jobHeld);
-
-                Q_EMIT jobState(job->title(), "", job->printerName(), 1, "", true, job->jobId(), 4, "", "", 1);
-                break;
+        // Change the faked job state
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == printerName
+                    && job->jobId() == jobId) {
+                job->setState(PrinterEnum::JobState::Held);
             }
         }
+
+        Q_EMIT jobState("", "", printerName, 1, "", true, jobId, static_cast<uint>(PrinterEnum::JobState::Held), "", "", 1);
     }
 
-    virtual void releaseJob(const QString &name, const int jobId) override
+    virtual void releaseJob(const QString &printerName, const int jobId) override
     {
-        for (int i=0; i < m_jobs.count(); i++) {
-            QSharedPointer<PrinterJob> job = m_jobs[i];
-
-            if (job->printerName() == name && job->jobId() == jobId) {
-                auto jobRelease = QSharedPointer<PrinterJob>(new PrinterJob(job->printerName(), this, jobId));
-                jobRelease->setState(PrinterEnum::JobState::Pending);
-                m_jobs.replace(0, jobRelease);
-
-                Q_EMIT jobState(job->title(), "", job->printerName(), 1, "", true, job->jobId(), 4, "", "", 1);
-                break;
+        // Change the faked job state
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == printerName
+                    && job->jobId() == jobId) {
+                job->setState(PrinterEnum::JobState::Pending);
             }
         }
+
+        Q_EMIT jobState("", "", printerName, 1, "", true, jobId, static_cast<uint>(PrinterEnum::JobState::Pending), "", "", 1);
     }
 
     virtual int printFileToDest(const QString &filepath,
@@ -229,9 +223,37 @@
     virtual QMap<QString, QVariant> printerGetJobAttributes(
             const QString &name, const int jobId) override
     {
-        Q_UNUSED(name);
-        Q_UNUSED(jobId);
-        return QMap<QString, QVariant>();
+        QMap<QString, QVariant> attributes;
+
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == name
+                    && job->jobId() == jobId) {
+                // Emulate reverse of PrinterJob::loadAttributes
+                // using local jobs defined in tests
+                attributes.insert("Collate", job->collate());
+                attributes.insert("copies", job->copies());
+                attributes.insert("ColorModel", job->getColorModel().name);
+                attributes.insert("CompletedTime", job->completedTime());
+                attributes.insert("CreationTime", job->creationTime());
+                attributes.insert("Duplex", Utils::duplexModeToPpdChoice(job->getDuplexMode()));
+                attributes.insert("landscape", job->landscape());
+                attributes.insert("messages", job->messages());
+                if (job->printRangeMode() == PrinterEnum::PrintRange::AllPages) {
+                    attributes.insert("page-ranges", QStringList());
+                } else {
+                    attributes.insert("page-ranges", job->printRange().split(QLocale::system().groupSeparator()));
+                }
+                attributes.insert("ProcessingTime", job->processingTime());
+                attributes.insert("Quality", job->getPrintQuality().name);
+                attributes.insert("OutputOrder", job->reverse() ? "Reverse" : "Normal");
+                attributes.insert("Size", job->size());
+                attributes.insert("User", job->user());
+
+                break;
+            }
+        }
+
+        return attributes;
     }
 
     virtual QString printerName() const override
@@ -337,6 +359,13 @@
         m_requestedPrinters << printerName;
     }
 
+    virtual void requestJobExtendedAttributes(QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job) override
+    {
+        QMap<QString, QVariant> attributes = printerGetJobAttributes(printer->name(), job->jobId());
+
+        Q_EMIT jobLoaded(printer->name(), job->jobId(), attributes);
+    }
+
     virtual PrinterEnum::PrinterType type() const override
     {
         return m_type;
@@ -393,6 +422,34 @@
         );
     }
 
+    void mockJobCompleted(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+    {
+        Q_EMIT jobCompleted(
+            text, printer_uri, printer_name, printer_state,
+            printer_state_reasons, printer_is_accepting_jobs, job_id,
+            job_state, job_state_reasons, job_name, job_impressions_completed
+        );
+    }
+
+    void mockJobState(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+    {
+        Q_EMIT jobState(
+            text, printer_uri, printer_name, printer_state,
+            printer_state_reasons, printer_is_accepting_jobs, job_id,
+            job_state, job_state_reasons, job_name, job_impressions_completed
+        );
+    }
+
     void mockDriversLoaded(const QList<PrinterDriver> &drivers)
     {
         Q_EMIT printerDriversLoaded(drivers);

=== modified file 'tests/unittests/Printers/tst_jobfilter.cpp'
--- tests/unittests/Printers/tst_jobfilter.cpp	2017-02-21 10:46:29 +0000
+++ tests/unittests/Printers/tst_jobfilter.cpp	2017-03-16 15:26:32 +0000
@@ -32,10 +32,12 @@
         QScopedPointer<MockPrinterBackend> backend(new MockPrinterBackend);
         JobModel model(backend.data());
 
-        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend.data()));
+        auto job = QSharedPointer<PrinterJob>(
+            new PrinterJob("test-printer", backend.data(), 100)
+        );
         backend->m_jobs << job;
         // Trigger update.
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 100, 3, "", "", 1);
 
         JobFilter filter;
         filter.setSourceModel(&model);

=== modified file 'tests/unittests/Printers/tst_jobmodel.cpp'
--- tests/unittests/Printers/tst_jobmodel.cpp	2017-03-06 11:44:11 +0000
+++ tests/unittests/Printers/tst_jobmodel.cpp	2017-03-16 15:26:32 +0000
@@ -18,12 +18,14 @@
 
 #include "backend/backend.h"
 #include "models/jobmodel.h"
+#include "printers/printers.h"
 
 #include <QDebug>
 #include <QObject>
 #include <QSignalSpy>
 #include <QTest>
 
+
 class TestJobModel : public QObject
 {
     Q_OBJECT
@@ -31,14 +33,19 @@
     void init()
     {
         m_backend = new MockPrinterBackend;
-        m_model = new JobModel(m_backend);
+        m_printers = new Printers(m_backend);
+
+        m_model = static_cast<JobModel *>(m_printers->printJobs());
+
+        PrinterBackend* backend = new MockPrinterBackend("test-printer");
+        auto printer = QSharedPointer<Printer>(new Printer(backend));
+        m_backend->mockPrinterLoaded(printer);
     }
     void cleanup()
     {
-        QSignalSpy destroyedSpy(m_model, SIGNAL(destroyed(QObject*)));
-        m_model->deleteLater();
+        QSignalSpy destroyedSpy(m_printers, SIGNAL(destroyed(QObject*)));
+        m_printers->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
-        delete m_backend;
     }
 
     // Tests for adding/removing/changing things in the model
@@ -71,7 +78,7 @@
         catchall handler in the model. */
         QSignalSpy removeSpy(m_model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)));
         m_backend->m_jobs.clear();
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCompleted("", "", "", 1, "", true, 100, 1, "", "", 1);
         QCOMPARE(removeSpy.count(), 1);
 
         // Check item was removed
@@ -79,38 +86,20 @@
         QCOMPARE(args.at(1).toInt(), 0);
         QCOMPARE(args.at(2).toInt(), 0);
     }
-    void testMove()
-    {
-        // Add two jobs.
-        auto job1 = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
-        auto job2 = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
-        m_backend->m_jobs << job1 << job2;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-
-        m_backend->m_jobs.move(0, 1);
-        // Triggers a move.
-        QSignalSpy moveSpy(m_model, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-        QCOMPARE(moveSpy.count(), 1);
-        QList<QVariant> args = moveSpy.at(0);
-        QCOMPARE(args.at(1).toInt(), 1);
-        QCOMPARE(args.at(2).toInt(), 1);
-        QCOMPARE(args.at(4).toInt(), 0);
-    }
     void testModify()
     {
         auto jobBefore = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        int impressions_count = 1;
 
         m_backend->m_jobs << jobBefore;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-
-        auto jobAfter = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
-        jobAfter->setCopies(100);
-        m_backend->m_jobs.replace(0, jobAfter);
+        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", impressions_count);
 
         // Triggers a change.
         QSignalSpy changedSpy(m_model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)));
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+
+        impressions_count = 5;
+        m_backend->mockJobState("", "", "", 1, "", true, 100, 1, "", "", impressions_count);
+
         QCOMPARE(changedSpy.count(), 1);
     }
 
@@ -135,14 +124,19 @@
         jobB->setCollate(true);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
+
         QCOMPARE(m_model->data(m_model->index(0), JobModel::CollateRole).toBool(), false);
         QCOMPARE(m_model->data(m_model->index(1), JobModel::CollateRole).toBool(), true);
     }
     void testColorModelRole()
     {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring colorModel for now as it requires a loaded Printer for the PrinterJob.");
+
         ColorModel a;
         a.name = "KGray";
         a.text = "Gray";
@@ -159,17 +153,21 @@
 
         auto printer = QSharedPointer<Printer>(new Printer(backend));
         m_backend->mockPrinterLoaded(printer);
+//        m_printers->m_printers << printer;
 
         auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 1));
         jobA->setPrinter(printer);
+        jobA->loadDefaults();
         jobA->setColorModel(models.indexOf(a));
 
         auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 2));
         jobB->setPrinter(printer);
+        jobB->loadDefaults();
         jobB->setColorModel(models.indexOf(b));
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::ColorModelRole).toString(),
@@ -189,7 +187,8 @@
         jobB->setCompletedTime(dateTimeB);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::CompletedTimeRole).toDateTime(),
@@ -206,7 +205,8 @@
         jobB->setCopies(5);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::CopiesRole).toInt(), 2);
@@ -224,7 +224,8 @@
         jobB->setCreationTime(dateTimeB);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::CreationTimeRole).toDateTime(),
@@ -234,6 +235,9 @@
     }
     void testDuplexRole()
     {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring duplex for now as it requires a loaded Printer for the PrinterJob.");
+
         QList<PrinterEnum::DuplexMode> modes({
             PrinterEnum::DuplexMode::DuplexNone,
             PrinterEnum::DuplexMode::DuplexLongSide,
@@ -257,7 +261,8 @@
         jobB->setDuplexMode(modes.indexOf(PrinterEnum::DuplexMode::DuplexNone));
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::DuplexRole).toString(),
@@ -274,7 +279,8 @@
         jobB->setState(PrinterEnum::JobState::Held);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, static_cast<uint>(jobA->state()), "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, static_cast<uint>(jobB->state()), "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::HeldRole).toBool(), false);
@@ -289,7 +295,8 @@
         jobB->setImpressionsCompleted(5);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", jobA->impressionsCompleted());
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", jobB->impressionsCompleted());
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::ImpressionsCompletedRole).toInt(), 2);
@@ -304,7 +311,8 @@
         jobB->setLandscape(true);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::LandscapeRole).toBool(), false);
@@ -312,14 +320,15 @@
     }
     void testMessagesRole()
     {
-        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", m_backend, 1));
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
         jobA->setMessages(QStringList() << "a-message" << "b-message");
 
-        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("b-printer", m_backend, 2));
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
         jobB->setMessages(QStringList() << "c-message" << "d-message");
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::MessagesRole).toStringList(),
@@ -334,7 +343,8 @@
         auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("b-printer", m_backend, 2));
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "b-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::PrinterNameRole).toString(), QString("a-printer"));
@@ -344,12 +354,15 @@
     {
         auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
         jobA->setPrintRange("1-3,5");
+        jobA->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
 
         auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
         jobB->setPrintRange("-3,6,10-");
+        jobB->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::PrintRangeRole).toString(), QString("1-3,5"));
@@ -361,10 +374,12 @@
         jobA->setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
 
         auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setPrintRange("1-3");
         jobB->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::PrintRangeModeRole).value<PrinterEnum::PrintRange>(), PrinterEnum::PrintRange::AllPages);
@@ -382,7 +397,8 @@
         jobB->setProcessingTime(dateTimeB);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::ProcessingTimeRole).toDateTime(),
@@ -392,6 +408,9 @@
     }
     void testQualityRole()
     {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring quality for now as it requires a loaded Printer for the PrinterJob.");
+
         PrintQuality a;
         a.name = "fast-draft";
         a.text = "Draft";
@@ -418,7 +437,8 @@
         jobB->setQuality(qualities.indexOf(b));
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::QualityRole).toString(),
@@ -435,7 +455,8 @@
         jobB->setReverse(true);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::ReverseRole).toBool(), false);
@@ -450,7 +471,8 @@
         jobB->setSize(64);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::SizeRole).toInt(), 32);
@@ -465,7 +487,8 @@
         jobB->setState(PrinterEnum::JobState::Processing);
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, static_cast<uint>(jobA->state()), "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, static_cast<uint>(jobB->state()), "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::StateRole).value<PrinterEnum::JobState>(), PrinterEnum::JobState::Pending);
@@ -480,7 +503,8 @@
         jobB->setTitle("b-job");
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", jobA->title(), 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", jobB->title(), 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::TitleRole).toString(), QString("a-job"));
@@ -495,7 +519,8 @@
         jobB->setUser("b-user");
 
         m_backend->m_jobs << jobA << jobB;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
 
         QTRY_COMPARE(m_model->count(), 2);
         QCOMPARE(m_model->data(m_model->index(0), JobModel::UserRole).toString(), QString("a-user"));
@@ -505,6 +530,7 @@
 private:
     MockPrinterBackend *m_backend;
     JobModel *m_model;
+    Printers *m_printers;
 };
 
 QTEST_GUILESS_MAIN(TestJobModel)

=== modified file 'tests/unittests/Printers/tst_printerjob.cpp'
--- tests/unittests/Printers/tst_printerjob.cpp	2017-03-14 12:01:48 +0000
+++ tests/unittests/Printers/tst_printerjob.cpp	2017-03-16 15:26:32 +0000
@@ -39,6 +39,7 @@
         m_mock_printer = QSharedPointer<Printer>(new Printer(m_backend));
         m_instance = new PrinterJob(m_printer_name, m_backend);
         m_instance->setPrinter(m_mock_printer);
+        m_instance->loadDefaults();
     }
     void cleanup()
     {
@@ -60,6 +61,7 @@
 
         m_instance = new PrinterJob(m_printer_name, m_backend);
         m_instance->setPrinter(m_mock_printer);
+        m_instance->loadDefaults();
     }
     void refreshInstanceWithBackend(MockPrinterBackend *backend)
     {

=== modified file 'tests/unittests/Printers/tst_printers.cpp'
--- tests/unittests/Printers/tst_printers.cpp	2017-03-02 14:19:56 +0000
+++ tests/unittests/Printers/tst_printers.cpp	2017-03-16 15:26:32 +0000
@@ -120,9 +120,9 @@
         Printers p(backend);
 
         // Add one.
-        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend));
+        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
         backend->m_jobs << job;
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
 
         // Check it was added
         QCOMPARE(model->count(), 1);
@@ -147,13 +147,13 @@
         Printers p(backend);
 
         // Add one.
-        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend));
+        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
         backend->m_jobs << job;
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, static_cast<uint>(PrinterEnum::JobState::Pending), "", "", 1);
 
         // Check it was added
         QCOMPARE(model->count(), 1);
-        QCOMPARE(job->state(), PrinterEnum::JobState::Pending);
+        QCOMPARE(model->getJob("test-printer", 1)->state(), PrinterEnum::JobState::Pending);
 
         // Setup the spy
         QSignalSpy dataChangedSpy(model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)));
@@ -163,7 +163,7 @@
 
         // Check item was removed
         QTRY_COMPARE(dataChangedSpy.count(), 1);
-        QCOMPARE(job->state(), PrinterEnum::JobState::Held);
+        QCOMPARE(model->getJob("test-printer", 1)->state(), PrinterEnum::JobState::Held);
     }
     void testReleaseJob()
     {
@@ -172,15 +172,15 @@
         Printers p(backend);
 
         // Add one.
-        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend));
+        QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
         backend->m_jobs << job;
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
 
         p.holdJob(job->printerName(), job->jobId());
 
         // Check it was added and is in held state
         QCOMPARE(model->count(), 1);
-        QCOMPARE(job->state(), PrinterEnum::JobState::Held);
+        QCOMPARE(model->getJob("test-printer", 1)->state(), PrinterEnum::JobState::Held);
 
         // Setup the spy
         QSignalSpy dataChangedSpy(model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)));
@@ -190,7 +190,7 @@
 
         // Check item was removed
         QTRY_COMPARE(dataChangedSpy.count(), 1);
-        QCOMPARE(job->state(), PrinterEnum::JobState::Pending);
+        QCOMPARE(model->getJob("test-printer", 1)->state(), PrinterEnum::JobState::Pending);
     }
     void testPrinterRemove()
     {
@@ -252,23 +252,31 @@
         auto printer = QSharedPointer<Printer>(new Printer(printerBackend));
         backend->mockPrinterLoaded(printer);
 
-        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend));
+        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
         backend->m_jobs << job;
 
+        // Setup the spy
+        QSignalSpy jobLoadedSpy(backend, SIGNAL(jobLoaded(QString, int, QMap<QString, QVariant>)));
+
         // Trigger update.
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+
+        QTRY_COMPARE(jobLoadedSpy.count(), 1);
 
         // Job now has a shared pointer to printer.
-        QCOMPARE(job->printer()->name(), printer->name());
+        JobModel *model = static_cast<JobModel *>(p.printJobs());
+
+        QCOMPARE(model->getJob(printer->name(), job->jobId())->printer(), printer);
+        QCOMPARE(model->getJob(printer->name(), job->jobId())->printer()->name(), printer->name());
     }
     void testSetPrinterJobFilter()
     {
         MockPrinterBackend *backend = new MockPrinterBackend;
         Printers p(backend);
 
-        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend));
+        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
         backend->m_jobs << job;
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
 
         MockPrinterBackend *printerBackend = new MockPrinterBackend("test-printer");
         auto printer = QSharedPointer<Printer>(new Printer(printerBackend));