tdesktop/Telegram/SourceFiles/boxes/username_box.cpp

440 lines
12 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 "boxes/username_box.h"
#include "boxes/peers/edit_peer_usernames_list.h"
#include "base/timer.h"
#include "boxes/peers/edit_peer_common.h"
#include "data/data_channel.h"
#include "data/data_session.h"
#include "data/data_user.h"
#include "lang/lang_keys.h"
#include "main/main_app_config_values.h"
#include "main/main_session.h"
#include "mtproto/sender.h"
#include "ui/layers/generic_box.h"
#include "ui/painter.h"
#include "ui/vertical_list.h"
#include "ui/text/text_utilities.h"
#include "ui/text/text_variant.h"
#include "ui/toast/toast.h"
#include "ui/widgets/buttons.h"
#include "ui/widgets/fields/special_fields.h"
#include "ui/widgets/labels.h"
#include "ui/wrap/follow_slide_wrap.h"
#include "ui/wrap/slide_wrap.h"
#include "styles/style_layers.h"
#include "styles/style_boxes.h"
namespace {
[[nodiscard]] TextWithEntities PurchaseAvailableText() {
constexpr auto kUsernameAuction = "auction";
return tr::lng_username_purchase_available(
tr::now,
lt_link,
Ui::Text::Link(
'@' + QString(kUsernameAuction),
u"https://t.me/"_q + kUsernameAuction),
Ui::Text::RichLangValue);
}
class UsernameEditor final : public Ui::RpWidget {
public:
UsernameEditor(not_null<Ui::RpWidget*>, not_null<PeerData*> peer);
void setInnerFocus();
void setEnabled(bool value);
[[nodiscard]] rpl::producer<> submitted() const;
[[nodiscard]] rpl::producer<> save();
[[nodiscard]] rpl::producer<UsernameCheckInfo> checkInfoChanged() const;
protected:
void resizeEvent(QResizeEvent *e) override;
private:
void updateFail(const QString &error);
void checkFail(const QString &error);
void checkInfoPurchaseAvailable();
void check();
void changed();
void checkInfoChange();
[[nodiscard]] QString editableUsername() const;
QString getName() const;
const not_null<PeerData*> _peer;
const not_null<Main::Session*> _session;
const style::margins &_padding;
MTP::Sender _api;
object_ptr<Ui::UsernameInput> _username;
mtpRequestId _saveRequestId = 0;
mtpRequestId _checkRequestId = 0;
QString _sentUsername, _checkUsername, _errorText, _goodText;
base::Timer _checkTimer;
rpl::event_stream<> _saved;
rpl::event_stream<UsernameCheckInfo> _checkInfoChanged;
};
UsernameEditor::UsernameEditor(
not_null<Ui::RpWidget*>,
not_null<PeerData*> peer)
: _peer(peer)
, _session(&peer->session())
, _padding(st::usernamePadding)
, _api(&_session->mtp())
, _username(
this,
st::defaultInputField,
rpl::single(u"@username"_q),
editableUsername(),
QString())
, _checkTimer([=] { check(); }) {
_goodText = editableUsername().isEmpty()
? QString()
: tr::lng_username_available(tr::now);
connect(_username, &Ui::MaskedInputField::changed, [=] { changed(); });
resize(width(), (_padding.top() + _username->height()));
}
rpl::producer<> UsernameEditor::submitted() const {
return [=](auto consumer) {
auto lifetime = rpl::lifetime();
QObject::connect(
_username,
&Ui::MaskedInputField::submitted,
[=] { consumer.put_next({}); });
return lifetime;
};
}
void UsernameEditor::setInnerFocus() {
if (_username->isEnabled()) {
_username->setFocusFast();
}
}
void UsernameEditor::setEnabled(bool value) {
_username->setEnabled(value);
_username->setDisplayFocused(value);
}
void UsernameEditor::resizeEvent(QResizeEvent *e) {
_username->resize(
width() - _padding.left() - _padding.right(),
_username->height());
_username->moveToLeft(_padding.left(), _padding.top());
}
rpl::producer<> UsernameEditor::save() {
if (_saveRequestId) {
return _saved.events();
}
_sentUsername = getName();
_saveRequestId = _api.request(MTPaccount_UpdateUsername(
MTP_string(_sentUsername)
)).done([=](const MTPUser &result) {
_saveRequestId = 0;
_session->data().processUser(result);
_saved.fire_done();
}).fail([=](const MTP::Error &error) {
_saveRequestId = 0;
updateFail(error.type());
}).send();
return _saved.events();
}
QString UsernameEditor::editableUsername() const {
if (const auto user = _peer->asUser()) {
return user->editableUsername();
} else if (const auto channel = _peer->asChannel()) {
return channel->editableUsername();
} else {
return QString();
}
}
rpl::producer<UsernameCheckInfo> UsernameEditor::checkInfoChanged() const {
return _checkInfoChanged.events();
}
void UsernameEditor::check() {
_api.request(base::take(_checkRequestId)).cancel();
const auto name = getName();
if (name.size() < Ui::EditPeer::kMinUsernameLength) {
return;
}
_checkUsername = name;
_checkRequestId = _api.request(MTPaccount_CheckUsername(
MTP_string(name)
)).done([=](const MTPBool &result) {
_checkRequestId = 0;
_errorText = (mtpIsTrue(result)
|| (_checkUsername == editableUsername()))
? QString()
: tr::lng_username_occupied(tr::now);
_goodText = _errorText.isEmpty()
? tr::lng_username_available(tr::now)
: QString();
checkInfoChange();
}).fail([=](const MTP::Error &error) {
_checkRequestId = 0;
checkFail(error.type());
}).send();
}
void UsernameEditor::changed() {
const auto name = getName();
if (name.isEmpty()) {
if (!_errorText.isEmpty() || !_goodText.isEmpty()) {
_errorText = _goodText = QString();
_checkInfoChanged.fire({ UsernameCheckInfo::Type::Default });
}
_checkTimer.cancel();
} else {
const auto len = int(name.size());
for (auto i = 0; i < len; ++i) {
const auto ch = name.at(i);
if ((ch < 'A' || ch > 'Z')
&& (ch < 'a' || ch > 'z')
&& (ch < '0' || ch > '9')
&& ch != '_'
&& (ch != '@' || i > 0)) {
if (_errorText != tr::lng_username_bad_symbols(tr::now)) {
_errorText = tr::lng_username_bad_symbols(tr::now);
checkInfoChange();
}
_checkTimer.cancel();
return;
}
}
if (name.size() < Ui::EditPeer::kMinUsernameLength) {
if (_errorText != tr::lng_username_too_short(tr::now)) {
_errorText = tr::lng_username_too_short(tr::now);
checkInfoChange();
}
_checkTimer.cancel();
} else {
if (!_errorText.isEmpty() || !_goodText.isEmpty()) {
_errorText = _goodText = QString();
checkInfoChange();
}
_checkTimer.callOnce(Ui::EditPeer::kUsernameCheckTimeout);
}
}
}
void UsernameEditor::checkInfoChange() {
if (!_errorText.isEmpty()) {
_checkInfoChanged.fire({
.type = UsernameCheckInfo::Type::Error,
.text = { _errorText },
});
} else if (!_goodText.isEmpty()) {
_checkInfoChanged.fire({
.type = UsernameCheckInfo::Type::Good,
.text = { _goodText },
});
} else {
_checkInfoChanged.fire({
.type = UsernameCheckInfo::Type::Default,
.text = { tr::lng_username_choose(tr::now) },
});
}
}
void UsernameEditor::checkInfoPurchaseAvailable() {
_username->setFocus();
_username->showError();
_errorText = u".bad."_q;
_checkInfoChanged.fire({
.type = UsernameCheckInfo::Type::PurchaseAvailable,
});
}
void UsernameEditor::updateFail(const QString &error) {
if ((error == u"USERNAME_NOT_MODIFIED"_q)
|| (_sentUsername == editableUsername())) {
if (const auto user = _peer->asUser()) {
user->setName(
TextUtilities::SingleLine(user->firstName),
TextUtilities::SingleLine(user->lastName),
TextUtilities::SingleLine(user->nameOrPhone),
TextUtilities::SingleLine(_sentUsername));
}
_saved.fire_done();
} else if (error == u"USERNAME_INVALID"_q) {
_username->setFocus();
_username->showError();
_errorText = tr::lng_username_invalid(tr::now);
checkInfoChange();
} else if ((error == u"USERNAME_OCCUPIED"_q)
|| (error == u"USERNAMES_UNAVAILABLE"_q)) {
_username->setFocus();
_username->showError();
_errorText = tr::lng_username_occupied(tr::now);
checkInfoChange();
} else if (error == u"USERNAME_PURCHASE_AVAILABLE"_q) {
checkInfoPurchaseAvailable();
} else {
_username->setFocus();
}
}
void UsernameEditor::checkFail(const QString &error) {
if (error == u"USERNAME_INVALID"_q) {
_errorText = tr::lng_username_invalid(tr::now);
checkInfoChange();
} else if ((error == u"USERNAME_OCCUPIED"_q)
&& (_checkUsername != editableUsername())) {
_errorText = tr::lng_username_occupied(tr::now);
checkInfoChange();
} else if (error == u"USERNAME_PURCHASE_AVAILABLE"_q) {
checkInfoPurchaseAvailable();
} else {
_goodText = QString();
_username->setFocus();
}
}
QString UsernameEditor::getName() const {
return _username->text().replace('@', QString()).trimmed();
}
} // namespace
void UsernamesBox(
not_null<Ui::GenericBox*> box,
not_null<PeerData*> peer) {
const auto isBot = peer && peer->isUser() && peer->asUser()->isBot();
box->setTitle(isBot
? tr::lng_bot_username_title()
: tr::lng_username_title());
const auto container = box->verticalLayout();
const auto editor = box->addRow(
object_ptr<UsernameEditor>(box, peer),
{});
editor->setEnabled(!isBot);
box->setFocusCallback([=] { editor->setInnerFocus(); });
AddUsernameCheckLabel(container, editor->checkInfoChanged());
auto description = [&]() -> rpl::producer<TextWithEntities> {
if (!isBot) {
return rpl::combine(
tr::lng_username_description1(Ui::Text::RichLangValue),
tr::lng_username_description2(Ui::Text::RichLangValue)
) | rpl::map([](TextWithEntities d1, TextWithEntities d2) {
return d1.append("\n\n").append(std::move(d2));
});
}
if (const auto url = AppConfig::FragmentLink(&peer->session())) {
const auto link = Ui::Text::Link(
tr::lng_bot_username_description1_link(tr::now),
*url);
return tr::lng_bot_username_description1(
lt_link,
rpl::single(link),
Ui::Text::RichLangValue);
}
return rpl::single<TextWithEntities>({});
}();
container->add(object_ptr<Ui::DividerLabel>(
container,
object_ptr<Ui::FlatLabel>(
container,
std::move(description),
st::boxDividerLabel),
st::defaultBoxDividerLabelPadding));
const auto list = box->addRow(
object_ptr<UsernamesList>(
box,
peer,
box->uiShow(),
!isBot
? [=] { box->scrollToY(0); editor->setInnerFocus(); }
: Fn<void()>(nullptr)),
{});
const auto finish = [=] {
list->save(
) | rpl::start_with_done([=] {
editor->save(
) | rpl::start_with_done([=] {
box->closeBox();
}, box->lifetime());
}, box->lifetime());
};
editor->submitted(
) | rpl::start_with_next(finish, editor->lifetime());
if (isBot) {
box->addButton(tr::lng_close(), [=] { box->closeBox(); });
} else {
box->addButton(tr::lng_settings_save(), finish);
box->addButton(tr::lng_cancel(), [=] { box->closeBox(); });
}
}
void AddUsernameCheckLabel(
not_null<Ui::VerticalLayout*> container,
rpl::producer<UsernameCheckInfo> checkInfo) {
const auto padding = st::boxRowPadding;
const auto &st = st::aboutRevokePublicLabel;
const auto skip = (st::usernameSkip - st.style.font->height) / 4;
auto wrapped = object_ptr<Ui::VerticalLayout>(container);
Ui::AddSkip(wrapped, skip);
const auto label = wrapped->add(object_ptr<Ui::FlatLabel>(wrapped, st));
Ui::AddSkip(wrapped, skip);
Ui::AddSkip(container, skip);
container->add(
object_ptr<Ui::FollowSlideWrap<Ui::VerticalLayout>>(
container,
std::move(wrapped)),
padding);
rpl::combine(
std::move(checkInfo),
container->widthValue()
) | rpl::start_with_next([=](const UsernameCheckInfo &info, int w) {
using Type = UsernameCheckInfo::Type;
label->setMarkedText((info.type == Type::PurchaseAvailable)
? PurchaseAvailableText()
: info.text);
const auto &color = (info.type == Type::Good)
? st::boxTextFgGood
: (info.type == Type::Error)
? st::boxTextFgError
: st::usernameDefaultFg;
label->setTextColorOverride(color->c);
label->resizeToWidth(w - padding.left() - padding.right());
}, label->lifetime());
Ui::AddSkip(container, skip);
}