gramscript stable v1.0.3

Author: kalanakt

package-lock.json

@@ -0,0 +1,54 @@
+/*
+    Get direct answers from user.
+*/
+
+const userList = {};
+
+module.exports = {
+
+    id: 'askUser',
+    defaultConfig: {
+        messageTypes: ['text']
+    },
+
+    plugin(bot, pluginConfig) {
+
+        const indx = pluginConfig.messageTypes.indexOf('*');
+        if (indx > -1) {
+            console.error('ERROR using askUser plugin: type \'*\' is not allowed, it cause a bug. removing');
+            pluginConfig.messageTypes.splice(indx, 1);
+        }
+        if (pluginConfig.messageTypes.length === 0) {
+            console.error('ERROR using askUser plugin: you must specify at least one valid type. adding type \'text\'');
+            pluginConfig.messageTypes.push('text');
+        }
+        // On every message
+        bot.on(pluginConfig.messageTypes, (msg, props) => {
+
+            const id = msg.chat.id;
+            const ask = userList[id];
+
+            // If no question, then it's a regular message
+            if (!ask) return;
+
+            // Delete user from list and send custom event
+            delete userList[id];
+            bot.event('ask.' + ask, msg, props);
+
+        });
+
+        // Before call sendMessage method
+        bot.on('sendMessage', (args) => {
+
+            const id = args[0];
+            const opt = args[2] || {};
+
+            const ask = opt.ask;
+
+            // If "ask" in options, add user to list
+            if (ask) userList[id] = ask;
+
+        });
+
+    }
+};

plugins/askUser.js

@@ -0,0 +1,30 @@
+/*
+    Advanced analytics for your Telegram bot - http://botan.io
+    Requires "botanio" npm package.
+*/
+
+module.exports = {
+
+    id: 'botan',
+    defaultConfig: null,
+
+    plugin(bot, config) {
+
+        // Check AppMetrika key
+        const token = config;
+
+        if (token) {
+
+            // Require botanio
+            const botan = require('botanio')(token);
+
+            // Track every type of message
+            bot.on('*', (msg, props) => botan.track(msg, props.type));
+
+        } else {
+            console.error('[botan] no token key');
+        }
+
+    }
+
+};

plugins/botan.js

@@ -0,0 +1,54 @@
+/*
+    Use commands in buttons.
+*/
+
+module.exports = {
+
+    id: 'commandButton',
+    defaultConfig: {
+        regExpEvents: true
+    },
+
+    plugin(bot, pluginConfig) {
+
+        const {regExpEvents} = pluginConfig;
+
+        bot.on('callbackQuery', (msg, props) => {
+
+            let isAnswered = false;
+            let promise = Promise.resolve();
+
+            const cmd = msg.data;
+
+            if (cmd.charAt(0) == '/') {
+                answerCallback();
+                promise = bot.event(cmd, msg, props);
+            }
+
+            if (regExpEvents) {
+                for (let eventName of bot.eventList.keys()) {
+                    if (eventName instanceof RegExp) {
+                        const match = cmd.match(eventName);
+                        if (match) {
+                            answerCallback();
+                            props.match = match;
+                            promise = promise.then(() => bot.event(eventName, msg, props));
+                        }
+                    }
+                }
+            }
+
+            return promise;
+
+            function answerCallback() {
+                if (!isAnswered) {
+                    bot.answerCallbackQuery(msg.id);
+                    isAnswered = true;
+                }
+            }
+
+        });
+
+    }
+
+};

plugins/commandButton.js

@@ -0,0 +1,56 @@
+/*
+    Simple flood protection plugin.
+    Note: Received Telegram message time accuracy is one second.
+*/
+
+const userList = {};
+
+// Export bot module
+module.exports = {
+
+    id: 'floodProtection',
+    defaultConfig: {
+        interval: 1,
+        message: 'Too many messages, relax!'
+    },
+
+    plugin(bot, pluginConfig) {
+
+        const interval = Number(pluginConfig.interval) || 1;
+        const text = pluginConfig.message;
+
+        bot.mod('message', (data) => {
+
+            const msg = data.message;
+            const id = msg.from.id;
+            const user = userList[id];
+            const now = new Date(msg.date);
+
+            if (user) {
+
+                const diff = now - user.lastTime;
+                user.lastTime = now;
+
+                if (diff <= interval) {
+
+                    if (!user.flood) {
+                        if (text) bot.sendMessage(id, text);
+                        user.flood = true;
+                    }
+
+                    data.message = {};
+
+                } else {
+                    user.flood = false;
+                }
+
+            } else {
+                userList[id] = {lastTime: now};
+            }
+
+            return data;
+
+        });
+
+    }
+};

plugins/floodProtection.js

@@ -0,0 +1,30 @@
+const startDate = {};
+
+module.exports = {
+
+    id: 'ignoreMessagesBeforeStart',
+
+    defaultConfig: {
+        start: true
+    },
+
+    plugin(bot, config) {
+
+        bot.on(config.start ? ['start', '/start'] : 'start', (msg) => {
+            let userId = 'main_bot';
+            if (msg && msg.from) {
+                userId = msg.from.id;
+            }
+            startDate[userId] = Date.now();
+        });
+
+        bot.mod('message', (data) => {
+            const {date, from} = data.message;
+            if (from && (date * 1000 < startDate[from.id] || date * 1000 < startDate.main_bot)) {
+                data.message = {};
+            }
+
+            return data;
+        });
+    }
+};

plugins/ignoreMessagesBeforeStart.js

@@ -0,0 +1,34 @@
+/*
+    Named buttons which triggers bot commands.
+*/
+
+module.exports = {
+
+    id: 'namedButtons',
+    defaultConfig: {
+        buttons: {
+            // myButton: {
+            //     label: '😄 My Button Name',
+            //     command: '/myBotCommand'
+            // }
+        }
+    },
+
+    plugin(bot, pluginConfig) {
+
+        const buttons = pluginConfig.buttons || {};
+
+        bot.on('text', (msg, props) => {
+            const text = msg.text;
+            for (let buttonId in buttons) {
+                const button = buttons[buttonId];
+                if (button.label === text) {
+                    return bot.event(button.command, msg, props);
+                }
+            }
+
+        });
+
+    }
+
+};

plugins/namedButtons.js

@@ -0,0 +1,32 @@
+module.exports = {
+
+    id: 'permissions',
+    defaultConfig: {
+        allowedUserIds: [],
+        allowedChannels: [],
+        message: '⛔ you are not authorized'
+    },
+
+    plugin(bot, pluginConfig) {
+
+        bot.mod('message', (data) => {
+            if (data.message.chat) {
+                if (data.message.chat.type === 'channel') {
+                    const chatId = data.message.chat.id;
+                    if (!pluginConfig.allowedChannels.includes(chatId)) {
+                        data.message = {};
+                        bot.sendMessage(chatId, pluginConfig.message);
+                    }
+                } else {
+                    const userId = data.message.from.id;
+                    if (!pluginConfig.allowedUserIds.includes(userId)) {
+                        data.message = {};
+                        bot.sendMessage(userId, pluginConfig.message);
+                    }
+                }
+            }
+
+            return data;
+        });
+    }
+};

plugins/permissions.js

@@ -0,0 +1,34 @@
+/*
+    Adds RegExp support to text event messages.
+*/
+
+module.exports = {
+
+    id: 'regExpMessage',
+
+    plugin(bot) {
+
+        bot.mod('text', (data) => {
+            const {message, props} = data;
+            const text = message.text;
+
+            let promise = Promise.resolve();
+
+            for (let eventType of bot.eventList.keys()) {
+                if (eventType instanceof RegExp) {
+                    const match = text.match(eventType);
+                    if (match) {
+                        props.match = match;
+                        promise = promise.then(() => bot.event(eventType, message, props));
+                    }
+                }
+            }
+
+            data.promise = promise;
+
+            return data;
+        });
+
+    }
+
+};