kun-web/src/telegram/telegram.ts

import Client from "mtproton/envs/browser";
import { rand_id } from "../utils/rand";
import { obj } from "../utils/log";

class TelegramHelper {
  private client: any;
  constructor(appID: number, appHash: string) {
    this.client = new Client({
      api_id: appID,
      api_hash: appHash,
      test: true,
    });
    this.client.setDefaultDc(1);
  }

  async call(method: string, params?: object, options?: object): Promise<any> {
    try {
      console.dir(`${method} req\n${obj(params)}`);
      let resp = await this.client.call(method, params, options);
      console.dir(`${method} resp\n${obj(resp)}`);
      return resp;
    } catch (error) {
      console.log(`${method} error:`, error);

      // @ts-ignore
      const { error_code, error_message } = error;

      // if (error_code === 420) {
      //   const seconds = Number(error_message.split('FLOOD_WAIT_')[1]);
      //   const ms = seconds * 1000;
      //
      //   await sleep(ms);
      //
      //   return this.call(method, params, options);
      // }

      if (error_code === 303) {
        const [type, dcIdAsString] = error_message.split("_MIGRATE_");

        const dcId = Number(dcIdAsString);

        // if (type === "PHONE") {
        await this.client.setDefaultDc(dcId);
        // } else {
        //   Object.assign(options, { dcId });
        // }

        return this.call(method, params, options);
      }
      return Promise.reject(error);
    }
  }
}

async function uploadBigFile(
  bytes: ArrayBuffer
): Promise<{ file_id: number; total_part: number }> {
  let file_id = rand_id();
  console.log("file_id", file_id);

  let uploadBytes = new Uint8Array(bytes);
  console.log("uploading file", bytes);
  const file_total_parts = Math.ceil(uploadBytes.length / 524288);
  console.log("file_total_parts", file_total_parts);
  for (let i = 0; i < file_total_parts; i++) {
    console.log("push part: ", i);
    try {
      let tempBytes = uploadBytes.slice(i * 524288, (i + 1) * 524288);
      if (i === file_total_parts - 1) {
        tempBytes = uploadBytes.slice(i * 524288);
      }
      console.log("tempBytes", tempBytes);
      let finished = await Telegram.call("upload.saveBigFilePart", {
        file_id: file_id,
        file_part: i,
        file_total_parts: file_total_parts,
        bytes: tempBytes,
      });
      if (finished) {
        console.log("finished");
      } else {
        console.log("not finished");
      }
    } catch (error) {
      return Promise.reject(error);
    }
  }

  console.log("uploaded");
  return { file_id: file_id, total_part: file_total_parts };
}

function inputFile(file_id: number, part_number: number, file_name: string) {
  return {
    _: "inputFileBig",
    id: file_id,
    parts: part_number,
    name: file_name,
  };
}

function sendFile(inputFile: any, type: string) {
  let random_id = rand_id();
  console.log("random_id", random_id);
  return Telegram.call("messages.sendMedia", {
    peer: {
      _: "inputPeerSelf",
    },
    media: {
      _: "inputMediaUploadedDocument",
      file: inputFile,
      mime_type: type,
      attributes: [
        {
          _: "documentAttributeFilename",
          file_name: inputFile.name,
        },
      ],
    },
    random_id: rand_id(),
    message: "test",
  });
}

async function downloadFile(fileDocument: any) {
  let partSize = 1024 * 1024;
  const file_total_parts = Math.ceil(fileDocument.document.size / partSize);

  let results = [];
  for (let i = 0; i < file_total_parts; i++) {
    try {
      let result = await Telegram.call("upload.getFile", {
        location: {
          _: "inputDocumentFileLocation",
          id: fileDocument.document.id,
          access_hash: fileDocument.document.access_hash,
          file_reference: fileDocument.document.file_reference,
          thumb_size: "",
        },
        limit: partSize,
        offset: partSize * i,
      });
      console.log("result", result);
      results.push(result);
    } catch (error) {
      return Promise.reject(error);
    }
  }

  console.log("messages.getDocument:", results);
  let bytes = new Uint8Array(fileDocument.document.size);
  for (let i = 0; i < results.length; i++) {
    for (let j = 0; j < results[i].bytes.length; j++) {
      bytes[i * partSize + j] = results[i].bytes[j];
    }
  }
  let downloadBytes = bytes;
  console.log("downloadBytes", downloadBytes);
  let blob = new Blob([downloadBytes], {
    type: fileDocument.document.mime_type,
  });
  let url = window.URL.createObjectURL(blob);
  let a = document.createElement("a");
  a.href = url;
  a.download = fileDocument.document.attributes[0].file_name;
  a.click();
  return Promise.resolve(true);
}

async function sendSignInCode(phone: string): Promise<string> {
  try {
    let result = await Telegram.call("auth.sendCode", {
      phone_number: phone,
      settings: {
        _: "codeSettings",
      },
    });
    return Promise.resolve(result.phone_code_hash);
  } catch (error: any) {
    return Promise.reject(error);
  }
}

async function signIn(phone: string, code: string, phone_code_hash: string) {
  try {
    let result = await Telegram.call("auth.signIn", {
      phone_number: phone,
      phone_code_hash: phone_code_hash,
      phone_code: code,
    });
    return Promise.resolve(result);
  } catch (error: any) {
    return Promise.reject(error);
  }
}

const appID = 18987971;
const appHash = "fcfd9e6ed3f9e48a360bb57cc0d59d98";
let Telegram = new TelegramHelper(appID, appHash);

export default Telegram;
export {
  uploadBigFile,
  inputFile,
  sendFile,
  downloadFile,
  sendSignInCode,
  signIn,
};