@2byte/tgbot-framework 1.0.5 → 1.0.7

package/src/user/UserStore.ts

@@ -1,119 +1,119 @@
-import { UserModel } from './UserModel';
-import { UserSession } from '../types';
-import { EnvVars } from '../types';
-
-interface ApiConfig {
-  apiUrl: string;
-}
-
-interface Api {
-  fetch(endpoint: string, method?: string, data?: any): Promise<any>;
-}
-
-export class UserStore {
-  private usersMap: Map<string, UserModel> = new Map();
-  private usersSession: Map<UserModel, UserSession> = new Map();
-  private api: Api | null = null;
-
-  constructor(envConfig?: EnvVars) {
-    if (envConfig) {
-      let url = envConfig.BOT_API_URL || '';
-      
-      // Здесь должна быть инициализация API, но мы оставим это для будущей реализации
-      // this.api = new Api({
-      //   apiUrl: url.endsWith('/') ? url : url + '/',
-      // });
-    }
-  }
-
-  async checkOrRegister(params: { tgUsername: string, tgId: number, tgName: string }): Promise<any> {
-    if (!this.usersMap.has(params.tgUsername) && this.api) {
-      let userData = null;
-
-      try {
-        let resApi = await this.api.fetch('user/get/' + params.tgUsername);
-        userData = resApi.data;
-      } catch (err) {
-        let resApi = await this.api.fetch('user/register', 'post', {
-          tg_username: params.tgUsername,
-          tg_id: params.tgId,
-          name: params.tgName,
-        });
-
-        userData = resApi.data;
-      }
-
-      if (userData !== null) {
-        this.add(params.tgUsername, userData);
-      }
-
-      return userData;
-    }
-    return null;
-  }
-
-  find(tgUsername: string): UserModel {
-    return this.usersMap.get(tgUsername) as UserModel;
-  }
-
-  findSession(userModel: UserModel): UserSession {
-    return this.usersSession.get(userModel) || {};
-  }
-
-  exists(tgUsername: string): boolean {
-    return this.usersMap.has(tgUsername);
-  }
-
-  add(tgUsername: string, data: UserModel | any): boolean {
-    if (data instanceof UserModel) {
-      this.usersMap.set(tgUsername, data);
-    } else {
-      this.usersMap.set(tgUsername, new UserModel(data));
-    }
-    
-    this.usersSession.set(this.usersMap.get(tgUsername) as UserModel, {});
-
-    return true;
-  }
-
-  upActive(tgUsername: string): this {
-    const user = this.usersMap.get(tgUsername);
-    if (user) {
-      user.upActive();
-    }
-    return this;
-  }
-
-  storeMessageId(tgUsername: string, messageId: number, limit: number): this {
-    const user = this.usersMap.get(tgUsername);
-    if (user) {
-      user.storeMessageId(messageId, limit);
-    }
-    return this;
-  }
-
-  getLastMessageId(tgUsername: string): number | undefined {
-    const user = this.usersMap.get(tgUsername);
-    if (user) {
-      const ids = user.lastMessageIds;
-      return ids.length ? ids[ids.length - 1] : undefined;
-    }
-    return undefined;
-  }
-
-  autocleanup(minutes: number = 1): void {
-    const getNotActiveUsers = (): [string, UserModel][] => {
-      return Array.from(this.usersMap).filter(([tgUsername, data]) => {
-        return (
-          data.serviceAttributes.lastActive.getTime() <= Date.now() - minutes * 60 * 1000
-        );
-      });
-    };
-
-    setInterval(() => {
-      getNotActiveUsers().forEach(([tgUsername]) => {
-        this.usersMap.delete(tgUsername);
-      });
-    }, 60 * 1000);
-  }
-}
+import { UserModel } from './UserModel';
+import { UserSession } from '../types';
+import { EnvVars } from '../types';
+
+interface ApiConfig {
+  apiUrl: string;
+}
+
+interface Api {
+  fetch(endpoint: string, method?: string, data?: any): Promise<any>;
+}
+
+export class UserStore {
+  private usersMap: Map<string, UserModel> = new Map();
+  private usersSession: Map<UserModel, UserSession> = new Map();
+  private api: Api | null = null;
+
+  constructor(envConfig?: EnvVars) {
+    if (envConfig) {
+      let url = envConfig.BOT_API_URL || '';
+      
+      // Здесь должна быть инициализация API, но мы оставим это для будущей реализации
+      // this.api = new Api({
+      //   apiUrl: url.endsWith('/') ? url : url + '/',
+      // });
+    }
+  }
+
+  async checkOrRegister(params: { tgUsername: string, tgId: number, tgName: string }): Promise<any> {
+    if (!this.usersMap.has(params.tgUsername) && this.api) {
+      let userData = null;
+
+      try {
+        let resApi = await this.api.fetch('user/get/' + params.tgUsername);
+        userData = resApi.data;
+      } catch (err) {
+        let resApi = await this.api.fetch('user/register', 'post', {
+          tg_username: params.tgUsername,
+          tg_id: params.tgId,
+          name: params.tgName,
+        });
+
+        userData = resApi.data;
+      }
+
+      if (userData !== null) {
+        this.add(params.tgUsername, userData);
+      }
+
+      return userData;
+    }
+    return null;
+  }
+
+  find(tgUsername: string): UserModel {
+    return this.usersMap.get(tgUsername) as UserModel;
+  }
+
+  findSession(userModel: UserModel): UserSession {
+    return this.usersSession.get(userModel) || {};
+  }
+
+  exists(tgUsername: string): boolean {
+    return this.usersMap.has(tgUsername);
+  }
+
+  add(tgUsername: string, data: UserModel | any): boolean {
+    if (data instanceof UserModel) {
+      this.usersMap.set(tgUsername, data);
+    } else {
+      this.usersMap.set(tgUsername, new UserModel(data));
+    }
+    
+    this.usersSession.set(this.usersMap.get(tgUsername) as UserModel, {});
+
+    return true;
+  }
+
+  upActive(tgUsername: string): this {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      user.upActive();
+    }
+    return this;
+  }
+
+  storeMessageId(tgUsername: string, messageId: number, limit: number): this {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      user.storeMessageId(messageId, limit);
+    }
+    return this;
+  }
+
+  getLastMessageId(tgUsername: string): number | undefined {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      const ids = user.lastMessageIds;
+      return ids.length ? ids[ids.length - 1] : undefined;
+    }
+    return undefined;
+  }
+
+  autocleanup(minutes: number = 1): void {
+    const getNotActiveUsers = (): [string, UserModel][] => {
+      return Array.from(this.usersMap).filter(([tgUsername, data]) => {
+        return (
+          data.serviceAttributes.lastActive.getTime() <= Date.now() - minutes * 60 * 1000
+        );
+      });
+    };
+
+    setInterval(() => {
+      getNotActiveUsers().forEach(([tgUsername]) => {
+        this.usersMap.delete(tgUsername);
+      });
+    }, 60 * 1000);
+  }
+}

package/src/workflow/services/MassSendApiService.ts

@@ -1,80 +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);
-                    }
-                }
-            }
-        }
-    }
-}
+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);
+                    }
+                }
+            }
+        }
+    }
+}

package/templates/bot/.env.example

@@ -1,23 +1,34 @@
-# Переменные окружения для {{className}} Bot
-
-# Токен бота от @BotFather
-BOT_TOKEN=your_bot_token_here
-
-# Путь к базе данных
-DATABASE_PATH=./database/database.sqlite
-
-# Настройки логирования
-LOG_LEVEL=info
-
-BOT_APP_API_PORT=3033
-BOT_API_URL=https://localhost:3000
-APP_ENV=local
-BOT_DEV_HOT_RELOAD_SECTIONS=true
-BOT_ACCESS=public
-BOT_ACCESS_KEYS=
-ACCESS_USERNAMES=stork0
-BOT_HOOK_DOMAIN=example.com
-BOT_HOOK_PORT=3000
-
-TG_APP_ID=
-TG_APP_HASH=
+# Environment variables for Rewardbot Bot
+
+# token from @BotFather
+BOT_TOKEN=8333709720:AAEk3AzAmt1JS0XQJQWqUDI
+
+# Path to the database
+DATABASE_PATH=./database/database.sqlite
+
+# log level: error, warn, info, debug
+LOG_LEVEL=info
+
+# port for the bot's application server
+BOT_APP_API_PORT=3033
+# Port for the bot's API server
+BOT_API_URL=https://localhost:3000
+APP_ENV=local
+# enable hot reload for development sections
+BOT_DEV_HOT_RELOAD_SECTIONS=true
+# Bot access mode: public or private
+BOT_ACCESS=private
+# Comma-separated list of access keys for private bot access
+BOT_ACCESS_KEYS=
+# Comma-separated list of Telegram usernames allowed to access the bot (without @)
+ACCESS_USERNAMES=
+# Domain and port for webhook setup
+BOT_HOOK_DOMAIN=example.com
+# Port for webhook setup
+BOT_HOOK_PORT=3000
+# URL for gift page
+GIFT_PAGE=https://reward.com
+
+# Telegram API credentials
+TG_APP_ID=2040
+TG_APP_HASH=b18441a1ff607e10a989891a5462e627

package/templates/bot/artisan.ts

@@ -1,9 +1,9 @@
-#!/usr/bin/env node
-import { BotArtisan } from '@2byte/tgbot-framework';
-
-const artisan = new BotArtisan(__dirname, {
-  botName: '{{botName}}',
-  sectionsPath: './sections'
-});
-
+#!/usr/bin/env node
+import { BotArtisan } from '@2byte/tgbot-framework';
+
+const artisan = new BotArtisan(__dirname, {
+  botName: '{{botName}}',
+  sectionsPath: './sections'
+});
+
 artisan.run();

package/templates/bot/bot.ts

@@ -1,82 +1,82 @@
-import { App } from '@2byte/tgbot-framework';
-import { UserStore } from "@2byte/tgbot-framework";
-import { sectionList } from "./sectionList";
-import { Database } from 'bun:sqlite';
-import { EnvVars } from "@2byte/tgbot-framework";
-
-if (import.meta.dirname === undefined) {
-  throw new Error("import.meta.dirname is not defined. Ensure you are using a module environment.");
-}
-
-// check if the environment is set up correctly
-const requiredEnvVars: (keyof EnvVars)[] = [
-  "BOT_TOKEN",
-  "BOT_API_URL",
-  "BOT_HOOK_DOMAIN",
-  "BOT_HOOK_PORT",
-  "BOT_ACCESS",
-  "ACCESS_USERNAMES",
-  "BOT_ACCESS_KEYS",
-  "BOT_APP_API_PORT",
-  "TG_APP_ID",
-  "TG_APP_HASH",
-];
-for (const envVar of requiredEnvVars) {
-  if (!process.env[envVar]) {
-    throw new Error(`${envVar} is not set in the environment variables.`);
-  }
-}
-
-declare global {
-  var userStorage: UserStore;
-  var db: Database;
-  var settings: Record<string, any>;
-}
-
-// Initialize global variables
-global.userStorage = new UserStore(process.env as EnvVars);
-global.db = new Database(import.meta.dirname +'/database/database.sqlite');
-global.settings = {
-  paging: {
-    taskListPerPage: 3, // Number items per page
-  }
-};
-
-// Autoclean storage user by timeout
-userStorage.autocleanup(10);
-
-const appController = new App.Builder()
-  .botCwd(import.meta.dirname)
-  .envConfig(process.env as EnvVars)
-  .botToken(process.env.BOT_TOKEN as string)
-  .telegrafConfigLaunch({
-    // webhook: {
-    //   // Public domain for webhook; e.g.: example.com
-    //   domain: process.env.BOT_HOOK_DOMAIN,
-    //   // Port to listen on; e.g.: 8080
-    //   port: +process.env.BOT_HOOK_PORT,
-    //   // Path to listen on nginx
-    //   path: "/super-mega-tgbot",
-    //   secretToken: process.env.BOT_HOOK_SECRET_TOKEN,
-    // },
-  })
-  .accessPublic(process.env.BOT_ACCESS === "public")
-  .apiUrl(process.env.BOT_API_URL as string)
-  .settings(settings)
-  .userStorage(userStorage)
-  .sections(sectionList)
-  .keepSectionInstances(true)
-  .debug()
-  //.telegrafLog()
-  .devHotReloadSections(process.env.BOT_DEV_HOT_RELOAD_SECTIONS === "true")
-  .mainMenuKeyboard([
-    ["🏠 Лобби"],
-  ])
-  .hears({
-    "🏠 Лобби": "home",
-  })      
-  .terminateSigInt()
-  .terminateSigTerm()
-  .build();
-
-(await appController.init()).launch();
+import { App } from '@2byte/tgbot-framework';
+import { UserStore } from "@2byte/tgbot-framework";
+import { sectionList } from "./sectionList";
+import { Database } from 'bun:sqlite';
+import { EnvVars } from "@2byte/tgbot-framework";
+
+if (import.meta.dirname === undefined) {
+  throw new Error("import.meta.dirname is not defined. Ensure you are using a module environment.");
+}
+
+// check if the environment is set up correctly
+const requiredEnvVars: (keyof EnvVars)[] = [
+  "BOT_TOKEN",
+  "BOT_API_URL",
+  "BOT_HOOK_DOMAIN",
+  "BOT_HOOK_PORT",
+  "BOT_ACCESS",
+  "ACCESS_USERNAMES",
+  "BOT_ACCESS_KEYS",
+  "BOT_APP_API_PORT",
+  "TG_APP_ID",
+  "TG_APP_HASH",
+];
+for (const envVar of requiredEnvVars) {
+  if (!process.env[envVar]) {
+    throw new Error(`${envVar} is not set in the environment variables.`);
+  }
+}
+
+declare global {
+  var userStorage: UserStore;
+  var db: Database;
+  var settings: Record<string, any>;
+}
+
+// Initialize global variables
+global.userStorage = new UserStore(process.env as EnvVars);
+global.db = new Database(import.meta.dirname +'/database/database.sqlite');
+global.settings = {
+  paging: {
+    taskListPerPage: 3, // Number items per page
+  }
+};
+
+// Autoclean storage user by timeout
+userStorage.autocleanup(10);
+
+const appController = new App.Builder()
+  .botCwd(import.meta.dirname)
+  .envConfig(process.env as EnvVars)
+  .botToken(process.env.BOT_TOKEN as string)
+  .telegrafConfigLaunch({
+    // webhook: {
+    //   // Public domain for webhook; e.g.: example.com
+    //   domain: process.env.BOT_HOOK_DOMAIN,
+    //   // Port to listen on; e.g.: 8080
+    //   port: +process.env.BOT_HOOK_PORT,
+    //   // Path to listen on nginx
+    //   path: "/super-mega-tgbot",
+    //   secretToken: process.env.BOT_HOOK_SECRET_TOKEN,
+    // },
+  })
+  .accessPublic(process.env.BOT_ACCESS === "public")
+  .apiUrl(process.env.BOT_API_URL as string)
+  .settings(settings)
+  .userStorage(userStorage)
+  .sections(sectionList)
+  .keepSectionInstances(true)
+  .debug()
+  //.telegrafLog()
+  .devHotReloadSections(process.env.BOT_DEV_HOT_RELOAD_SECTIONS === "true")
+  .mainMenuKeyboard([
+    ["🏠 Лобби"],
+  ])
+  .hears({
+    "🏠 Лобби": "home",
+  })      
+  .terminateSigInt()
+  .terminateSigTerm()
+  .build();
+
+(await appController.init()).launch();

package/templates/bot/database/dbConnector.ts

@@ -1,5 +1,5 @@
-import { Database } from 'bun:sqlite';
-
-export default () => {
-    return new Database(import.meta.dirname + '/database.sqlite');
+import { Database } from 'bun:sqlite';
+
+export default () => {
+    return new Database(import.meta.dirname + '/database.sqlite');
 }

package/templates/bot/database/migrate.ts

@@ -1,10 +1,10 @@
-import { BotMigration } from '@2byte/tgbot-framework';
-import path from 'path';
-
-const migration = new BotMigration({
-  botPath: __dirname,
-  migrationsPath: path.join(__dirname, 'migrations'),
-  databasePath: path.join(__dirname, 'database.sqlite')
-});
-
+import { BotMigration } from '@2byte/tgbot-framework';
+import path from 'path';
+
+const migration = new BotMigration({
+  botPath: __dirname,
+  migrationsPath: path.join(__dirname, 'migrations'),
+  databasePath: path.join(__dirname, 'database.sqlite')
+});
+
 migration.run();