ZaStoGram_desktop/Telegram/SourceFiles/wallet/wallet_own_card.cpp
loop-uh b40c425ad2 Новые файлы оригинала: include-пути mtproto по раскладке форка
api_share_themes.h, wallet/*, info/profile/*, window/* и test/* пришли из оригинала
со старыми путями mtproto/sender.h, mtp_instance.h, mtproto_dc_options.h,
mtproto_response.h, details/mtproto_serialized_request.h, details/mtproto_dump_to_text.h.
Переписаны на instance/, config/, protocol/ (apiwrap.cpp не собирался).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-03 17:03:07 -05:00

268 lines
7.3 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 "wallet/wallet_own_card.h"
#include "data/data_changes.h"
#include "data/data_star_gift.h"
#include "data/data_user.h"
#include "main/main_session.h"
#include "mtproto/protocol/mtproto_response.h"
#include "storage/storage_account.h"
#include "wallet/wallet_address.h"
namespace Wallet {
namespace {
using Data::WalletCardSticker;
constexpr auto kPreserveAppearanceDuration = crl::time(60000);
constexpr auto kCardDecorationHintDonePref = "wallet_card_drag_hint_hidden"_cs;
[[nodiscard]] auto SameNftAs(const QString &address) {
return [canonical = CanonicalAddress(address)](
const WalletCardSticker &sticker) {
return !canonical.isEmpty()
&& (CanonicalAddress(sticker.address) == canonical);
};
}
[[nodiscard]] QString SentBackground(const OwnCardState &state) {
const auto i = ranges::find_if(
state.stickers,
SameNftAs(state.background));
return (i != end(state.stickers)) ? i->address : QString();
}
[[nodiscard]] bool SameWire(const OwnCardState &a, const OwnCardState &b) {
const auto same = [](
const WalletCardSticker &x,
const WalletCardSticker &y) {
return (x.area == y.area)
&& (CanonicalAddress(x.address) == CanonicalAddress(y.address));
};
return ranges::equal(a.stickers, b.stickers, same)
&& (CanonicalAddress(SentBackground(a))
== CanonicalAddress(SentBackground(b)));
}
[[nodiscard]] bool ValidArea(const Data::StoryArea &area) {
const auto &geometry = area.geometry;
const auto values = {
geometry.x(),
geometry.y(),
geometry.width(),
geometry.height(),
area.rotation,
area.radius,
};
const auto finite = [](float64 value) {
return std::isfinite(value);
};
return ranges::all_of(values, finite)
&& (geometry.width() > 0.)
&& (geometry.height() > 0.)
&& (area.radius >= 0.);
}
[[nodiscard]] bool ValidSticker(const WalletCardSticker &sticker) {
return sticker.gift && sticker.gift->unique && ValidArea(sticker.area);
}
[[nodiscard]] bool ValidState(const OwnCardState &state) {
return ranges::all_of(state.stickers, ValidSticker)
&& Data::UniqueWalletCardStickers(state.stickers)
&& (state.background.isEmpty() || !SentBackground(state).isEmpty());
}
[[nodiscard]] std::vector<WalletCardSticker> Missing(
const std::vector<WalletCardSticker> &from,
const std::vector<WalletCardSticker> &in) {
auto result = std::vector<WalletCardSticker>();
for (const auto &sticker : from) {
if (ranges::none_of(in, SameNftAs(sticker.address))) {
result.push_back(sticker);
}
}
return result;
}
[[nodiscard]] MTPwallet_SetCardStickers Serialize(
const OwnCardState &state) {
using Flag = MTPwallet_setCardStickers::Flag;
auto stickers = QVector<MTPInputWalletCardSticker>();
stickers.reserve(state.stickers.size());
for (const auto &sticker : state.stickers) {
stickers.push_back(MTP_inputWalletCardSticker(
Data::SerializeArea(sticker.area),
MTP_string(sticker.address)));
}
const auto background = SentBackground(state);
return MTPwallet_SetCardStickers(
MTP_flags(background.isEmpty() ? Flag() : Flag::f_bg_nft_address),
MTP_vector<MTPInputWalletCardSticker>(std::move(stickers)),
MTP_string(background));
}
} // namespace
OwnCard::OwnCard(not_null<Main::Session*> session)
: _session(session)
, _api(&session->mtp()) {
session->changes().peerFlagsValue(
session->user(),
Data::PeerUpdate::Flag::WalletCard
) | rpl::on_next([=] {
refresh();
}, _lifetime);
}
OwnCard::~OwnCard() = default;
bool OwnCard::ready() const {
const auto card = _session->user()->walletCard();
return card && card->stickersComplete;
}
bool OwnCard::contains(const QString &address) const {
const auto state = shown();
return ranges::any_of(state.stickers, SameNftAs(address));
}
OwnCardState OwnCard::shown() const {
return _pending ? *_pending : confirmed();
}
rpl::producer<OwnCardState> OwnCard::shownValue() const {
return _shown.value();
}
rpl::producer<OwnCardFailure> OwnCard::failures() const {
return _failures.events();
}
void OwnCard::applyFullUserCard(std::optional<Data::WalletCard> card) {
const auto self = _session->user();
const auto current = self->walletCard();
// Profile reads can lag behind a successful card mutation.
if (card && current
&& (_pending || crl::now() < _preserveAppearanceUntil)
&& (CanonicalAddress(card->address)
== CanonicalAddress(current->address))) {
card->stickers = current->stickers;
card->backgroundAddress = current->backgroundAddress;
card->stickersComplete = current->stickersComplete;
}
self->setWalletCard(std::move(card));
}
OwnCardChange OwnCard::save(OwnCardState desired) {
if (!ready()) {
return OwnCardChange::NotReady;
} else if (int(desired.stickers.size()) > Data::kWalletCardMaxStickers) {
return OwnCardChange::Limit;
} else if (!ValidState(desired)) {
return OwnCardChange::Invalid;
} else if (SameWire(desired, shown())) {
return OwnCardChange::Unchanged;
}
apply(std::move(desired));
return OwnCardChange::Applied;
}
bool OwnCard::cardDecorationHintDone() const {
return _session->local().readPref<bool>(kCardDecorationHintDonePref);
}
void OwnCard::finishCardDecorationHint() {
if (!cardDecorationHintDone()) {
_session->local().writePref<bool>(kCardDecorationHintDonePref, true);
}
}
OwnCardState OwnCard::confirmed() const {
const auto card = _session->user()->walletCard();
return card
? OwnCardState{ card->stickers, card->backgroundAddress }
: OwnCardState();
}
void OwnCard::refresh() {
auto state = shown();
if (!state.stickers.empty()) {
finishCardDecorationHint();
}
_shown = std::move(state);
}
void OwnCard::apply(OwnCardState desired) {
_pending = std::move(desired);
refresh();
if (!_requestId) {
send();
}
}
void OwnCard::send() {
Expects(_pending.has_value());
_sent = *_pending;
_preserveAppearanceUntil = crl::now() + kPreserveAppearanceDuration;
_requestId = _api.request(
Serialize(_sent)
).done([=](const MTPwallet_Card &result) {
_requestId = 0;
done(result);
}).fail([=](const MTP::Error &error) {
_requestId = 0;
discard({
.type = error.type(),
.silent = MTP::IgnoreError(error),
});
}).handleAllErrors().send();
}
void OwnCard::done(const MTPwallet_Card &result) {
const auto self = _session->user();
_preserveAppearanceUntil = crl::now() + kPreserveAppearanceDuration;
self->setWalletCard(Data::ParseWalletCard(_session, result));
if (!_pending
|| SameWire(*_pending, _sent)
|| SameWire(*_pending, confirmed())) {
_pending = std::nullopt;
refresh();
} else if (!ready()) {
discard({ .notReady = true });
} else {
send();
}
}
void OwnCard::discard(OwnCardFailure failure) {
const auto before = _shown.current();
_pending = std::nullopt;
refresh();
const auto &after = _shown.current();
failure.left = Missing(before.stickers, after.stickers);
failure.returned = Missing(after.stickers, before.stickers);
_failures.fire(std::move(failure));
}
bool RemoveOwnCardSticker(OwnCardState &state, const QString &address) {
const auto i = ranges::find_if(state.stickers, SameNftAs(address));
if (i == end(state.stickers)) {
return false;
}
state.stickers.erase(i);
if (SentBackground(state).isEmpty()) {
state.background = QString();
}
return true;
}
} // namespace Wallet