@2byte/tgbot-framework 1.0.3 → 1.0.4

package/src/libs/TgSender.ts

@@ -0,0 +1,53 @@
+import {
+  TelegramAccountRemote,
+  TelegramManagerCredentials,
+  TelegramCredentials,
+} from "./TelegramAccountControl";
+
+interface TgSenderParams {
+  tgAppId: string;
+  tgAppHash: string;
+  app: any;
+}
+
+export class TgSender {
+  private makeInstanceTgRemoteControl: () => {
+    remoteControl: TelegramAccountRemote;
+    credentialsManager: TelegramManagerCredentials;
+  };
+
+  static init(params: TgSenderParams) {
+    return new TgSender(params);
+  }
+
+  constructor(private params: TgSenderParams) {
+    this.makeInstanceTgRemoteControl = () => {
+      const credentialsManager = TelegramManagerCredentials.init({
+        pathFileStorage: path.join(__dirname, "../storage/tg_credentials.json"),
+        pathFileProxyList: path.join(__dirname, "../storage/tg_proxy_list.txt"),
+        pathFileCounterOffset: path.join(__dirname, "../storage/tg_counter_offset.txt"),
+      });
+
+      const remoteControl = TelegramAccountRemote.init({
+        appId: params.tgAppId!,
+        appHash: params.tgAppHash!,
+        credetialsManager: credentialsManager,
+      });
+
+      return {
+        remoteControl,
+        credentialsManager,
+      };
+    };
+  }
+
+  fromRandomAccount() {
+    return this;
+  }
+
+  fromAccountCredentials(credentials: TelegramCredentials) {
+    return this;
+  }
+
+  sendMessageByPhone(phone: string, message: string) {}
+}

package/src/models/Model.ts

@@ -0,0 +1,67 @@
+import type { Database } from "bun:sqlite";
+import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "..";
+import { Section } from "..";
+
+export abstract class Model {
+  protected static db: Database;
+  protected static tableName: string;
+
+  static setDatabase(database: Database) {
+    this.db = database;
+  }
+
+  protected static query(sql: string, params: any[] = []): any {
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+
+  protected static queryOne(sql: string, params: any[] = []): any {
+    const stmt = this.db.prepare(sql);
+    return stmt.get(...params);
+  }
+
+  protected static execute(sql: string, params: any[] = []): void {
+    const stmt = this.db.prepare(sql);
+    stmt.run(...params);
+  }
+
+  protected static transaction<T>(callback: () => T): T {
+    return this.db.transaction(callback)();
+  }
+
+  public static async paginate(paginateParams: ModelPaginateParams): Promise<PaginateResult> {
+    const { page, route, routeParams, limit, whereSql, whereParams } = paginateParams;
+    const offset = (page - 1) * limit;
+    const sql = `SELECT * FROM ${this.tableName} ${whereSql} LIMIT ${offset}, ${limit}`;
+
+    const result = await this.query(sql, whereParams);
+    const queryTotal = await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} ${whereSql}`, whereParams);
+    const total = queryTotal ? queryTotal.count : 0;
+    const totalPages = Math.ceil(total / limit);
+    const hasPreviousPage = page > 1;
+    const hasNextPage = page < totalPages;
+    
+    return {
+      items: result,
+      paginateButtons: Section.makeManualPaginateButtons({
+        callbackDataAction: route,
+        paramsQuery: routeParams || {},
+        currentPage: page,
+        totalRecords: total,
+        perPage: limit,
+      } as MakeManualPaginateButtonsParams),
+      total,
+      totalPages,
+      hasPreviousPage,
+      hasNextPage,
+      currentPage: page,
+    } as PaginateResult;
+  }
+
+  static getConnection(): Database {
+    if (db) {
+      return db;
+    }
+    throw new Error("Database connection is not set.");
+  }
+}

package/src/models/Proxy.ts

@@ -0,0 +1,218 @@
+import { Model } from "./Model";
+
+export interface ProxyData {
+  /** PRIMARY KEY */
+  id?: number;
+  ip: string;
+  port: number;
+  username?: string | null;
+  password?: string | null;
+  secret?: string | null;
+  socksType?: number | null; // 4 or 5
+  MTProxy?: number; // 0 or 1
+  status?: number; // 0 = inactive, 1 = active
+  source?: string | null; // Note: keeping original typo from migration
+  last_check?: string | null;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export enum ProxyStatus {
+  INACTIVE = 0,
+  ACTIVE = 1
+}
+
+export enum ProxySocksType {
+  SOCKS4 = 4,
+  SOCKS5 = 5
+}
+
+export class Proxy extends Model {
+  static tableName = 'proxy';
+
+  /**
+   * Создать новый прокси
+   */
+  static async create(data: ProxyData): Promise<number> {
+    const {
+      ip,
+      port,
+      username = null,
+      password = null,
+      secret = null,
+      socksType = null,
+      MTProxy = 0,
+      status = ProxyStatus.INACTIVE,
+      source: souurce = null,
+      last_check = null,
+    } = data;
+
+    const stmt = this.db.prepare(
+      `INSERT INTO ${this.tableName} 
+       (ip, port, username, password, secret, socksType, MTProxy, status, souurce, last_check) 
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    
+    const result = stmt.run(ip, port, username, password, secret, socksType, MTProxy, status, souurce, last_check);
+    return result.lastInsertRowid as number;
+  }
+
+  /**
+   * Найти прокси по ID
+   */
+  static async findById(id: number): Promise<ProxyData | null> {
+    return this.queryOne(`SELECT * FROM ${this.tableName} WHERE id = ?`, [id]);
+  }
+
+  /**
+   * Найти прокси по IP и порту
+   */
+  static async findByIpPort(ip: string, port: number): Promise<ProxyData | null> {
+    return this.queryOne(`SELECT * FROM ${this.tableName} WHERE ip = ? AND port = ?`, [ip, port]);
+  }
+
+  /**
+   * Получить все активные прокси
+   */
+  static async getActive(): Promise<ProxyData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE status = ? ORDER BY last_check DESC`, [ProxyStatus.ACTIVE]);
+  }
+
+  /**
+   * Получить все прокси
+   */
+  static async getAll(): Promise<ProxyData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} ORDER BY created_at DESC`);
+  }
+
+  /**
+   * Получить прокси по типу SOCKS
+   */
+  static async getBySocksType(socksType: ProxySocksType): Promise<ProxyData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE socksType = ? AND status = ? ORDER BY last_check DESC`, 
+      [socksType, ProxyStatus.ACTIVE]);
+  }
+
+  /**
+   * Получить MTProxy прокси
+   */
+  static async getMTProxies(): Promise<ProxyData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE MTProxy = 1 AND status = ? ORDER BY last_check DESC`, 
+      [ProxyStatus.ACTIVE]);
+  }
+
+  /**
+   * Обновить статус прокси
+   */
+  static async updateStatus(id: number, status: ProxyStatus): Promise<void> {
+    this.execute(`UPDATE ${this.tableName} SET status = ? WHERE id = ?`, [status, id]);
+  }
+
+  /**
+   * Обновить время последней проверки
+   */
+  static async updateLastCheck(id: number, lastCheck: string = new Date().toISOString()): Promise<void> {
+    this.execute(`UPDATE ${this.tableName} SET last_check = ? WHERE id = ?`, [lastCheck, id]);
+  }
+
+  /**
+   * Обновить данные прокси
+   */
+  static async update(id: number, data: Partial<ProxyData>): Promise<void> {
+    const fields = Object.keys(data).filter(key => key !== 'id');
+    const values = fields.map(field => data[field as keyof ProxyData]);
+    
+    if (fields.length === 0) return;
+
+    const setClause = fields.map(field => `${field} = ?`).join(', ');
+    this.execute(`UPDATE ${this.tableName} SET ${setClause} WHERE id = ?`, [...values, id]);
+  }
+
+  /**
+   * Удалить прокси
+   */
+  static async delete(id: number): Promise<void> {
+    this.execute(`DELETE FROM ${this.tableName} WHERE id = ?`, [id]);
+  }
+
+  /**
+   * Проверить, существует ли прокси
+   */
+  static async exists(ip: string, port: number): Promise<boolean> {
+    const result = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE ip = ? AND port = ?`, [ip, port]);
+    return result.count > 0;
+  }
+
+  /**
+   * Получить количество прокси по статусу
+   */
+  static async getCountByStatus(status: ProxyStatus): Promise<number> {
+    const result = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [status]);
+    return result.count;
+  }
+
+  /**
+   * Получить случайный активный прокси
+   */
+  static async getRandomActive(): Promise<ProxyData | null> {
+    return this.queryOne(`SELECT * FROM ${this.tableName} WHERE status = ? ORDER BY RANDOM() LIMIT 1`, [ProxyStatus.ACTIVE]);
+  }
+
+  /**
+   * Массовое добавление прокси
+   */
+  static async bulkCreate(proxies: ProxyData[]): Promise<number[]> {
+    const ids: number[] = [];
+    
+    this.transaction(() => {
+      for (const proxy of proxies) {
+        const id = this.create(proxy);
+        ids.push(id as any);
+      }
+    });
+
+    return ids;
+  }
+
+  /**
+   * Деактивировать все прокси
+   */
+  static async deactivateAll(): Promise<void> {
+    this.execute(`UPDATE ${this.tableName} SET status = ?`, [ProxyStatus.INACTIVE]);
+  }
+
+  /**
+   * Поиск прокси по источнику
+   */
+  static async findBySource(source: string): Promise<ProxyData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE souurce = ? ORDER BY created_at DESC`, [source]);
+  }
+
+  /**
+   * Получить статистику по прокси
+   */
+  static async getStats(): Promise<{
+    total: number;
+    active: number;
+    inactive: number;
+    socks4: number;
+    socks5: number;
+    mtproxy: number;
+  }> {
+    const total = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName}`).count;
+    const active = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [ProxyStatus.ACTIVE]).count;
+    const inactive = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [ProxyStatus.INACTIVE]).count;
+    const socks4 = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE socksType = ?`, [ProxySocksType.SOCKS4]).count;
+    const socks5 = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE socksType = ?`, [ProxySocksType.SOCKS5]).count;
+    const mtproxy = this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE MTProxy = 1`).count;
+
+    return {
+      total,
+      active,
+      inactive,
+      socks4,
+      socks5,
+      mtproxy
+    };
+  }
+}

package/src/models/TgAccount.ts

@@ -0,0 +1,362 @@
+import { Model } from "./Model";
+
+export interface AccountData {
+  /** PRIMARY KEY */
+  id?: number;
+  /** UNIQUE */
+  phone: string;
+  session?: string | null;
+  password?: string | null;
+  country?: string | null;
+  proxy_id?: number | null; // Foreign key to proxy table
+  status?: number;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export enum TgAccountStatus {
+  INACTIVE = 0,
+  ACTIVE = 1,
+  BANNED = 2,
+}
+
+export class TgAccount extends Model {
+  static tableName = 'tg_accounts';
+
+  /**
+   * Создать новый аккаунт
+   */
+  static async create(data: AccountData): Promise<void> {
+    const {
+      phone,
+      session = null,
+      password = null,
+      country = null,
+      proxy_id = null,
+      status = 0,
+    } = data;
+
+    await this.execute(
+      `INSERT INTO ${this.tableName} 
+       (phone, session, password, country, proxy_id, status) 
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [phone, session, password, country, proxy_id, status]
+    );
+  }
+
+  /**
+   * Найти аккаунт по номеру телефона
+   */
+  static async findByPhone(phone: string): Promise<AccountData | null> {
+    return this.queryOne(`SELECT * FROM ${this.tableName} WHERE phone = ?`, [phone]);
+  }
+
+  /**
+   * Найти аккаунт по ID
+   */
+  static async findById(id: number): Promise<AccountData | null> {
+    return this.queryOne(`SELECT * FROM ${this.tableName} WHERE id = ?`, [id]);
+  }
+
+  /**
+   * Обновить сессию аккаунта
+   */
+  static async updateSession(phone: string, session: string): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET session = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [session, phone]
+    );
+  }
+
+  /**
+   * Обновить пароль аккаунта
+   */
+  static async updatePassword(phone: string, password: string): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET password = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [password, phone]
+    );
+  }
+
+  /**
+   * Обновить страну аккаунта
+   */
+  static async updateCountry(phone: string, country: string): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET country = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [country, phone]
+    );
+  }
+
+  /**
+   * Обновить прокси аккаунта
+   */
+  static async updateProxy(phone: string, proxy_id: number | null): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET proxy_id = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [proxy_id, phone]
+    );
+  }
+
+  /**
+   * Обновить статус аккаунта
+   */
+  static async updateStatus(phone: string, status: number): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET status = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [status, phone]
+    );
+  }
+
+  /**
+   * Универсальный метод обновления любых полей
+   */
+  static async update(phone: string, fields: Partial<Omit<AccountData, "phone" | "id">>): Promise<void> {
+    const keys = Object.keys(fields);
+    if (keys.length === 0) return;
+
+    const setClause = keys.map(k => `${k} = ?`).join(", ");
+    const values = keys.map(k => (fields as any)[k]);
+
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET ${setClause}, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [...values, phone]
+    );
+  }
+
+  /**
+   * Вставка или обновление аккаунта (upsert)
+   */
+  static async upsert(data: AccountData): Promise<void> {
+    const {
+      phone,
+      session = null,
+      password = null,
+      country = null,
+      proxy_id = null,
+      status = 0,
+    } = data;
+
+    await this.execute(
+      `INSERT INTO ${this.tableName} 
+       (phone, session, password, country, proxy_id, status) 
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(phone) DO UPDATE 
+       SET session = excluded.session,
+           password = excluded.password,
+           country = excluded.country,
+           proxy_id = excluded.proxy_id,
+           status = excluded.status,
+           updated_at = CURRENT_TIMESTAMP`,
+      [phone, session, password, country, proxy_id, status]
+    );
+  }
+
+  /**
+   * Получить все аккаунты
+   */
+  static async getAll(): Promise<AccountData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} ORDER BY created_at DESC`);
+  }
+
+  /**
+   * Удалить аккаунт
+   */
+  static async delete(phone: string): Promise<void> {
+    await this.execute(`DELETE FROM ${this.tableName} WHERE phone = ?`, [phone]);
+  }
+
+  /**
+   * Получить количество аккаунтов
+   */
+  static async count(): Promise<number> {
+    const result: { count: number } = await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName}`);
+    return result.count;
+  }
+
+  static async countActive(): Promise<number> {
+    const result: { count: number } = await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = 1`);
+    return result.count;
+  }
+
+  /**
+   * Получить следующий свободный аккаунт
+   */
+  static async getNextAvailable(): Promise<AccountData | null> {
+    return this.queryOne(`
+      SELECT a.* FROM ${this.tableName} a
+      LEFT JOIN report_tasks rt ON a.phone = rt.account_phone AND rt.status = 'pending'
+      WHERE rt.id IS NULL
+      LIMIT 1
+    `);
+  }
+
+  /**
+   * Получить аккаунты с прокси
+   */
+  static async getWithProxy(): Promise<AccountData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE proxy_id IS NOT NULL ORDER BY created_at DESC`);
+  }
+
+  /**
+   * Получить аккаунты без прокси
+   */
+  static async getWithoutProxy(): Promise<AccountData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE proxy_id IS NULL ORDER BY created_at DESC`);
+  }
+
+  /**
+   * Получить аккаунт с информацией о прокси (JOIN)
+   */
+  static async findWithProxy(phone: string): Promise<(AccountData & { proxy?: any }) | null> {
+    return this.queryOne(`
+      SELECT 
+        a.*,
+        p.ip as proxy_ip,
+        p.port as proxy_port,
+        p.username as proxy_username,
+        p.password as proxy_password,
+        p.secret as proxy_secret,
+        p.socksType as proxy_socksType,
+        p.MTProxy as proxy_MTProxy,
+        p.status as proxy_status,
+        p.source as proxy_source
+      FROM ${this.tableName} a
+      LEFT JOIN proxy p ON a.proxy_id = p.id
+      WHERE a.phone = ?
+    `, [phone]);
+  }
+
+  /**
+   * Получить все аккаунты с информацией о прокси (JOIN)
+   */
+  static async getAllWithProxy(): Promise<(AccountData & { proxy?: any })[]> {
+    return this.query(`
+      SELECT 
+        a.*,
+        p.ip as proxy_ip,
+        p.port as proxy_port,
+        p.username as proxy_username,
+        p.password as proxy_password,
+        p.secret as proxy_secret,
+        p.socksType as proxy_socksType,
+        p.MTProxy as proxy_MTProxy,
+        p.status as proxy_status,
+        p.source as proxy_source
+      FROM ${this.tableName} a
+      LEFT JOIN proxy p ON a.proxy_id = p.id
+      ORDER BY a.created_at DESC
+    `);
+  }
+
+  /**
+   * Привязать прокси к аккаунту
+   */
+  static async assignProxy(phone: string, proxyId: number): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET proxy_id = ?, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [proxyId, phone]
+    );
+  }
+
+  /**
+   * Отвязать прокси от аккаунта
+   */
+  static async unassignProxy(phone: string): Promise<void> {
+    await this.execute(
+      `UPDATE ${this.tableName} 
+       SET proxy_id = NULL, updated_at = CURRENT_TIMESTAMP 
+       WHERE phone = ?`,
+      [phone]
+    );
+  }
+
+  /**
+   * Получить аккаунты по статусу
+   */
+  static async getByStatus(status: number): Promise<AccountData[]> {
+    return this.query(`SELECT * FROM ${this.tableName} WHERE status = ? ORDER BY created_at DESC`, [status]);
+  }
+
+  /**
+   * Получить активные аккаунты
+   */
+  static async getActive(): Promise<AccountData[]> {
+    return this.getByStatus(TgAccountStatus.ACTIVE);
+  }
+
+  /**
+   * Получить заблокированные аккаунты
+   */
+  static async getBanned(): Promise<AccountData[]> {
+    return this.getByStatus(TgAccountStatus.BANNED);
+  }
+
+  /**
+   * Проверить существование аккаунта
+   */
+  static async exists(phone: string): Promise<boolean> {
+    const result: { count: number } = await this.queryOne(
+      `SELECT COUNT(*) as count FROM ${this.tableName} WHERE phone = ?`,
+      [phone]
+    );
+    return result.count > 0;
+  }
+
+  /**
+   * Получить статистику аккаунтов
+   */
+  static async getStats(): Promise<{
+    total: number;
+    active: number;
+    banned: number;
+    inactive: number;
+    withProxy: number;
+    withoutProxy: number;
+    withSession: number;
+  }> {
+    const total = await this.count();
+    const active = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [TgAccountStatus.ACTIVE])).count;
+    const banned = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [TgAccountStatus.BANNED])).count;
+    const inactive = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE status = ?`, [TgAccountStatus.INACTIVE])).count;
+    const withProxy = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE proxy_id IS NOT NULL`)).count;
+    const withoutProxy = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE proxy_id IS NULL`)).count;
+    const withSession = (await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} WHERE session IS NOT NULL`)).count;
+
+    return {
+      total,
+      active,
+      banned,
+      inactive,
+      withProxy,
+      withoutProxy,
+      withSession
+    };
+  }
+
+  /**
+   * Получить случайный доступный аккаунт
+   */
+  static async getRandomAvailable(): Promise<AccountData | null> {
+    return this.queryOne(`
+      SELECT * FROM ${this.tableName} 
+      WHERE status = ? AND session IS NOT NULL 
+      ORDER BY RANDOM() 
+      LIMIT 1
+    `, [TgAccountStatus.ACTIVE]);
+  }
+}

package/src/models/index.ts

@@ -0,0 +1,3 @@
+export * from './Model';
+export * from './TgAccount';
+export * from './Proxy';