Merge pull request #752 from Thulinma/devicelistEdits

Added support for refreshing the device list & marking current device with a checkmark instead of a lock

1 files changed, 53 insertions, 45 deletions

diff --git a/src/ui/UserProfile.cpp b/src/ui/UserProfile.cpp

index 58150ed7..31ae9f8b 100644
--- a/src/ui/UserProfile.cpp
+++ b/src/ui/UserProfile.cpp
@@ -34,6 +34,7 @@ UserProfile::UserProfile(QString roomid,
             this,
             &UserProfile::setGlobalUsername,
             Qt::QueuedConnection);
+    connect(this, &UserProfile::verificationStatiChanged, &UserProfile::updateVerificationStatus);
 
     if (isGlobalUserProfile()) {
         getGlobalProfileData();
@@ -48,22 +49,7 @@ UserProfile::UserProfile(QString roomid,
           if (user_id != this->userid_.toStdString())
               return;
 
-          auto status = cache::verificationStatus(user_id);
-          if (!status)
-              return;
-          this->isUserVerified = status->user_verified;
-          emit userStatusChanged();
-
-          for (auto &deviceInfo : deviceList_.deviceList_) {
-              deviceInfo.verification_status =
-                std::find(status->verified_devices.begin(),
-                          status->verified_devices.end(),
-                          deviceInfo.device_id.toStdString()) == status->verified_devices.end()
-                  ? verification::UNVERIFIED
-                  : verification::VERIFIED;
-          }
-          deviceList_.reset(deviceList_.deviceList_);
-          emit devicesChanged();
+          emit verificationStatiChanged();
       });
     fetchDeviceList(this->userid_);
 }
@@ -152,6 +138,13 @@ UserProfile::isSelf() const
 }
 
 void
+UserProfile::refreshDevices()
+{
+    cache::client()->markUserKeysOutOfDate({this->userid_.toStdString()});
+    fetchDeviceList(this->userid_);
+}
+
+void
 UserProfile::fetchDeviceList(const QString &userID)
 {
     auto localUser = utils::localUser();
@@ -161,20 +154,18 @@ UserProfile::fetchDeviceList(const QString &userID)
 
     cache::client()->query_keys(
       userID.toStdString(),
-      [other_user_id = userID.toStdString(), this](const UserKeyCache &other_user_keys,
+      [other_user_id = userID.toStdString(), this](const UserKeyCache &,
                                                    mtx::http::RequestErr err) {
           if (err) {
               nhlog::net()->warn("failed to query device keys: {},{}",
                                  mtx::errors::to_string(err->matrix_error.errcode),
                                  static_cast<int>(err->status_code));
-              return;
           }
 
           // Ensure local key cache is up to date
           cache::client()->query_keys(
             utils::localUser().toStdString(),
-            [other_user_id, other_user_keys, this](const UserKeyCache &,
-                                                   mtx::http::RequestErr err) {
+            [this](const UserKeyCache &, mtx::http::RequestErr err) {
                 using namespace mtx;
                 std::string local_user_id = utils::localUser().toStdString();
 
@@ -182,39 +173,56 @@ UserProfile::fetchDeviceList(const QString &userID)
                     nhlog::net()->warn("failed to query device keys: {},{}",
                                        mtx::errors::to_string(err->matrix_error.errcode),
                                        static_cast<int>(err->status_code));
-                    return;
                 }
 
-                this->hasMasterKey = !other_user_keys.master_keys.keys.empty();
+                emit verificationStatiChanged();
+            });
+      });
+}
+
+void
+UserProfile::updateVerificationStatus()
+{
+    if (!cache::client() || !cache::client()->isDatabaseReady())
+        return;
 
-                std::vector<DeviceInfo> deviceInfo;
-                auto devices            = other_user_keys.device_keys;
-                auto verificationStatus = cache::client()->verificationStatus(other_user_id);
+    auto user_keys = cache::client()->userKeys(userid_.toStdString());
+    if (!user_keys) {
+        this->hasMasterKey   = false;
+        this->isUserVerified = crypto::Trust::Unverified;
+        this->deviceList_.reset({});
+        emit userStatusChanged();
+        return;
+    }
 
-                isUserVerified = verificationStatus.user_verified;
-                emit userStatusChanged();
+    this->hasMasterKey = !user_keys->master_keys.keys.empty();
 
-                for (const auto &d : devices) {
-                    auto device                   = d.second;
-                    verification::Status verified = verification::Status::UNVERIFIED;
+    std::vector<DeviceInfo> deviceInfo;
+    auto devices            = user_keys->device_keys;
+    auto verificationStatus = cache::client()->verificationStatus(userid_.toStdString());
 
-                    if (std::find(verificationStatus.verified_devices.begin(),
-                                  verificationStatus.verified_devices.end(),
-                                  device.device_id) != verificationStatus.verified_devices.end() &&
-                        mtx::crypto::verify_identity_signature(
-                          device, DeviceId(device.device_id), UserId(other_user_id)))
-                        verified = verification::Status::VERIFIED;
+    this->isUserVerified = verificationStatus.user_verified;
+    emit userStatusChanged();
 
-                    deviceInfo.push_back(
-                      {QString::fromStdString(d.first),
-                       QString::fromStdString(device.unsigned_info.device_display_name),
-                       verified});
-                }
+    for (const auto &d : devices) {
+        auto device = d.second;
+        verification::Status verified =
+          std::find(verificationStatus.verified_devices.begin(),
+                    verificationStatus.verified_devices.end(),
+                    device.device_id) == verificationStatus.verified_devices.end()
+            ? verification::UNVERIFIED
+            : verification::VERIFIED;
 
-                this->deviceList_.queueReset(std::move(deviceInfo));
-                emit devicesChanged();
-            });
-      });
+        if (isSelf() && device.device_id == ::http::client()->device_id())
+            verified = verification::Status::SELF;
+
+        deviceInfo.push_back({QString::fromStdString(d.first),
+                              QString::fromStdString(device.unsigned_info.device_display_name),
+                              verified});
+    }
+
+    this->deviceList_.queueReset(std::move(deviceInfo));
+    emit devicesChanged();
 }
 
 void