matrixion/src/ui/UserProfile.cpp

311 lines
9.8 KiB
C++
Raw Normal View History

2020-05-17 16:34:47 +03:00
#include "UserProfile.h"
#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"
#include "timeline/TimelineViewManager.h"
#include <mtx/responses.hpp>
2021-01-28 21:45:40 +03:00
#include <mtx/responses/common.hpp>
2020-05-17 16:34:47 +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)
, manager(manager_)
2020-08-09 06:05:15 +03:00
, model(parent)
2020-07-04 05:24:28 +03:00
{
fetchDeviceList(this->userid_);
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_);
});
connect(this,
&UserProfile::globalUsernameRetrieved,
this,
&UserProfile::setGlobalUsername,
Qt::QueuedConnection);
http::client()->get_profile(
userid_.toStdString(),
[this](const mtx::responses::Profile &res, mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("failed to retrieve own profile info");
return;
}
emit globalUsernameRetrieved(QString::fromStdString(res.display_name));
});
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
{
return globalUserProfile() ? globalUsername : cache::displayName(roomid_, userid_);
2020-07-04 05:24:28 +03:00
}
QString
UserProfile::avatarUrl()
{
return cache::avatarUrl(roomid_, userid_);
2020-05-22 08:47:02 +03:00
}
bool
UserProfile::globalUserProfile() const
{
return (roomid_ == "") && isSelf();
}
2020-07-17 23:16:30 +03:00
bool
UserProfile::getUserStatus()
{
return isUserVerified;
}
bool
UserProfile::userVerificationEnabled() const
{
return hasMasterKey;
}
bool
UserProfile::isSelf() const
{
return this->userid_ == utils::localUser();
}
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(
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;
}
// Ensure local key cache is up to date
2020-10-27 19:45:28 +03:00
cache::client()->query_keys(
utils::localUser().toStdString(),
[other_user_id, other_user_keys, this](const UserKeyCache &,
mtx::http::RequestErr err) {
2020-08-24 11:26:50 +03:00
using namespace mtx;
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;
}
this->hasMasterKey = !other_user_keys.master_keys.keys.empty();
std::vector<DeviceInfo> deviceInfo;
auto devices = other_user_keys.device_keys;
auto verificationStatus =
cache::client()->verificationStatus(other_user_id);
isUserVerified = verificationStatus.user_verified;
emit userStatusChanged();
2020-08-24 11:26:50 +03:00
for (const auto &d : devices) {
auto device = d.second;
verification::Status verified =
verification::Status::UNVERIFIED;
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;
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()
{
ChatPage::instance()->startChat(this->userid_);
2020-07-17 23:16:30 +03:00
}
void
UserProfile::changeUsername(QString username)
{
if (globalUserProfile()) {
// change global
http::client()->set_displayname(
2021-01-28 21:23:56 +03:00
username.toStdString(), [this](mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("could not change username");
return;
}
});
} else {
// change room username
mtx::events::state::Member member;
member.display_name = username.toStdString();
member.avatar_url =
cache::avatarUrl(roomid_,
QString::fromStdString(http::client()->user_id().to_string()))
.toStdString();
member.membership = mtx::events::state::Membership::Join;
http::client()->send_state_event(
roomid_.toStdString(),
http::client()->user_id().to_string(),
member,
[](mtx::responses::EventId, mtx::http::RequestErr err) {
if (err)
nhlog::net()->error("Failed to set room displayname: {}",
err->matrix_error.error);
});
}
allowUsernameEditing(false);
}
void
UserProfile::verify(QString device)
2020-07-17 23:16:30 +03:00
{
if (!device.isEmpty())
manager->verifyDevice(userid_, device);
2020-08-09 06:05:15 +03:00
else {
manager->verifyUser(userid_);
2020-08-09 06:05:15 +03:00
}
2020-08-30 20:33:10 +03:00
}
void
UserProfile::unverify(QString device)
{
cache::markDeviceUnverified(userid_.toStdString(), device.toStdString());
}
void
UserProfile::allowUsernameEditing(bool allow)
{
usernameEditing = allow;
emit usernameEditingChanged();
}
bool
UserProfile::isUsernameEditingAllowed() const
{
return usernameEditing;
}
void
2021-01-28 21:45:40 +03:00
UserProfile::setGlobalUsername(const QString &globalUser)
{
globalUsername = globalUser;
emit displayNameChanged();
}