mirror of
https://github.com/TelegramMessenger/Telegram-iOS.git
synced 2026-05-21 18:20:41 +00:00
isaac
c0acc09cb1
Migrate RenderedChannelParticipant.peers from [PeerId: Peer] to
[EnginePeer.Id: EnginePeer]. Closes the wave-41 ratchet — the public
struct no longer leaks raw Peer types in any field (presences stays
Postbox-typed; separate migration).
Consumer-surface: -10 bridges. Dropped 6 EnginePeer(peer) read-wraps
at participant.peers[...] extraction sites across
ChannelAdminsController, ChannelMembersSearchContainerNode,
ChannelBlacklistController. Dropped 5 .mapValues({ $0._asPeer() })
constructor-unwrap transforms in ChannelAdminsController,
ChannelMembersSearchContainerNode, ChannelMembersSearchControllerNode.
Added 2 ._asPeer() unwraps in ChatRecentActionsHistoryTransition at
the two iteration sites (line 673 via participant.peers, line 2273
via new.peers in participantSubscriptionExtended) where the iterated
value is inserted into a raw-Peer SimpleDictionary.
TelegramCore producers: 8 files build the local peers dict inside
postbox.transaction and wrap at the insertion point. ChannelMembers,
RequestStartBot, ChannelOwnershipTransfer, JoinChannel, AddPeerMember,
PeerAdmins, ChannelBlacklist, Ranks.
2-iteration build convergence. Iteration-1 surfaced new.peers at
ChatRecentActionsHistoryTransition:2272 that the plan's participant.peers
pre-flight grep missed; wider grep now confirms the two iteration sites
are the complete surface.
No unit tests in this project; full Telegram/Telegram build verified
under configuration=debug_sim_arm64.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
83 lines
4.1 KiB
Swift
83 lines
4.1 KiB
Swift
import Foundation
|
|
import Postbox
|
|
import SwiftSignalKit
|
|
import TelegramApi
|
|
import MtProtoKit
|
|
|
|
|
|
func _internal_requestStartBot(account: Account, botPeerId: PeerId, payload: String?) -> Signal<Void, NoError> {
|
|
if let payload = payload, !payload.isEmpty {
|
|
return account.postbox.loadedPeerWithId(botPeerId)
|
|
|> mapToSignal { botPeer -> Signal<Void, NoError> in
|
|
if let inputUser = apiInputUser(botPeer) {
|
|
return account.network.request(Api.functions.messages.startBot(bot: inputUser, peer: .inputPeerEmpty, randomId: Int64.random(in: Int64.min ... Int64.max), startParam: payload))
|
|
|> mapToSignal { result -> Signal<Void, MTRpcError> in
|
|
account.stateManager.addUpdates(result)
|
|
return .complete()
|
|
}
|
|
|> `catch` { _ -> Signal<Void, MTRpcError> in
|
|
return .complete()
|
|
}
|
|
|> retryRequest
|
|
} else {
|
|
return .complete()
|
|
}
|
|
}
|
|
} else {
|
|
return enqueueMessages(account: account, peerId: botPeerId, messages: [.message(text: "/start", attributes: [], inlineStickers: [:], mediaReference: nil, threadId: nil, replyToMessageId: nil, replyToStoryId: nil, localGroupingKey: nil, correlationId: nil, bubbleUpEmojiOrStickersets: [])]) |> mapToSignal { _ -> Signal<Void, NoError> in
|
|
return .complete()
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum RequestStartBotInGroupError {
|
|
case generic
|
|
}
|
|
|
|
public enum StartBotInGroupResult {
|
|
case none
|
|
case channelParticipant(RenderedChannelParticipant)
|
|
}
|
|
|
|
func _internal_requestStartBotInGroup(account: Account, botPeerId: PeerId, groupPeerId: PeerId, payload: String?) -> Signal<StartBotInGroupResult, RequestStartBotInGroupError> {
|
|
return account.postbox.transaction { transaction -> (Peer?, Peer?) in
|
|
return (transaction.getPeer(botPeerId), transaction.getPeer(groupPeerId))
|
|
}
|
|
|> mapError { _ -> RequestStartBotInGroupError in }
|
|
|> mapToSignal { botPeer, groupPeer -> Signal<StartBotInGroupResult, RequestStartBotInGroupError> in
|
|
if let botPeer = botPeer, let inputUser = apiInputUser(botPeer), let groupPeer = groupPeer, let inputGroup = apiInputPeer(groupPeer) {
|
|
let request = account.network.request(Api.functions.messages.startBot(bot: inputUser, peer: inputGroup, randomId: Int64.random(in: Int64.min ... Int64.max), startParam: payload ?? ""))
|
|
|> mapError { _ -> RequestStartBotInGroupError in
|
|
return .generic
|
|
}
|
|
|> mapToSignal { result -> Signal<StartBotInGroupResult, RequestStartBotInGroupError> in
|
|
account.stateManager.addUpdates(result)
|
|
if groupPeerId.namespace == Namespaces.Peer.CloudChannel {
|
|
return _internal_fetchChannelParticipant(account: account, peerId: groupPeerId, participantId: botPeerId)
|
|
|> mapError { _ -> RequestStartBotInGroupError in }
|
|
|> mapToSignal { participant -> Signal<StartBotInGroupResult, RequestStartBotInGroupError> in
|
|
return account.postbox.transaction { transaction -> StartBotInGroupResult in
|
|
if let participant = participant, let peer = transaction.getPeer(participant.peerId) {
|
|
var peers: [EnginePeer.Id: EnginePeer] = [:]
|
|
let presences: [PeerId: PeerPresence] = [:]
|
|
|
|
peers[peer.id] = EnginePeer(peer)
|
|
return .channelParticipant(RenderedChannelParticipant(participant: participant, peer: EnginePeer(peer), peers: peers, presences: presences))
|
|
} else {
|
|
return .none
|
|
}
|
|
}
|
|
|> mapError { _ -> RequestStartBotInGroupError in }
|
|
}
|
|
} else {
|
|
return .single(.none)
|
|
}
|
|
}
|
|
|
|
return request
|
|
} else {
|
|
return .complete()
|
|
}
|
|
}
|
|
}
|