@2byte/tgbot-framework 1.0.2 → 1.0.4

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';

package/src/types.ts

@@ -23,6 +23,7 @@ export interface AppConfig {
   terminateSigInt: boolean;
   terminateSigTerm: boolean;
   keepSectionInstances: boolean;
+  botCwd: string;
 }
 
 export interface SectionOptions {
@@ -155,8 +156,12 @@ export interface EnvVars {
   BOT_HOOK_SECRET_TOKEN?: string;
   BOT_DEV_HOT_RELOAD_SECTIONS?: string;
   BOT_ACCESS?: 'private' | 'public';
+  BOT_ACCESS_KEYS?: string; // comma separated access keys
   ACCESS_USERNAMES?: string; // comma separated usernames
-  [key: string]: string | undefined;
+  BOT_APP_API_PORT?: number;
+  TG_APP_ID?: string;
+  TG_APP_HASH?: string;
+  [key: string]: string | number |undefined;
 }
 
 export type ModelPaginateParams = {

package/src/user/UserModel.ts

@@ -17,6 +17,11 @@ export class UserModel extends Model {
     this.attributes = attributes;
   }
 
+  static getAll(): UserModel[] {
+    const usersData = this.query(`SELECT * FROM ${this.tableName}`);
+    return usersData.map((data: any) => UserModel.make(data));
+  }
+
   setSessionStorage(storage: UserStore): this {
     this.userSession = storage;
     return this;
@@ -191,6 +196,10 @@ export class UserModel extends Model {
     return this.attributes.tg_username;
   }
 
+  get tgId(): number {
+    return this.attributes.tg_id;
+  }
+
   get firstName(): string {
     return this.attributes.tg_first_name;
   }

package/src/workflow/services/MassSendApiService.ts

@@ -0,0 +1,80 @@
+import { ApiService} from '../../core/ApiService';
+import { App } from '../../core/App';
+import { UserModel } from '../../user/UserModel';
+
+export default class MassSendApiService extends ApiService {
+
+    private bunServerInstance: any;
+
+    constructor(
+        protected app: App,
+        public name: string = "MassSendApiService"
+    ) {
+        super(app, name);
+    }
+
+    public async setup(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    public async unsetup(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    public async run(): Promise<void> {
+        this.bunServerInstance = Bun.serve({
+            port: this.app.configApp.envConfig.BOT_APP_API_PORT || 3033,
+            routes: {
+                '/': async (req) => {
+                    const receivedData = (await req.json()) as { userIds?: number[]; message?: string };
+                    this.app.debugLog("Received data for mass message:", receivedData);
+
+                    let userIds: number[] = [];
+                    let message: string = "Hello from MassSendApiService";
+
+                    if (receivedData && typeof receivedData == 'object') {
+                        userIds = receivedData?.userIds || [];
+                        message = receivedData?.message || "Hello from MassSendApiService";
+                    }
+
+                    this.sendMassMessage(userIds, message);
+
+                    return Response.json({ status: 200, body: 'Mass message sending initiated.' });
+                }
+            }
+        });
+
+        this.app.debugLog(`MassSendApiService Bun server running at http://localhost:${this.bunServerInstance.port}/`);
+
+        return Promise.resolve();
+    }
+
+    private async sendMassMessage(userIds: number[] = [], message: string): Promise<void> {
+        if (userIds.length === 0) {
+
+            if (!db) {
+                throw new Error("Database connection is not established.");
+            }
+
+            UserModel.setDatabase(db);
+
+            this.app.debugLog("Fetching all users for mass message...");
+            const users = UserModel.getAll(); 
+
+            this.app.debugLog("Fetched users for mass message:", users);
+
+            if (users && users.length > 0) {
+                for (const user of users) {
+                    this.app.debugLog(`Sending message to user ID: ${user.tgId} username: ${user.username}`);
+
+                    try {
+                        await this.app.bot.telegram.sendMessage(user.tgId, message);
+                        this.app.debugLog(`Message sent to user ID: ${user.tgId} username: ${user.username}`);
+                    } catch (error) {
+                        this.app.debugLog(`Failed to send message to user ID: ${user.tgId} username: ${user.username}`, error);
+                    }
+                }
+            }
+        }
+    }
+}