tdesktop/Telegram/SourceFiles/api/api_user_names.cpp

243 lines
6.4 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "api/api_user_names.h"
#include "apiwrap.h"
#include "data/data_channel.h"
#include "data/data_peer.h"
#include "data/data_user.h"
#include "main/main_session.h"
namespace Api {
namespace {
[[nodiscard]] Data::Username UsernameFromTL(const MTPUsername &username) {
return {
.username = qs(username.data().vusername()),
.active = username.data().is_active(),
.editable = username.data().is_editable(),
};
}
} // namespace
Usernames::Usernames(not_null<ApiWrap*> api)
: _session(&api->session())
, _api(&api->instance()) {
}
rpl::producer<Data::Usernames> Usernames::loadUsernames(
not_null<PeerData*> peer) const {
return [=](auto consumer) {
auto lifetime = rpl::lifetime();
const auto push = [consumer](
const auto &usernames,
const auto &username) {
if (usernames) {
if (usernames->v.empty()) {
// Probably will never happen.
consumer.put_next({});
} else {
auto parsed = FromTL(*usernames);
if ((parsed.size() == 1)
&& username
&& (parsed.front().username == qs(*username))) {
// Probably will never happen.
consumer.put_next({});
} else {
consumer.put_next(std::move(parsed));
}
}
} else {
consumer.put_next({});
}
};
const auto requestUser = [&](const MTPInputUser &data) {
_session->api().request(MTPusers_GetUsers(
MTP_vector<MTPInputUser>(1, data)
)).done([=](const MTPVector<MTPUser> &result) {
result.v.front().match([&](const MTPDuser &data) {
push(data.vusernames(), data.vusername());
consumer.put_done();
}, [&](const MTPDuserEmpty&) {
consumer.put_next({});
consumer.put_done();
});
}).send();
};
const auto requestChannel = [&](const MTPInputChannel &data) {
_session->api().request(MTPchannels_GetChannels(
MTP_vector<MTPInputChannel>(1, data)
)).done([=](const MTPmessages_Chats &result) {
result.match([&](const auto &data) {
data.vchats().v.front().match([&](const MTPDchannel &c) {
push(c.vusernames(), c.vusername());
consumer.put_done();
}, [&](auto &&) {
consumer.put_next({});
consumer.put_done();
});
});
}).send();
};
if (peer->isSelf()) {
requestUser(MTP_inputUserSelf());
} else if (const auto user = peer->asUser()) {
requestUser(user->inputUser);
} else if (const auto channel = peer->asChannel()) {
requestChannel(channel->inputChannel);
}
return lifetime;
};
}
rpl::producer<rpl::no_value, Usernames::Error> Usernames::toggle(
not_null<PeerData*> peer,
const QString &username,
bool active) {
const auto peerId = peer->id;
const auto it = _toggleRequests.find(peerId);
const auto found = (it != end(_toggleRequests));
auto &entry = (!found
? _toggleRequests.emplace(
peerId,
Entry{ .usernames = { username } }).first
: it)->second;
if (ranges::contains(entry.usernames, username)) {
if (found) {
return entry.done.events();
}
} else {
entry.usernames.push_back(username);
}
const auto pop = [=](Error error) {
const auto it = _toggleRequests.find(peerId);
if (it != end(_toggleRequests)) {
auto &list = it->second.usernames;
list.erase(ranges::remove(list, username), end(list));
if (list.empty()) {
if (error == Error::Unknown) {
it->second.done.fire_done();
} else if (error == Error::TooMuch) {
it->second.done.fire_error_copy(error);
}
_toggleRequests.remove(peerId);
}
}
};
const auto done = [=] {
pop(Error::Unknown);
};
const auto fail = [=](const MTP::Error &error) {
const auto type = error.type();
if (type == u"USERNAMES_ACTIVE_TOO_MUCH"_q) {
pop(Error::TooMuch);
} else {
pop(Error::Unknown);
}
};
if (peer->isSelf()) {
_api.request(MTPaccount_ToggleUsername(
MTP_string(username),
MTP_bool(active)
)).done(done).fail(fail).send();
} else if (const auto channel = peer->asChannel()) {
_api.request(MTPchannels_ToggleUsername(
channel->inputChannel,
MTP_string(username),
MTP_bool(active)
)).done(done).fail(fail).send();
} else {
return rpl::never<rpl::no_value, Error>();
}
return entry.done.events();
}
rpl::producer<> Usernames::reorder(
not_null<PeerData*> peer,
const std::vector<QString> &usernames) {
const auto peerId = peer->id;
const auto it = _reorderRequests.find(peerId);
if (it != end(_reorderRequests)) {
_api.request(it->second).cancel();
_reorderRequests.erase(peerId);
}
return [=](auto consumer) {
auto lifetime = rpl::lifetime();
auto tlUsernames = ranges::views::all(
usernames
) | ranges::views::transform([](const QString &username) {
return MTP_string(username);
}) | ranges::to<QVector<MTPstring>>;
const auto finish = [=] {
if (_reorderRequests.contains(peerId)) {
_reorderRequests.erase(peerId);
}
consumer.put_done();
};
if (usernames.empty()) {
crl::on_main([=] { consumer.put_done(); });
return lifetime;
}
if (peer->isSelf()) {
const auto requestId = _api.request(MTPaccount_ReorderUsernames(
MTP_vector<MTPstring>(std::move(tlUsernames))
)).done(finish).fail(finish).send();
_reorderRequests.emplace(peerId, requestId);
} else if (const auto channel = peer->asChannel()) {
const auto requestId = _api.request(MTPchannels_ReorderUsernames(
channel->inputChannel,
MTP_vector<MTPstring>(std::move(tlUsernames))
)).done(finish).fail(finish).send();
_reorderRequests.emplace(peerId, requestId);
}
return lifetime;
};
}
Data::Usernames Usernames::FromTL(const MTPVector<MTPUsername> &usernames) {
return ranges::views::all(
usernames.v
) | ranges::views::transform(UsernameFromTL) | ranges::to_vector;
}
void Usernames::requestToCache(not_null<PeerData*> peer) {
_tinyCache = {};
if (const auto user = peer->asUser()) {
if (user->usernames().empty()) {
return;
}
} else if (const auto channel = peer->asChannel()) {
if (channel->usernames().empty()) {
return;
}
}
const auto lifetime = std::make_shared<rpl::lifetime>();
*lifetime = loadUsernames(
peer
) | rpl::start_with_next([=, id = peer->id](Data::Usernames usernames) {
_tinyCache = std::make_pair(id, std::move(usernames));
lifetime->destroy();
});
}
Data::Usernames Usernames::cacheFor(PeerId id) {
return (_tinyCache.first == id) ? _tinyCache.second : Data::Usernames();
}
} // namespace Api