initial commit for new modules: filters, notes, locks, and blacklists

src/database/antiflood_sql.ts

@@ -0,0 +1,89 @@
+import { prisma } from ".";
+
+export async function get_flood(chatId: string) {
+ let flood = await prisma.antiflood.findFirst({
+ where: {
+ chat_id: chatId.toString()
+ }
+ })
+ return flood;
+}
+
+export async function get_flood_settings(chatId: string) {
+ let flood_settings = await prisma.antiflood_settings.findUnique({
+ where: {
+ chat_id: chatId.toString()
+ }
+ })
+ return flood_settings;
+}
+
+export async function set_flood(chat_id: string, count: bigint, limit: bigint) {
+ try {
+ let flood = await prisma.antiflood.upsert({
+ where: {
+ chat_id: chat_id,
+ },
+ update: {
+ count: count,
+ limit: limit
+ },
+ create: {
+ chat_id: chat_id,
+ count: count,
+ limit: limit
+ }
+ })
+ return true;
+ }
+ catch (e) {
+ console.error(e)
+ return false; 
+ }
+}
+
+export async function set_flood_settings(chat_id: string, flood_type: bigint, value: string = "0") {
+ try {
+ let flood_settings = await prisma.antiflood_settings.upsert({
+ where: {
+ chat_id: chat_id
+ },
+ update: {
+ flood_type: flood_type,
+ value: value
+ },
+ create: {
+ chat_id: chat_id,
+ flood_type: flood_type,
+ value: value 
+ }
+ })
+ return true;
+ }
+ catch (e) {
+ console.error(e)
+ return false;
+ }
+}
+
+export async function update_flood(chat_id: string, count: bigint) {
+ try {
+ let flood = await prisma.antiflood.upsert({
+ where: {
+ chat_id: chat_id,
+ },
+ update: {
+ count: count,
+ },
+ create: {
+ chat_id: chat_id,
+ count: count,
+ }
+ })
+ return true;
+ }
+ catch (e) {
+ console.error(e)
+ return false; 
+ }
+}

src/database/blacklist_sql.ts

@@ -0,0 +1,10 @@
+import { prisma } from ".";
+
+export async function get_blacklist(chatId: string) {
+ let blacklist = await prisma.blacklist.findFirst({
+ where: {
+ chat_id: chatId.toString()
+ }
+ })
+ return blacklist;
+}

src/index.ts

@@ -2,7 +2,7 @@ import { bot, adapter }from "./bot";
 import constants from "./config"
 import { gramjs } from './utility';
 import { logger, channel_log } from "./logger"
-import { Composer, Context } from "grammy";
+import { Context } from "grammy";
 import { run, sequentialize } from "@grammyjs/runner";
 import { autoRetry } from "@grammyjs/auto-retry";
 import { chatMembers } from "@grammyjs/chat-members";
@@ -11,8 +11,6 @@ import { LogLevel } from 'telegram/extensions/Logger';
 
 import Commands from "./modules/index";
 
-const composer = new Composer();
-
 const runner = run(bot, { 
  runner: { 
  fetch: { 

src/modules/antiflood.ts

@@ -0,0 +1,207 @@
+import { Composer } from "grammy";
+import { bot } from "../bot";
+import { get_flood, get_flood_settings, set_flood, set_flood_settings } from "../database/antiflood_sql";
+import { adminCanRestrictUsers, botCanRestrictUsers, convertUnixTime, extract_time } from "../helpers/helper_func";
+
+const composer = new Composer();
+
+async function flood_type_meaning(flood_type: bigint) {
+ switch (flood_type) {
+ case 1n:
+ return "ban";
+ case 2n:
+ return "kick";
+ case 3n:
+ return "mute";
+ case 4n:
+ return "tban";
+ case 5n:
+ return "tmute";
+ }
+}
+
+async function validateTimeValue(input: string): Promise<string | false> {
+ const regex = /^(\d+m|\d+h|\d+d)(\s+(\d+m|\d+h|\d+d))*$/i;
+
+ if (regex.test(input)) {
+ return input;
+ }
+
+ return false;
+}
+
+// async function captureflood(ctx: any) {
+// let flood = await get_flood(ctx.chat.id);
+// let flood_settings = await get_flood_settings(ctx.chat.id);
+// if (flood?.limit) {
+// if (flood.count >= flood.limit) {
+// switch (flood_settings?.flood_type) {
+// case 1n:
+// await ctx.kickChatMember(ctx.from.id);
+// break;
+// case 2n:
+// await ctx.kickChatMember(ctx.from.id);
+// break;
+// case 3n:
+// await ctx.restrictChatMember(ctx.from.id, {until_date: Math.floor(Date.now() / 1000) + 3600});
+// break;
+// case 4n:
+// await ctx.kickChatMember(ctx.from.id);
+// await ctx.restrictChatMember(ctx.from.id, {until_date: Math.floor(Date.now() / 1000) + convertUnixTime(flood_settings?.value || "0")});
+// break;
+// case 5n:
+// await ctx.restrictChatMember(ctx.from.id, {until_date: Math.floor(Date.now() / 1000) + convertUnixTime(flood_settings?.value || "0")});
+// break;
+// }
+// await ctx.deleteMessage(ctx.message.message_id);
+// await ctx.reply(`You have exceeded the flood limit of <code>${flood.limit}</code> consecutive messages!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+// }
+// else {
+// await set_flood(ctx.chat.id.toString(), flood?.count + 1n, flood.limit);
+// }
+// }
+// }
+
+async function flood(ctx: any) {
+ let flood = await get_flood(ctx.chat.id);
+ let flood_settings = await get_flood_settings(ctx.chat.id);
+ if (ctx.match) {
+ await ctx.reply(`Use <code>/setflood (number)</code> to enable anti-flood (i.e. <code>/setflood 12</code> - limit 12 consecutive messages).\n\nOr use <code>/setflood off</code> to disable anti-flood!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ }
+ else if (!flood?.limit) {
+ await ctx.reply("I'm not enforcing any flood control here!", {reply_parameters: {message_id: ctx.message.message_id}});
+ } 
+ else {
+ await ctx.reply(`I'm currently restricting members after <code>${flood?.limit}</code> consecutive messages.\n<b>Action on exceeding the limit</b>: <code>${await flood_type_meaning(flood_settings?.flood_type || 1n)}</code>`, {reply_parameters: {message_id: ctx.message.message_id}, parse_mode: "HTML"});
+ }
+}
+
+async function floodmode(ctx: any) {
+ let flood_settings = await get_flood_settings(ctx.chat.id);
+ if (ctx.match) {
+ await ctx.reply(`Usage: <code>/setfloodmode ban/kick/mute/tban/tmute value</code> to set action to be taken after members exceed the flood limit!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}}); 
+ }
+ else if (flood_settings?.flood_type == undefined) {
+ await set_flood_settings(ctx.chat.id.toString(), 1n);
+ await ctx.reply(`Members will be <b>banned</b> after exceeding the flood limit!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ } 
+ else {
+ if (flood_settings?.value !== null && flood_settings?.value !== "0") {
+ await ctx.reply(`Current flood mode is set to: <b>${await flood_type_meaning(flood_settings?.flood_type || 1n)} ${flood_settings?.value}</b>`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}}); 
+ }
+ else {
+ await ctx.reply(`Current flood mode is set to: <b>${await flood_type_meaning(flood_settings?.flood_type || 1n)}</b>`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}}); 
+ }
+ } 
+}
+
+async function setflood(ctx: any) {
+ let args = ctx.match.toLowerCase();
+ if (args) {
+ let flood_settings = await get_flood_settings(ctx.chat.id);
+ if (args == "off" || args == "no" || args == "disable" || args == "0") {
+ await set_flood(ctx.chat.id.toString(), 0n, 0n);
+ await ctx.reply(`Anti-flood has been <b>disabled</b>!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ }
+ else if (!isNaN(Number(args))) {
+ if (flood_settings?.flood_type == undefined) {
+ await set_flood_settings(ctx.chat.id.toString(), 1n);
+ }
+ await set_flood(ctx.chat.id.toString(), 0n, BigInt(args));
+ await ctx.reply(`Anti-flood has been set to <code>${args}</code> consecutive messages!\n<b>Action on exceeding the limit</b>: <code>${await flood_type_meaning(flood_settings?.flood_type || 1n)}</code>`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ }
+ else {
+ await ctx.reply(`Invalid argument please use a number to set flood limit <i>OR</i> use '<code>off</code>' or '<code>no</code>' to disable anti-flood.`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ }
+ }
+ else { 
+ await ctx.reply(`Use <code>/setflood (number)</code> to enable anti-flood (i.e. <code>/setflood 12</code> - limit 12 consecutive messages).\n\nOr use <code>/setflood off</code> to disable anti-flood!`, {parse_mode: "HTML", reply_parameters: {message_id: ctx.message.message_id}});
+ }
+}
+
+async function setfloodmode(ctx: any) {
+ let args = ctx.match.toLowerCase();
+ if (args) {
+ let split_args = args.split(" ");
+ if (split_args[0] == "ban") {
+ await set_flood_settings(ctx.chat.id.toString(), 1n);
+ await ctx.reply(`Members will be <b>banned</b> after exceeding the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ } 
+ else if (split_args[0] == "kick") {
+ await set_flood_settings(ctx.chat.id.toString(), 2n);
+ await ctx.reply(`Members will be <b>kicked</b> after exceeding the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ } 
+ else if (split_args[0] == "mute") {
+ await set_flood_settings(ctx.chat.id.toString(), 3n);
+ await ctx.reply(`Members will be <b>muted</b> after exceeding the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ else if (split_args[0] == "tban") {
+ if (split_args.length > 1) {
+ let time_value = await validateTimeValue(split_args.slice(1).join(" "));
+ if (time_value !== false) {
+ await set_flood_settings(ctx.chat.id.toString(), 4n, time_value);
+ await ctx.reply(`Members will be <b>temporarily banned for ${time_value}</b> after exceeding the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ else {
+ await ctx.reply(`It looks like you didn't specify a valid time; Try, <code>/setfloodmode tmute 12h</code>.\n\nExamples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ } 
+ }
+ else {
+ await ctx.reply(`It looks like you didn't specify a valid time; Try, <code>/setfloodmode tmute 12h</code>.\n\nExamples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ } 
+ else if (split_args[0] == "tmute") {
+ if (split_args.length > 1) {
+ let time_value = await validateTimeValue(split_args.slice(1).join(" "));
+ if (time_value !== false) {
+ await set_flood_settings(ctx.chat.id.toString(), 5n, time_value);
+ await ctx.reply(`Members will be <b>temporarily muted for ${time_value}</b> after exceeding the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ else {
+ await ctx.reply(`It looks like you didn't specify a valid time; Try, <code>/setfloodmode tmute 12h</code>.\n\nExamples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ } 
+ }
+ else {
+ await ctx.reply(`It looks like you didn't specify a valid time; Try, <code>/setfloodmode tmute 12h</code>.\n\nExamples of time value: 4m = 4 minutes, 3h = 3 hours, 6d = 6 days, 5w = 5 weeks.`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ }
+ else {
+ await ctx.reply(`Usage: <code>/setfloodmode ban/kick/mute/tban/tmute value</code> to set action to be taken after members exceed the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+ } 
+ else {
+ await ctx.reply(`Usage: <code>/setfloodmode ban/kick/mute/tban/tmute value</code> to set action to be taken after members exceed the flood limit!`, { parse_mode: "HTML", reply_parameters: { message_id: ctx.message.message_id } });
+ }
+}
+
+// var FLOODCOUNT: bigint = 0n;
+
+// composer.on(["message", "edited_message"], (async (ctx: any) => {
+// // await captureflood(ctx);
+// // FLOODCOUNT += 1n
+// // let limit = 10n
+// // console.log(`${FLOODCOUNT}/${limit}`)
+// // if (FLOODCOUNT > limit) {
+// // FLOODCOUNT = 0n
+// // }
+// // await next();
+
+// }));
+
+composer.chatType("supergroup" || "group").command(["flood", "antiflood"], (async (ctx: any) => {
+ await flood(ctx);
+}));
+
+composer.chatType("supergroup" || "group").command(["floodmode", "antifloodmode"], (async (ctx: any) => {
+ await floodmode(ctx);
+}));
+
+composer.chatType("supergroup" || "group").command(["setflood", "setantiflood"], adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+ await setflood(ctx);
+})));
+
+composer.chatType("supergroup" || "group").command(["setfloodmode", "setantifloodmode"], adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+ await setfloodmode(ctx);
+})));
+
+export default composer;

src/modules/blacklists.ts

@@ -0,0 +1,37 @@
+import { Composer } from "grammy";
+import { get_blacklist } from "../database/blacklist_sql";
+import { adminCanRestrictUsers, botCanRestrictUsers } from "../helpers/helper_func";
+
+const composer = new Composer();
+
+async function blacklist(ctx: any) {
+ let blacklist = await get_blacklist(ctx.match.toString());
+ let filter_list = `Current blacklisted words in <b>${ctx.chat.title}</b>:\n`;
+
+ // for (let trigger in blacklist) {
+ // 
+ // }
+
+}
+
+// composer.chatType("supergroup" || "group").command(["blacklist", "blacklists"], adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+// await blacklist(ctx);
+// })));
+
+// composer.chatType("supergroup" || "group").command("addblacklist", adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+// 
+// })));
+
+// composer.chatType("supergroup" || "group").command(["unblacklist", "rmblacklist"], adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+// 
+// })));
+
+// composer.chatType("supergroup" || "group").command("blacklistmode", adminCanRestrictUsers(botCanRestrictUsers(async (ctx: any) => {
+// 
+// })));
+
+// composer.on(["message", "edited_message"], (async (ctx: any, next) => {
+// 
+// }));
+
+export default composer;

src/modules/filters.ts

@@ -0,0 +1,12 @@
+import { Composer } from "grammy";
+
+const composer = new Composer();
+
+// composer.on(["message", "edited_message"], (async (ctx: any, next) => {
+
+// await next();
+
+
+// }));
+
+export default composer;