2020-05-17 16:34:47 +03:00
|
|
|
#include "UserProfile.h"
|
2020-10-08 00:03:14 +03:00
|
|
|
#include "Cache_p.h"
|
2020-06-26 01:54:42 +03:00
|
|
|
#include "ChatPage.h"
|
2020-07-05 19:03:27 +03:00
|
|
|
#include "DeviceVerificationFlow.h"
|
2020-05-17 16:34:47 +03:00
|
|
|
#include "Logging.h"
|
|
|
|
#include "Utils.h"
|
2020-05-22 08:47:02 +03:00
|
|
|
#include "mtx/responses/crypto.hpp"
|
2020-08-09 06:05:15 +03:00
|
|
|
#include "timeline/TimelineModel.h"
|
2020-10-05 23:12:10 +03:00
|
|
|
#include "timeline/TimelineViewManager.h"
|
2020-05-17 16:34:47 +03:00
|
|
|
|
2020-10-05 23:12:10 +03:00
|
|
|
UserProfile::UserProfile(QString roomid,
|
|
|
|
QString userid,
|
|
|
|
TimelineViewManager *manager_,
|
|
|
|
TimelineModel *parent)
|
2020-07-04 05:24:28 +03:00
|
|
|
: QObject(parent)
|
|
|
|
, roomid_(roomid)
|
|
|
|
, userid_(userid)
|
2020-10-05 23:12:10 +03:00
|
|
|
, manager(manager_)
|
2020-08-09 06:05:15 +03:00
|
|
|
, model(parent)
|
2020-07-04 05:24:28 +03:00
|
|
|
{
|
|
|
|
fetchDeviceList(this->userid_);
|
2020-10-08 00:03:14 +03:00
|
|
|
|
|
|
|
connect(cache::client(),
|
|
|
|
&Cache::verificationStatusChanged,
|
|
|
|
this,
|
|
|
|
[this](const std::string &user_id) {
|
|
|
|
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_);
|
|
|
|
});
|
2020-07-04 05:24:28 +03:00
|
|
|
}
|
2020-06-28 18:31:34 +03:00
|
|
|
|
2020-07-04 05:24:28 +03:00
|
|
|
QHash<int, QByteArray>
|
|
|
|
DeviceInfoModel::roleNames() const
|
|
|
|
{
|
|
|
|
return {
|
|
|
|
{DeviceId, "deviceId"},
|
|
|
|
{DeviceName, "deviceName"},
|
|
|
|
{VerificationStatus, "verificationStatus"},
|
|
|
|
};
|
|
|
|
}
|
2020-07-01 15:17:10 +03:00
|
|
|
|
2020-07-04 05:24:28 +03:00
|
|
|
QVariant
|
|
|
|
DeviceInfoModel::data(const QModelIndex &index, int role) const
|
2020-07-01 15:17:10 +03:00
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
if (!index.isValid() || index.row() >= (int)deviceList_.size() || index.row() < 0)
|
|
|
|
return {};
|
|
|
|
|
|
|
|
switch (role) {
|
|
|
|
case DeviceId:
|
|
|
|
return deviceList_[index.row()].device_id;
|
|
|
|
case DeviceName:
|
|
|
|
return deviceList_[index.row()].display_name;
|
|
|
|
case VerificationStatus:
|
|
|
|
return QVariant::fromValue(deviceList_[index.row()].verification_status);
|
|
|
|
default:
|
|
|
|
return {};
|
|
|
|
}
|
2020-07-01 15:17:10 +03:00
|
|
|
}
|
2020-05-17 16:34:47 +03:00
|
|
|
|
2020-07-04 05:24:28 +03:00
|
|
|
void
|
|
|
|
DeviceInfoModel::reset(const std::vector<DeviceInfo> &deviceList)
|
2020-05-27 11:49:26 +03:00
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
beginResetModel();
|
|
|
|
this->deviceList_ = std::move(deviceList);
|
|
|
|
endResetModel();
|
|
|
|
}
|
|
|
|
|
|
|
|
DeviceInfoModel *
|
|
|
|
UserProfile::deviceList()
|
|
|
|
{
|
|
|
|
return &this->deviceList_;
|
2020-05-17 16:34:47 +03:00
|
|
|
}
|
|
|
|
|
2020-05-22 08:47:02 +03:00
|
|
|
QString
|
2020-07-04 05:24:28 +03:00
|
|
|
UserProfile::userid()
|
2020-05-27 11:49:26 +03:00
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
return this->userid_;
|
2020-05-22 08:47:02 +03:00
|
|
|
}
|
|
|
|
|
2020-07-04 05:24:28 +03:00
|
|
|
QString
|
|
|
|
UserProfile::displayName()
|
2020-05-27 11:49:26 +03:00
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
return cache::displayName(roomid_, userid_);
|
|
|
|
}
|
|
|
|
|
|
|
|
QString
|
|
|
|
UserProfile::avatarUrl()
|
|
|
|
{
|
|
|
|
return cache::avatarUrl(roomid_, userid_);
|
2020-05-22 08:47:02 +03:00
|
|
|
}
|
|
|
|
|
2020-07-17 23:16:30 +03:00
|
|
|
bool
|
|
|
|
UserProfile::getUserStatus()
|
|
|
|
{
|
|
|
|
return isUserVerified;
|
|
|
|
}
|
|
|
|
|
2020-06-28 18:31:34 +03:00
|
|
|
void
|
|
|
|
UserProfile::fetchDeviceList(const QString &userID)
|
|
|
|
{
|
2020-08-24 11:26:50 +03:00
|
|
|
auto localUser = utils::localUser();
|
|
|
|
|
2020-10-27 19:45:28 +03:00
|
|
|
cache::client()->query_keys(
|
2020-10-02 02:14:42 +03:00
|
|
|
userID.toStdString(),
|
|
|
|
[other_user_id = userID.toStdString(), this](const UserKeyCache &other_user_keys,
|
|
|
|
mtx::http::RequestErr err) {
|
2020-08-24 11:26:50 +03:00
|
|
|
if (err) {
|
|
|
|
nhlog::net()->warn("failed to query device keys: {},{}",
|
|
|
|
err->matrix_error.errcode,
|
|
|
|
static_cast<int>(err->status_code));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finding if the User is Verified or not based on the Signatures
|
2020-10-27 19:45:28 +03:00
|
|
|
cache::client()->query_keys(
|
2020-10-02 02:14:42 +03:00
|
|
|
utils::localUser().toStdString(),
|
|
|
|
[other_user_id, other_user_keys, this](const UserKeyCache &res,
|
|
|
|
mtx::http::RequestErr err) {
|
2020-08-24 11:26:50 +03:00
|
|
|
using namespace mtx;
|
2020-08-25 13:11:27 +03:00
|
|
|
std::string local_user_id = utils::localUser().toStdString();
|
2020-08-24 11:26:50 +03:00
|
|
|
|
|
|
|
if (err) {
|
|
|
|
nhlog::net()->warn("failed to query device keys: {},{}",
|
|
|
|
err->matrix_error.errcode,
|
|
|
|
static_cast<int>(err->status_code));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-10-02 02:14:42 +03:00
|
|
|
if (res.device_keys.empty()) {
|
|
|
|
nhlog::net()->warn("no devices retrieved {}", local_user_id);
|
2020-08-25 13:11:27 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<DeviceInfo> deviceInfo;
|
2020-10-08 00:03:14 +03:00
|
|
|
auto devices = other_user_keys.device_keys;
|
|
|
|
auto verificationStatus =
|
|
|
|
cache::client()->verificationStatus(other_user_id);
|
2020-08-25 13:11:27 +03:00
|
|
|
|
2020-10-08 00:03:14 +03:00
|
|
|
isUserVerified = verificationStatus.user_verified;
|
|
|
|
emit userStatusChanged();
|
2020-08-24 11:26:50 +03:00
|
|
|
|
2020-08-25 13:11:27 +03:00
|
|
|
for (const auto &d : devices) {
|
|
|
|
auto device = d.second;
|
|
|
|
verification::Status verified =
|
|
|
|
verification::Status::UNVERIFIED;
|
|
|
|
|
2020-10-08 00:03:14 +03:00
|
|
|
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;
|
2020-08-25 13:11:27 +03:00
|
|
|
|
|
|
|
deviceInfo.push_back(
|
|
|
|
{QString::fromStdString(d.first),
|
|
|
|
QString::fromStdString(
|
|
|
|
device.unsigned_info.device_display_name),
|
|
|
|
verified});
|
|
|
|
}
|
|
|
|
|
|
|
|
this->deviceList_.queueReset(std::move(deviceInfo));
|
|
|
|
});
|
2020-08-24 11:26:50 +03:00
|
|
|
});
|
2020-05-17 16:34:47 +03:00
|
|
|
}
|
2020-05-27 11:49:26 +03:00
|
|
|
|
2020-06-26 01:54:42 +03:00
|
|
|
void
|
|
|
|
UserProfile::banUser()
|
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
ChatPage::instance()->banUser(this->userid_, "");
|
2020-06-26 01:54:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// void ignoreUser(){
|
|
|
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
void
|
|
|
|
UserProfile::kickUser()
|
|
|
|
{
|
2020-07-04 05:24:28 +03:00
|
|
|
ChatPage::instance()->kickUser(this->userid_, "");
|
2020-06-26 01:54:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UserProfile::startChat()
|
|
|
|
{
|
|
|
|
mtx::requests::CreateRoom req;
|
|
|
|
req.preset = mtx::requests::Preset::PrivateChat;
|
|
|
|
req.visibility = mtx::requests::Visibility::Private;
|
2020-07-04 05:24:28 +03:00
|
|
|
if (utils::localUser() != this->userid_)
|
|
|
|
req.invite = {this->userid_.toStdString()};
|
2020-06-26 01:54:42 +03:00
|
|
|
emit ChatPage::instance()->createRoom(req);
|
2020-07-17 23:16:30 +03:00
|
|
|
}
|
|
|
|
|
2020-10-05 23:12:10 +03:00
|
|
|
void
|
|
|
|
UserProfile::verify(QString device)
|
2020-07-17 23:16:30 +03:00
|
|
|
{
|
2020-10-05 23:12:10 +03:00
|
|
|
if (!device.isEmpty())
|
|
|
|
manager->verifyDevice(userid_, device);
|
2020-08-09 06:05:15 +03:00
|
|
|
else {
|
2020-10-05 23:12:10 +03:00
|
|
|
manager->verifyUser(userid_);
|
2020-08-09 06:05:15 +03:00
|
|
|
}
|
2020-08-30 20:33:10 +03:00
|
|
|
}
|
2020-10-05 23:12:10 +03:00
|
|
|
|
|
|
|
void
|
|
|
|
UserProfile::unverify(QString device)
|
|
|
|
{
|
|
|
|
cache::markDeviceUnverified(userid_.toStdString(), device.toStdString());
|
|
|
|
}
|