teleproto 1.214.0

package/client/chats.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ParticipantsIter = void 0;
+exports.iterParticipants = iterParticipants;
+exports.getParticipants = getParticipants;
+exports.kickParticipant = kickParticipant;
+const Helpers_1 = require("../Helpers");
+const requestIter_1 = require("../requestIter");
+const __1 = require("..");
+const tl_1 = require("../tl");
+const big_integer_1 = __importDefault(require("big-integer"));
+const inspect_1 = require("../inspect");
+const Utils_1 = require("../Utils");
+const _MAX_PARTICIPANTS_CHUNK_SIZE = 200;
+const _MAX_ADMIN_LOG_CHUNK_SIZE = 100;
+const _MAX_PROFILE_PHOTO_CHUNK_SIZE = 100;
+class _ChatAction {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    constructor(client, chat, action, params = {
+        delay: 4,
+        autoCancel: true,
+    }) {
+        this._client = client;
+        this._chat = chat;
+        this._action = action;
+        this._delay = params.delay;
+        this.autoCancel = params.autoCancel;
+        this._request = undefined;
+        this._task = null;
+        this._running = false;
+    }
+    async start() {
+        this._request = new tl_1.Api.messages.SetTyping({
+            peer: this._chat,
+            action: this._action,
+        });
+        this._running = true;
+        this._update();
+    }
+    async stop() {
+        this._running = false;
+        if (this.autoCancel) {
+            await this._client.invoke(new tl_1.Api.messages.SetTyping({
+                peer: this._chat,
+                action: new tl_1.Api.SendMessageCancelAction(),
+            }));
+        }
+    }
+    async _update() {
+        while (this._running) {
+            if (this._request != undefined) {
+                await this._client.invoke(this._request);
+            }
+            await (0, Helpers_1.sleep)(this._delay * 1000);
+        }
+    }
+    progress(current, total) {
+        if ("progress" in this._action) {
+            this._action.progress = 100 * Math.round(current / total);
+        }
+    }
+}
+_ChatAction._str_mapping = {
+    typing: new tl_1.Api.SendMessageTypingAction(),
+    contact: new tl_1.Api.SendMessageChooseContactAction(),
+    game: new tl_1.Api.SendMessageGamePlayAction(),
+    location: new tl_1.Api.SendMessageGeoLocationAction(),
+    "record-audio": new tl_1.Api.SendMessageRecordAudioAction(),
+    "record-voice": new tl_1.Api.SendMessageRecordAudioAction(), //alias
+    "record-round": new tl_1.Api.SendMessageRecordRoundAction(),
+    "record-video": new tl_1.Api.SendMessageRecordVideoAction(),
+    audio: new tl_1.Api.SendMessageUploadAudioAction({ progress: 1 }),
+    voice: new tl_1.Api.SendMessageUploadAudioAction({ progress: 1 }), // alias
+    song: new tl_1.Api.SendMessageUploadAudioAction({ progress: 1 }), // alias
+    round: new tl_1.Api.SendMessageUploadRoundAction({ progress: 1 }),
+    video: new tl_1.Api.SendMessageUploadVideoAction({ progress: 1 }),
+    photo: new tl_1.Api.SendMessageUploadPhotoAction({ progress: 1 }),
+    document: new tl_1.Api.SendMessageUploadDocumentAction({ progress: 1 }),
+    file: new tl_1.Api.SendMessageUploadDocumentAction({ progress: 1 }), // alias
+    cancel: new tl_1.Api.SendMessageCancelAction(),
+};
+class _ParticipantsIter extends requestIter_1.RequestIter {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    async _init({ entity, filter, offset, search, showTotal, }) {
+        var _a, _b;
+        if (!offset) {
+            offset = 0;
+        }
+        if (filter && filter.constructor === Function) {
+            if ([
+                tl_1.Api.ChannelParticipantsBanned,
+                tl_1.Api.ChannelParticipantsKicked,
+                tl_1.Api.ChannelParticipantsSearch,
+                tl_1.Api.ChannelParticipantsContacts,
+            ].includes(filter)) {
+                filter = new filter({
+                    q: "",
+                });
+            }
+            else {
+                filter = new filter();
+            }
+        }
+        entity = await this.client.getInputEntity(entity);
+        const ty = __1.helpers._entityType(entity);
+        if (search && (filter || ty != __1.helpers._EntityType.CHANNEL)) {
+            // We need to 'search' ourselves unless we have a PeerChannel
+            search = search.toLowerCase();
+            this.filterEntity = (entity) => {
+                return (__1.utils
+                    .getDisplayName(entity)
+                    .toLowerCase()
+                    .includes(search) ||
+                    ("username" in entity ? entity.username || "" : "")
+                        .toLowerCase()
+                        .includes(search));
+            };
+        }
+        else {
+            this.filterEntity = (entity) => true;
+        }
+        // Only used for channels, but we should always set the attribute
+        this.requests = [];
+        if (ty == __1.helpers._EntityType.CHANNEL) {
+            if (showTotal) {
+                const channel = await this.client.invoke(new tl_1.Api.channels.GetFullChannel({
+                    channel: entity,
+                }));
+                if (!(channel.fullChat instanceof tl_1.Api.ChatFull)) {
+                    this.total = channel.fullChat.participantsCount;
+                }
+            }
+            if (this.total && this.total <= 0) {
+                return false;
+            }
+            this.requests.push(new tl_1.Api.channels.GetParticipants({
+                channel: entity,
+                filter: filter ||
+                    new tl_1.Api.ChannelParticipantsSearch({
+                        q: search || "",
+                    }),
+                offset,
+                limit: _MAX_PARTICIPANTS_CHUNK_SIZE,
+                hash: big_integer_1.default.zero,
+            }));
+        }
+        else if (ty == __1.helpers._EntityType.CHAT) {
+            if (!("chatId" in entity)) {
+                throw new Error("Found chat without id " + JSON.stringify(entity));
+            }
+            const full = await this.client.invoke(new tl_1.Api.messages.GetFullChat({
+                chatId: entity.chatId,
+            }));
+            if (full.fullChat instanceof tl_1.Api.ChatFull) {
+                if (!(full.fullChat.participants instanceof
+                    tl_1.Api.ChatParticipantsForbidden)) {
+                    this.total = full.fullChat.participants.participants.length;
+                }
+                else {
+                    this.total = 0;
+                    return false;
+                }
+                const users = new Map();
+                for (const user of full.users) {
+                    users.set(user.id.toString(), user);
+                }
+                for (const participant of full.fullChat.participants
+                    .participants) {
+                    const user = users.get(participant.userId.toString());
+                    if (!this.filterEntity(user)) {
+                        continue;
+                    }
+                    user.participant = participant;
+                    (_a = this.buffer) === null || _a === void 0 ? void 0 : _a.push(user);
+                }
+                return true;
+            }
+        }
+        else {
+            this.total = 1;
+            if (this.limit != 0) {
+                const user = await this.client.getEntity(entity);
+                if (this.filterEntity(user)) {
+                    user.participant = undefined;
+                    (_b = this.buffer) === null || _b === void 0 ? void 0 : _b.push(user);
+                }
+            }
+            return true;
+        }
+    }
+    async _loadNextChunk() {
+        var _a, _b;
+        if (!((_a = this.requests) === null || _a === void 0 ? void 0 : _a.length)) {
+            return true;
+        }
+        this.requests[0].limit = Math.min(this.limit - this.requests[0].offset, _MAX_PARTICIPANTS_CHUNK_SIZE);
+        const results = [];
+        for (const request of this.requests) {
+            results.push(await this.client.invoke(request));
+        }
+        for (let i = this.requests.length - 1; i >= 0; i--) {
+            const participants = results[i];
+            if (participants instanceof
+                tl_1.Api.channels.ChannelParticipantsNotModified ||
+                !participants.users.length) {
+                this.requests.splice(i, 1);
+                continue;
+            }
+            this.requests[i].offset += participants.participants.length;
+            const users = new Map();
+            for (const user of participants.users) {
+                users.set(user.id.toString(), user);
+            }
+            for (const participant of participants.participants) {
+                if (!("userId" in participant)) {
+                    continue;
+                }
+                const user = users.get(participant.userId.toString());
+                if (this.filterEntity && !this.filterEntity(user)) {
+                    continue;
+                }
+                user.participant = participant;
+                (_b = this.buffer) === null || _b === void 0 ? void 0 : _b.push(user);
+            }
+        }
+        return undefined;
+    }
+    [Symbol.asyncIterator]() {
+        return super[Symbol.asyncIterator]();
+    }
+}
+exports._ParticipantsIter = _ParticipantsIter;
+class _AdminLogIter extends requestIter_1.RequestIter {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    async _init(entity, searchArgs, filterArgs) {
+        let eventsFilter = undefined;
+        if (filterArgs &&
+            Object.values(filterArgs).find((element) => element === true)) {
+            eventsFilter = new tl_1.Api.ChannelAdminLogEventsFilter(Object.assign({}, filterArgs));
+        }
+        this.entity = await this.client.getInputEntity(entity);
+        const adminList = [];
+        if (searchArgs && searchArgs.admins) {
+            for (const admin of searchArgs.admins) {
+                adminList.push(await this.client.getInputEntity(admin));
+            }
+        }
+        this.request = new tl_1.Api.channels.GetAdminLog({
+            channel: this.entity,
+            q: (searchArgs === null || searchArgs === void 0 ? void 0 : searchArgs.search) || "",
+            minId: searchArgs === null || searchArgs === void 0 ? void 0 : searchArgs.minId,
+            maxId: searchArgs === null || searchArgs === void 0 ? void 0 : searchArgs.maxId,
+            limit: 0,
+            eventsFilter: eventsFilter,
+            admins: adminList || undefined,
+        });
+    }
+    async _loadNextChunk() {
+        if (!this.request) {
+            return true;
+        }
+        this.request.limit = Math.min(this.left, _MAX_ADMIN_LOG_CHUNK_SIZE);
+        const r = await this.client.invoke(this.request);
+        const entities = new Map();
+        for (const entity of [...r.users, ...r.chats]) {
+            entities.set(__1.utils.getPeerId(entity), entity);
+        }
+        const eventIds = [];
+        for (const e of r.events) {
+            eventIds.push(e.id);
+        }
+        this.request.maxId = (0, Helpers_1.getMinBigInt)([big_integer_1.default.zero, ...eventIds]);
+        for (const ev of r.events) {
+            if (ev.action instanceof tl_1.Api.ChannelAdminLogEventActionEditMessage) {
+                // @ts-ignore
+                // TODO ev.action.prevMessage._finishInit(this.client, entities, this.entity);
+                // @ts-ignore
+                // TODO ev.action.newMessage._finishInit(this.client, entities, this.entity);
+            }
+        }
+    }
+}
+/** @hidden */
+function iterParticipants(client, entity, { limit, offset, search, filter, showTotal = true }) {
+    return new _ParticipantsIter(client, limit !== null && limit !== void 0 ? limit : Number.MAX_SAFE_INTEGER, {}, {
+        entity: entity,
+        filter: filter,
+        offset: offset !== null && offset !== void 0 ? offset : 0,
+        search: search,
+        showTotal: showTotal,
+    });
+}
+/** @hidden */
+async function getParticipants(client, entity, params) {
+    const it = client.iterParticipants(entity, params);
+    return (await it.collect());
+}
+/** @hidden */
+async function kickParticipant(client, entity, participant) {
+    const peer = await client.getInputEntity(entity);
+    const user = await client.getInputEntity(participant);
+    let resp;
+    let request;
+    const type = __1.helpers._entityType(peer);
+    if (type === __1.helpers._EntityType.CHAT) {
+        request = new tl_1.Api.messages.DeleteChatUser({
+            chatId: (0, Helpers_1.returnBigInt)((0, Utils_1.getPeerId)(entity)),
+            userId: (0, Helpers_1.returnBigInt)((0, Utils_1.getPeerId)(participant)),
+        });
+        resp = await client.invoke(request);
+    }
+    else if (type === __1.helpers._EntityType.CHANNEL) {
+        if (user instanceof tl_1.Api.InputPeerSelf) {
+            request = new tl_1.Api.channels.LeaveChannel({
+                channel: peer,
+            });
+            resp = await client.invoke(request);
+        }
+        else {
+            request = new tl_1.Api.channels.EditBanned({
+                channel: peer,
+                participant: user,
+                bannedRights: new tl_1.Api.ChatBannedRights({
+                    untilDate: 0,
+                    viewMessages: true,
+                }),
+            });
+            resp = await client.invoke(request);
+            await (0, Helpers_1.sleep)(500);
+            await client.invoke(new tl_1.Api.channels.EditBanned({
+                channel: peer,
+                participant: user,
+                bannedRights: new tl_1.Api.ChatBannedRights({ untilDate: 0 }),
+            }));
+        }
+    }
+    else {
+        throw new Error("You must pass either a channel or a chat");
+    }
+    return client._getResponseMessage(request, resp, entity);
+}

package/client/dialogs.d.ts

@@ -0,0 +1,52 @@
+import { Api } from "../tl";
+import { RequestIter } from "../requestIter";
+import { TelegramClient } from "../index";
+import { Dialog } from "../tl/custom/dialog";
+import { DateLike, EntityLike } from "../define";
+import { TotalList } from "../Helpers";
+export interface DialogsIterInterface {
+    offsetDate: number;
+    offsetId: number;
+    offsetPeer: Api.TypePeer;
+    ignorePinned: boolean;
+    ignoreMigrated: boolean;
+    folder: number;
+}
+export declare class _DialogsIter extends RequestIter {
+    private request?;
+    private seen?;
+    private offsetDate?;
+    private ignoreMigrated?;
+    _init({ offsetDate, offsetId, offsetPeer, ignorePinned, ignoreMigrated, folder, }: DialogsIterInterface): Promise<true | undefined>;
+    [Symbol.asyncIterator](): AsyncIterator<Dialog, any, undefined>;
+    _loadNextChunk(): Promise<boolean | undefined>;
+}
+/** interface for iterating and getting dialogs. */
+export interface IterDialogsParams {
+    /**  How many dialogs to be retrieved as maximum. Can be set to undefined to retrieve all dialogs.<br/>
+     * Note that this may take whole minutes if you have hundreds of dialogs, as Telegram will tell the library to slow down through a FloodWaitError.*/
+    limit?: number;
+    /** The offset date of last message of dialog to be used. */
+    offsetDate?: DateLike;
+    /** The message ID to be used as offset. */
+    offsetId?: number;
+    /** offset Peer to be used (defaults to Empty = no offset) */
+    offsetPeer?: EntityLike;
+    /** Whether pinned dialogs should be ignored or not. When set to true, these won't be yielded at all. */
+    ignorePinned?: boolean;
+    /**  Whether Chat that have migratedTo a Supergroup should be included or not.<br/>
+     * By default all the chats in your dialogs are returned, but setting this to True will ignore (i.e. skip) them in the same way official applications do.*/
+    ignoreMigrated?: boolean;
+    /** The folder from which the dialogs should be retrieved.<br/>
+     * If left unspecified, all dialogs (including those from folders) will be returned.<br/>
+     * If set to 0, all dialogs that don't belong to any folder will be returned.<br/>
+     * If set to a folder number like 1, only those from said folder will be returned.<br/>
+     * By default Telegram assigns the folder ID 1 to archived chats, so you should use that if you need to fetch the archived dialogs.<br/> */
+    folder?: number;
+    /**  Alias for folder. If unspecified, all will be returned, false implies `folder:0` and True implies `folder:1`.*/
+    archived?: boolean;
+}
+/** @hidden */
+export declare function iterDialogs(client: TelegramClient, { limit, offsetDate, offsetId, offsetPeer, ignorePinned, ignoreMigrated, folder, archived, }: IterDialogsParams): _DialogsIter;
+/** @hidden */
+export declare function getDialogs(client: TelegramClient, params: IterDialogsParams): Promise<TotalList<Dialog>>;

package/client/dialogs.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._DialogsIter = void 0;
+exports.iterDialogs = iterDialogs;
+exports.getDialogs = getDialogs;
+const tl_1 = require("../tl");
+const requestIter_1 = require("../requestIter");
+const index_1 = require("../index");
+const dialog_1 = require("../tl/custom/dialog");
+const big_integer_1 = __importDefault(require("big-integer"));
+const Logger_1 = require("../extensions/Logger");
+const _MAX_CHUNK_SIZE = 100;
+/**
+ Get the key to get messages from a dialog.
+
+ We cannot just use the message ID because channels share message IDs,
+ and the peer ID is required to distinguish between them. But it is not
+ necessary in small group chats and private chats.
+ * @param {Api.TypePeer} [peer] the dialog peer
+ * @param {number} [messageId] the message id
+ * @return {[number,number]} the channel id and message id
+ */
+function _dialogMessageKey(peer, messageId) {
+    // can't use arrays as keys for map :( need to convert to string.
+    return ("" +
+        [
+            peer instanceof tl_1.Api.PeerChannel ? peer.channelId : undefined,
+            messageId,
+        ]);
+}
+class _DialogsIter extends requestIter_1.RequestIter {
+    async _init({ offsetDate, offsetId, offsetPeer, ignorePinned, ignoreMigrated, folder, }) {
+        this.request = new tl_1.Api.messages.GetDialogs({
+            offsetDate,
+            offsetId,
+            offsetPeer,
+            limit: 1,
+            hash: big_integer_1.default.zero,
+            excludePinned: ignorePinned,
+            folderId: folder,
+        });
+        if (this.limit <= 0) {
+            // Special case, get a single dialog and determine count
+            const dialogs = await this.client.invoke(this.request);
+            if ("count" in dialogs) {
+                this.total = dialogs.count;
+            }
+            else {
+                this.total = dialogs.dialogs.length;
+            }
+            return true;
+        }
+        this.seen = new Set();
+        this.offsetDate = offsetDate;
+        this.ignoreMigrated = ignoreMigrated;
+    }
+    [Symbol.asyncIterator]() {
+        return super[Symbol.asyncIterator]();
+    }
+    async _loadNextChunk() {
+        var _a;
+        if (!this.request || !this.seen || !this.buffer) {
+            return;
+        }
+        this.request.limit = Math.min(this.left, _MAX_CHUNK_SIZE);
+        const r = await this.client.invoke(this.request);
+        if (r instanceof tl_1.Api.messages.DialogsNotModified) {
+            return;
+        }
+        if ("count" in r) {
+            this.total = r.count;
+        }
+        else {
+            this.total = r.dialogs.length;
+        }
+        const entities = new Map();
+        const messages = new Map();
+        for (const entity of [...r.users, ...r.chats]) {
+            if (entity instanceof tl_1.Api.UserEmpty ||
+                entity instanceof tl_1.Api.ChatEmpty) {
+                continue;
+            }
+            entities.set(index_1.utils.getPeerId(entity), entity);
+        }
+        for (const m of r.messages) {
+            let message = m;
+            try {
+                if (message && "_finishInit" in message) {
+                    // todo make sure this never fails
+                    message._finishInit(this.client, entities, undefined);
+                }
+            }
+            catch (e) {
+                console.log("msg", message);
+                this.client._log.error("Got error while trying to finish init message with id " +
+                    m.id);
+                if (this.client._log.canSend(Logger_1.LogLevel.ERROR)) {
+                    console.error(e);
+                }
+                if (this.client._errorHandler) {
+                    await this.client._errorHandler(e);
+                }
+            }
+            messages.set(_dialogMessageKey(message.peerId, message.id), message);
+        }
+        for (const d of r.dialogs) {
+            if (d instanceof tl_1.Api.DialogFolder) {
+                continue;
+            }
+            const message = messages.get(_dialogMessageKey(d.peer, d.topMessage));
+            if (this.offsetDate != undefined) {
+                const date = message === null || message === void 0 ? void 0 : message.date;
+                if (date == undefined || date > this.offsetDate) {
+                    continue;
+                }
+            }
+            const peerId = index_1.utils.getPeerId(d.peer);
+            if (!this.seen.has(peerId)) {
+                this.seen.add(peerId);
+                if (!entities.has(peerId)) {
+                    /*
+                     > In which case can a UserEmpty appear in the list of banned members?
+                     > In a very rare cases. This is possible but isn't an expected behavior.
+                     Real world example: https://t.me/TelethonChat/271471
+                     */
+                    continue;
+                }
+                const cd = new dialog_1.Dialog(this.client, d, entities, message);
+                if (!this.ignoreMigrated ||
+                    (cd.entity != undefined && "migratedTo" in cd.entity)) {
+                    this.buffer.push(cd);
+                }
+            }
+        }
+        if (r.dialogs.length < this.request.limit ||
+            !(r instanceof tl_1.Api.messages.DialogsSlice)) {
+            return true;
+        }
+        let lastMessage;
+        for (let dialog of r.dialogs.reverse()) {
+            lastMessage = messages.get(_dialogMessageKey(dialog.peer, dialog.topMessage));
+            if (lastMessage) {
+                break;
+            }
+        }
+        this.request.excludePinned = true;
+        this.request.offsetId = lastMessage ? lastMessage.id : 0;
+        this.request.offsetDate = lastMessage ? lastMessage.date : 0;
+        this.request.offsetPeer =
+            (_a = this.buffer[this.buffer.length - 1]) === null || _a === void 0 ? void 0 : _a.inputEntity;
+    }
+}
+exports._DialogsIter = _DialogsIter;
+/** @hidden */
+function iterDialogs(client, { limit = undefined, offsetDate = undefined, offsetId = 0, offsetPeer = new tl_1.Api.InputPeerEmpty(), ignorePinned = false, ignoreMigrated = false, folder = undefined, archived = undefined, }) {
+    if (archived != undefined) {
+        folder = archived ? 1 : 0;
+    }
+    return new _DialogsIter(client, limit, {}, {
+        offsetDate,
+        offsetId,
+        offsetPeer,
+        ignorePinned,
+        ignoreMigrated,
+        folder,
+    });
+}
+/** @hidden */
+async function getDialogs(client, params) {
+    return (await client.iterDialogs(params).collect());
+}