Untitled

SUBMITTED BY: TaigaB1

DATE: Aug. 31, 2024, 4:38 p.m.

FORMAT: Text only

SIZE: 58.4 kB

Raw Download

HITS: 148

Report
  1. const TelegramBot = require('node-telegram-bot-api');
  2. const env = require('./.env');
  3. const fs = require('fs');
  4. const bot = new TelegramBot(env.token, { polling: true });
  5. const jsonFilePathUsers = 'db/usernameIdMap.json';
  6. const jsonFilePathWarnings = 'db/warningsIdMap.json';
  7. const jsonFilePathMenu = 'db/menuIdMap.json';
  8. const MAX_WARNINGS = env.MAX_WARNINGS;
  10. let customCommands = {};
  11. let usernameToUserIdMap = [];
  12. let warnings = {};
  14. const welcomeMessages = [
  15. 'Esperamos que você se divirta por aqui!',
  16. 'Estamos felizes em tê-lo(a) no grupo.',
  17. 'Sinta-se à vontade para participar das conversas.'
  18. ];
  19. const allowedGroupIds = [
  20. '-1001576734558',
  21. '-1002005067008', //DTunnel Mod (ConfigMods)
  22. '-1002016594807', //Grupo de testes
  23. '-1001591216081' //Grupo do shaka
  24. ];
  26. if (fs.existsSync(jsonFilePathUsers)) {
  27. const jsonDataUsers = fs.readFileSync(jsonFilePathUsers);
  28. usernameToUserIdMap = JSON.parse(jsonDataUsers);
  29. }
  30. if (fs.existsSync(jsonFilePathWarnings)) {
  31. const jsonDataWarnings = fs.readFileSync(jsonFilePathWarnings);
  32. warnings = JSON.parse(jsonDataWarnings);
  33. }
  34. if (fs.existsSync(jsonFilePathMenu)) {
  35. const jsonDataMenu = fs.readFileSync(jsonFilePathMenu);
  36. customCommands = JSON.parse(jsonDataMenu);
  37. }
  39. bot.on('message', (msg) => {
  40. const chatId = msg.chat.id;
  41. const { username, id } = msg.from;
  42. if (username) {
  43. const userIndex = usernameToUserIdMap.findIndex(user => user.id === id);
  44. if (userIndex !== -1) {
  45. const firstName = msg.from.first_name || '';
  46. const lastName = msg.from.last_name || '';
  47. const usernameOld = usernameToUserIdMap[userIndex].username;
  49. if (usernameOld != username) {
  50. const message = `🧐 Mudança Detectada\n\n👤 Usuário: ${firstName + ' ' + lastName} [ID: ${id}]\n\n✏️ Mudou @${usernameOld} Para @${username}`;
  51. bot.sendMessage(chatId, message);
  52. }
  53. usernameToUserIdMap[userIndex].username = username;
  54. } else {
  55. usernameToUserIdMap.push({ id, username });
  56. }
  57. fs.writeFileSync(jsonFilePathUsers, JSON.stringify(usernameToUserIdMap, null, 4));
  58. }
  59. });
  61. bot.on('message', async (msg) => {
  62. const chatId = msg.chat.id;
  63. const msgUserId = msg.message_id;
  64. if (msg.entities && msg.entities[0].type === 'bot_command') {
  65. const command = msg.text.split(' ')[0];
  67. if (msg.chat.type === 'private') {
  68. switch (command) {
  69. case '/start':
  70. bot.sendMessage(chatId, 'Olá! Eu sou Amy gerenciadora de grupos.');
  71. break;
  72. }
  73. } else {
  74. if (command == '/id') {
  75. bot.sendMessage(chatId, `ID do Grupo: ${chatId}`);
  76. return;
  77. }
  78. if (!isChatAllowed(chatId)) {
  79. bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
  80. return;
  81. }
  82. switch (command) {
  83. case '/start':
  84. bot.sendMessage(chatId, 'Olá! Eu sou Amy gerenciadora de grupos.');
  85. break;
  86. case '/ban':
  87. checkAdminPermission(msg, () => {
  88. let userId;
  89. let userName;
  90. const commandParams = msg.text.split(' ');
  92. if (msg.reply_to_message) {
  93. userId = msg.reply_to_message.from.id;
  94. userName = msg.reply_to_message.from.first_name + (msg.reply_to_message.from.last_name ? ' ' + msg.reply_to_message.from.last_name : '');
  95. } else if (commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
  96. userId = commandParams[1];
  97. userName = userId;
  98. } else if (commandParams.length > 1 && commandParams[1].startsWith('@')) {
  99. const username = commandParams[1].substring(1);
  100. const user = usernameToUserIdMap.find(user => user.username === username);
  102. if (user) {
  103. const user_Id = user.id;
  104. bot.banChatMember(chatId, user_Id);
  105. sendMessageWithUndoButton(chatId, `Usuário banido: @${username} (${user_Id})`, JSON.stringify({ command: 'undo_ban', userId: user_Id }));
  106. } else {
  107. bot.sendMessage(chatId, 'O usuário não foi encontrado.');
  108. }
  109. return;
  110. } else {
  111. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário ou o username para banir.');
  112. return;
  113. }
  115. bot.banChatMember(chatId, userId);
  116. sendMessageWithUndoButton(chatId, `Usuário banido: ${userName} (${userId})`, JSON.stringify({ command: 'undo_ban', userId: userId }));
  117. });
  118. break;
  119. case '/warn':
  120. checkAdminPermission(msg, () => {
  121. const reasonWarn = msg.text.split(' ').slice(1).join(' ');
  122. if (!reasonWarn) {
  123. const warnedUserId = msg.reply_to_message.from.id;
  124. const groupId = msg.chat.id;
  126. if (!warnings[groupId]) {
  127. warnings[groupId] = {};
  128. }
  130. const username = msg.reply_to_message.from.username;
  131. warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
  132. const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3`;
  133. sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
  134. if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
  135. bot.banChatMember(chatId, warnedUserId);
  136. bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
  137. delete warnings[groupId][warnedUserId];
  138. }
  139. saveWarnings();
  140. } else {
  141. const warnedUserId = msg.reply_to_message.from.id;
  142. const groupId = msg.chat.id;
  144. if (!warnings[groupId]) {
  145. warnings[groupId] = {};
  146. }
  148. const username = msg.reply_to_message.from.username;
  149. warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
  150. const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3\nMotivo: ${reasonDWarn}.`;
  151. sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
  152. if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
  153. bot.banChatMember(chatId, warnedUserId);
  154. bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
  155. delete warnings[groupId][warnedUserId];
  156. }
  157. saveWarnings();
  158. }
  159. });
  160. break;
  161. case '/mute':
  162. checkAdminPermission(msg, () => {
  164. let userId;
  165. let userName;
  167. if (msg.reply_to_message) {
  168. userId = msg.reply_to_message.from.id;
  169. userName = msg.reply_to_message.from.username;
  170. } else {
  171. const commandParams = msg.text.split(' ').slice(1).join(' ');
  173. if (!commandParams) {
  174. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
  175. return;
  176. }
  177. if (/^\d+$/.test(commandParams)) {
  178. userId = commandParams;
  179. userName = userId;
  180. bot.getChatMember(chatId, userId).then((user) => {
  181. userName = user.user.username || 'não disponível';
  182. const options = {
  183. until_date: Math.floor(Date.now() / 1000) + 3600,
  184. can_send_messages: false
  185. };
  187. bot.restrictChatMember(chatId, userId, options);
  188. sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));
  189. }).catch((error) => {
  190. console.error('Erro ao obter informações do usuário:', error.message);
  191. bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
  192. });
  193. return;
  194. } else if (commandParams.startsWith('@')) {
  195. const usernameParam = commandParams.substring(1);
  196. const user = usernameToUserIdMap.find(user => user.username === usernameParam);
  198. if (user) {
  199. userId = user.id;
  200. userName = usernameParam;
  202. const options = {
  203. until_date: Math.floor(Date.now() / 1000) + 3600,
  204. can_send_messages: false
  205. };
  207. bot.restrictChatMember(chatId, userId, options);
  208. sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));
  209. return;
  210. } else {
  211. bot.sendMessage(chatId, 'Usuário não encontrado.');
  212. return;
  213. }
  214. } else {
  215. bot.sendMessage(chatId, 'Formato de entrada inválido. Use /mute @username ou /mute user_id.');
  216. return;
  217. }
  218. }
  220. const options = {
  221. until_date: Math.floor(Date.now() / 1000) + 3600,
  222. can_send_messages: false
  223. };
  225. bot.restrictChatMember(chatId, userId, options);
  226. sendMessageWithUndoButton(chatId, `@${userName} (${userId}) mutado por 1h.`, JSON.stringify({ command: 'undo_mute', userId: userId }));
  228. });
  229. break;
  230. case '/unmute':
  231. checkAdminPermission(msg, () => {
  233. let userId;
  234. let userName;
  236. if (msg.reply_to_message) {
  237. userId = msg.reply_to_message.from.id;
  238. userName = msg.reply_to_message.from.username;
  239. } else {
  240. const commandParams = msg.text.split(' ').slice(1).join(' ');
  242. if (!commandParams) {
  243. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
  244. return;
  245. }
  246. if (/^\d+$/.test(commandParams)) {
  247. userId = commandParams;
  248. userName = userId;
  249. bot.getChatMember(chatId, userId).then((user) => {
  250. userName = user.user.username || 'não disponível';
  251. const options = { can_send_messages: true };
  253. bot.restrictChatMember(chatId, userId, options);
  254. bot.sendMessage(chatId, `@${userName} foi desmutado.`);
  255. }).catch((error) => {
  256. console.error('Erro ao obter informações do usuário:', error.message);
  257. bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
  258. });
  259. return;
  260. } else if (commandParams.startsWith('@')) {
  261. const usernameParam = commandParams.substring(1);
  262. const user = usernameToUserIdMap.find(user => user.username === usernameParam);
  264. if (user) {
  265. userId = user.id;
  266. userName = usernameParam;
  268. const options = { can_send_messages: true };
  270. bot.restrictChatMember(chatId, userId, options);
  271. bot.sendMessage(chatId, `@${userName} foi desmutado.`);
  272. return;
  273. } else {
  274. bot.sendMessage(chatId, 'Usuário não encontrado.');
  275. return;
  276. }
  277. } else {
  278. bot.sendMessage(chatId, 'Formato de entrada inválido. Use /unmute @username ou /unmute user_id.');
  279. return;
  280. }
  281. }
  283. const options = { can_send_messages: true };
  285. bot.restrictChatMember(chatId, userId, options);
  286. bot.sendMessage(chatId, `@${userName} foi desmutado.`);
  287. });
  288. break;
  289. case '/info':
  290. checkAdminPermission(msg, () => {
  291. let userId;
  292. let username;
  293. let user_id;
  295. const commandParams = msg.text.split(' ');
  297. if (msg.reply_to_message) {
  298. userId = msg.reply_to_message.from.id;
  299. username = msg.reply_to_message.from.username || 'não disponível';
  300. user_id = userId;
  301. } else {
  302. const firstParam = commandParams[1];
  303. if (commandParams[1] != null) {
  304. if (/^\d+$/.test(firstParam)) {
  305. userId = firstParam;
  306. bot.getChatMember(chatId, userId).then((user) => {
  307. user_id = user.user.id;
  308. username = user.user.username || 'não disponível';
  309. const userWarnings = warnings[userId] || 0;
  310. bot.sendMessage(chatId, `Informações sobre o usuário:\nUser: @${username}\nID: ${user_id}\nNúmero de advertências: ${userWarnings}`);
  311. }).catch((error) => {
  312. console.error('Erro ao obter informações do usuário:', error.message);
  313. bot.sendMessage(chatId, 'Erro ao obter informações do usuário.');
  314. });
  315. return;
  316. } else if (firstParam.startsWith('@')) {
  317. const usernameParam = firstParam.substring(1);
  319. const user = usernameToUserIdMap.find(user => user.username === usernameParam);
  321. if (user) {
  322. user_id = user.id;
  323. username = usernameParam;
  324. } else {
  325. bot.sendMessage(chatId, 'O usuário não foi encontrado.');
  326. return;
  327. }
  328. }
  329. } else {
  330. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
  331. return;
  332. }
  333. }
  335. const userWarnings = warnings[userId] || 0;
  336. bot.sendMessage(chatId, `Informações sobre o usuário:\nUser: @${username}\nID: ${user_id}\nNúmero de advertências: ${userWarnings}`);
  337. });
  338. break;
  339. case '/dwarn':
  340. checkAdminPermission(msg, () => {
  341. const reasonDWarn = msg.text.split(' ').slice(1).join(' ');
  342. if (!reasonDWarn) {
  343. const warnedUserId = msg.reply_to_message.from.id;
  344. const groupId = msg.chat.id;
  346. if (!warnings[groupId]) {
  347. warnings[groupId] = {};
  348. }
  350. const username = msg.reply_to_message.from.username;
  351. warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
  352. bot.deleteMessage(chatId, msg.reply_to_message.message_id);
  353. const warnMessage = `Usuário @${username} advertido: ${warnings[groupId][warnedUserId]}/3`;
  354. sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
  355. if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
  356. bot.banChatMember(chatId, warnedUserId);
  357. bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
  358. delete warnings[groupId][warnedUserId];
  359. }
  360. saveWarnings();
  361. } else {
  362. const warnedUserId = msg.reply_to_message.from.id;
  363. const groupId = msg.chat.id;
  365. if (!warnings[groupId]) {
  366. warnings[groupId] = {};
  367. }
  369. const username = msg.reply_to_message.from.username;
  370. warnings[groupId][warnedUserId] = warnings[groupId][warnedUserId] ? warnings[groupId][warnedUserId] + 1 : 1;
  371. bot.deleteMessage(chatId, msg.reply_to_message.message_id);
  372. const warnMessage = `Usuário @${username} adivertido: ${warnings[groupId][warnedUserId]}/3\nMotivo: ${reasonDWarn}.`;
  373. sendMessageWithUndoButton(chatId, warnMessage, JSON.stringify({ command: 'undo_warn', userId: warnedUserId }));
  374. if (warnings[groupId][warnedUserId] > MAX_WARNINGS) {
  375. bot.banChatMember(chatId, warnedUserId);
  376. bot.sendMessage(chatId, `Usuário banido por exceder o limite de advertências.`);
  377. delete warnings[groupId][warnedUserId];
  378. }
  379. saveWarnings();
  380. }
  381. });
  382. break;
  383. case '/dmute':
  384. checkAdminPermission(msg, () => {
  385. const messageId = msg.reply_to_message.message_id;
  386. bot.deleteMessage(chatId, messageId).then(() => {
  387. const userId = msg.reply_to_message.from.id;
  388. const options = {
  389. until_date: Math.floor(Date.now() / 1000) + 3600,
  390. can_send_messages: false
  391. };
  392. bot.restrictChatMember(chatId, userId, options).then(() => {
  393. sendMessageWithUndoButton(chatId, 'Mensagem apagada e usuário mutado por 1 hora.', JSON.stringify({ command: 'undo_mute', userId: userId }));
  394. }).catch((error) => {
  395. console.error('Erro ao mutar usuário:', error.message);
  396. bot.sendMessage(chatId, 'Erro ao mutar usuário.');
  397. });
  398. }).catch((error) => {
  399. console.error('Erro ao apagar mensagem:', error.message);
  400. bot.sendMessage(chatId, 'Erro ao apagar mensagem.');
  401. });
  402. });
  403. break;
  404. case '/dban':
  405. checkAdminPermission(msg, () => {
  406. const messageId = msg.reply_to_message.message_id;
  407. bot.deleteMessage(chatId, messageId).then(() => {
  408. const userId = msg.reply_to_message.from.id;
  409. bot.banChatMember(chatId, userId).then(() => {
  410. sendMessageWithUndoButton(chatId, 'Mensagem apagada e usuário banido.', JSON.stringify({ command: 'undo_ban', userId: userId }));
  411. }).catch((error) => {
  412. console.error('Erro ao banir usuário:', error.message);
  413. bot.sendMessage(chatId, 'Erro ao banir usuário.');
  414. });
  415. }).catch((error) => {
  416. console.error('Erro ao apagar mensagem:', error.message);
  417. bot.sendMessage(chatId, 'Erro ao apagar mensagem.');
  418. });
  419. });
  420. break;
  421. case '/promote':
  422. checkCreatorPermission(msg, async () => {
  423. const commandParams = msg.text.split(' ');
  424. let userId;
  425. let userName;
  426. let user_name;
  428. if (msg.reply_to_message) {
  429. userId = msg.reply_to_message.from.id;
  430. userName = msg.reply_to_message.from.first_name + (msg.reply_to_message.from.last_name ? ' ' + msg.reply_to_message.from.last_name : '');
  431. user_name = msg.reply_to_message.from.username;
  432. }
  434. if (!userId && commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
  435. userId = commandParams[1];
  436. userName = userId;
  437. user_name = msg.reply_to_message.from.username;
  438. }
  440. if (!userId && commandParams.length > 1 && commandParams[1].startsWith('@')) {
  441. const username = commandParams[1].substring(1);
  443. // Procurar o usuário no usernameToUserIdMap
  444. const user = usernameToUserIdMap.find(user => user.username === username);
  446. if (user) {
  447. const user_Id = user.id;
  448. await bot.promoteChatMember(chatId, user_Id, { can_change_info: false, can_delete_messages: true, can_invite_users: true, can_restrict_members: true, can_pin_messages: true, can_promote_members: false });
  449. bot.sendMessage(chatId, `Usuário @${username} promovido a administrador.`);
  450. return;
  451. } else {
  452. bot.sendMessage(chatId, 'O usuário não foi encontrado.');
  453. return;
  454. }
  455. }
  457. if (!userId) {
  458. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
  459. return;
  460. }
  462. try {
  463. await bot.promoteChatMember(chatId, userId, { can_change_info: false, can_delete_messages: true, can_invite_users: true, can_restrict_members: true, can_pin_messages: true, can_promote_members: false });
  464. bot.sendMessage(chatId, `Usuário @${user_name} promovido a administrador.`);
  465. } catch (error) {
  466. console.error('Erro ao promover usuário a administrador:', error.message);
  467. bot.sendMessage(chatId, 'Erro ao promover usuário a administrador.');
  468. }
  469. });
  470. break;
  471. case '/send':
  472. const commandParams = msg.text.split(' ').slice(1).join(' ');
  473. console.log(commandParams)
  474. bot.deleteMessage(chatId, msg.message_id);
  475. bot.sendMessage(chatId, commandParams);
  476. break;
  477. case '/comandos':
  478. const message = await fs.readFileSync('db/comandos.txt', 'utf-8');
  479. bot.sendMessage(chatId, message, { parse_mode: 'HTML' });
  480. break;
  481. case '/create':
  482. checkAdminPermission(msg, async () => {
  483. const commandData = msg.text.split(' ').slice(1).join(' ').split(':') || [];
  484. const commandName = commandData[0] ? commandData[0].trim() : false;
  485. const commandOrder = commandData[1] ? parseInt(commandData[1].trim()) : false;
  486. const groupId = msg.chat.id;
  488. if (!customCommands[groupId]) {
  489. customCommands[groupId] = {};
  490. }
  492. if (!commandData || commandData.length !== 2) {
  493. bot.sendMessage(chatId, 'Formato inválido. Use /create nome:ordem');
  494. return;
  495. }
  497. if (!commandName) {
  498. bot.sendMessage(chatId, 'Necessário adicionar um nome para o comando.');
  499. return;
  500. }
  502. if (!commandOrder || isNaN(commandOrder) || commandOrder <= 0) {
  503. bot.sendMessage(chatId, 'Necessário adicionar uma ordem válida para o comando.');
  504. return;
  505. }
  507. if (customCommands[groupId][commandName]) {
  508. bot.sendMessage(chatId, `O comando '${commandName}' já existe.`);
  509. return;
  510. }
  512. if (!msg.reply_to_message || !msg.reply_to_message.text) {
  513. bot.sendMessage(chatId, 'Você precisa responder a uma mensagem para criar um comando personalizado.');
  514. return;
  515. }
  517. const messageText = msg.reply_to_message.text;
  519. customCommands[groupId][commandName] = { text: messageText, order: commandOrder };
  521. bot.sendMessage(chatId, `Comando personalizado '${commandName}' criado com número de ordem '${commandOrder}'.`);
  523. // Ordena os comandos personalizados por número de ordem
  524. const sortedCommands = Object.entries(customCommands[groupId]).sort((a, b) => a[1].order - b[1].order);
  525. customCommands[groupId] = Object.fromEntries(sortedCommands);
  527. fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
  529. menuOptions = createMenuButtons(groupId);
  530. });
  531. break;
  532. case '/menu':
  533. menuOptions = createMenuButtons(chatId);
  534. const commands = customCommands[chatId];
  536. bot.getChatMember(chatId, msg.from.id)
  537. .then(chatMember => {
  538. let username = '';
  539. if (chatMember.user.username) {
  540. username = '@' + chatMember.user.username;
  541. } else if (chatMember.user.first_name) {
  542. username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
  543. }
  544. setTimeout(() => {
  545. bot.deleteMessage(chatId, msgUserId)
  546. .catch(error => {
  547. console.error('Erro ao excluir mensagem:', error);
  548. });
  549. }, 2 * 1000);
  550. if (commands && Object.keys(commands).length > 0) {
  551. bot.sendPhoto(chatId, 'bot.png', {
  552. caption: `Solicitado por: ${username}\n\nSelecione uma ação:`,
  553. reply_markup: menuOptions.reply_markup,
  554. }).then(sentMessage => {
  555. const messageId = sentMessage.message_id;
  556. const delaySeconds = 90;
  557. setTimeout(() => {
  558. bot.deleteMessage(chatId, messageId)
  559. .catch(error => {
  560. console.error('Erro ao excluir mensagem:', error);
  561. });
  562. }, delaySeconds * 1000);
  563. }).catch(error => {
  564. console.error('Erro ao enviar mensagem:', error);
  565. });
  566. } else {
  567. bot.sendMessage(chatId, 'Nenhum comando personalizado foi criado ainda');
  568. }
  569. })
  570. .catch(error => {
  571. console.error('Erro ao obter informações do membro do chat:', error);
  572. });
  573. break;
  574. case '/delete':
  575. checkAdminPermission(msg, async () => {
  576. const commandToDelete = msg.text.split(' ').slice(1).join(' ');
  577. const groupIdToDelete = msg.chat.id;
  578. if (customCommands.hasOwnProperty(groupIdToDelete) && customCommands[groupIdToDelete].hasOwnProperty(commandToDelete)) {
  579. delete customCommands[groupIdToDelete][commandToDelete];
  580. bot.sendMessage(msg.chat.id, `Comando "${commandToDelete}" deletado com sucesso.`)
  581. .then(sentMessage => {
  582. menuOptions = createMenuButtons(groupIdToDelete);
  583. fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
  584. // bot.editMessageReplyMarkup(menuOptions.reply_markup, {
  585. // chat_id: sentMessage.chat.id,
  586. // message_id: sentMessage.message_id
  587. // });
  588. })
  589. .catch(error => {
  590. console.error('Erro ao enviar mensagem:', error);
  591. });
  592. } else {
  593. bot.sendMessage(msg.chat.id, `O comando "${commandToDelete}" não existe.`);
  594. }
  595. });
  596. break;
  597. case '/unban':
  598. checkAdminPermission(msg, async () => {
  599. let userId;
  600. let user_name
  602. const commandParams = msg.text.split(' ');
  604. if (msg.reply_to_message) {
  605. userId = msg.reply_to_message.from.id;
  606. }
  608. if (!userId && commandParams.length > 1 && /^\d+$/.test(commandParams[1])) {
  609. userId = commandParams[1];
  610. }
  612. if (!userId && commandParams.length > 1 && commandParams[1].startsWith('@')) {
  613. const usernameParam = commandParams[1].substring(1);
  614. const user = usernameToUserIdMap.find(user => user.username === usernameParam);
  616. if (user) {
  617. userId = user.id;
  618. user_name = usernameParam;
  619. } else {
  620. bot.sendMessage(chatId, 'O usuário não foi encontrado.');
  621. return;
  622. }
  623. }
  625. if (!userId) {
  626. bot.sendMessage(chatId, 'Você precisa fornecer o ID do usuário, o username ou usar o comando em resposta a uma mensagem.');
  627. return;
  628. }
  630. bot.getChatMember(msg.chat.id, userId)
  631. .then(chatMember => {
  632. user_name = chatMember.user.username;
  633. })
  634. .catch(error => {
  635. console.error('Erro ao obter informações do membro do chat:', error);
  636. });
  638. try {
  639. await bot.unbanChatMember(chatId, userId);
  640. bot.sendMessage(chatId, `Usuário @${user_name} (ID: ${userId}) foi desbanido.`);
  641. } catch (error) {
  642. console.error('Erro ao desbanir usuário:', error.message);
  643. bot.sendMessage(chatId, 'Erro ao desbanir usuário.');
  644. }
  645. });
  646. break;
  647. case '/pin':
  648. checkAdminPermission(msg, async () => {
  649. const messageId = msg.reply_to_message.message_id;
  651. if (!messageId) {
  652. bot.sendMessage(chatId, 'Por favor, responda à mensagem que deseja fixar com o comando /pin.')
  653. .then(sentMessage => {
  654. const messageId = sentMessage.message_id;
  655. const delaySeconds = 30;
  656. setTimeout(() => {
  657. bot.deleteMessage(chatId, messageId)
  658. .catch(error => {
  659. console.error('Erro ao excluir mensagem:', error);
  660. });
  661. }, delaySeconds * 1000);
  662. }).catch(error => {
  663. console.error('Erro ao enviar mensagem:', error);
  664. });
  665. return;
  666. }
  668. bot.pinChatMessage(chatId, messageId)
  669. .then(() => {
  670. bot.sendMessage(chatId, 'A mensagem foi fixada com sucesso.')
  671. .then(sentMessage => {
  672. const messageId = sentMessage.message_id;
  673. const delaySeconds = 30;
  674. setTimeout(() => {
  675. bot.deleteMessage(chatId, messageId)
  676. .catch(error => {
  677. console.error('Erro ao excluir mensagem:', error);
  678. });
  679. }, delaySeconds * 1000);
  680. }).catch(error => {
  681. console.error('Erro ao enviar mensagem:', error);
  682. });
  683. })
  684. .catch((error) => {
  685. console.error('Erro ao fixar mensagem:', error);
  686. bot.sendMessage(chatId, 'Ocorreu um erro ao fixar a mensagem. Por favor, tente novamente mais tarde.')
  687. .then(sentMessage => {
  688. const messageId = sentMessage.message_id;
  689. const delaySeconds = 30;
  690. setTimeout(() => {
  691. bot.deleteMessage(chatId, messageId)
  692. .catch(error => {
  693. console.error('Erro ao excluir mensagem:', error);
  694. });
  695. }, delaySeconds * 1000);
  696. }).catch(error => {
  697. console.error('Erro ao enviar mensagem:', error);
  698. });
  699. });
  700. });
  701. break;
  702. case '/editar_ordem':
  703. checkAdminPermission(msg, async () => {
  704. const commandData = msg.text.split(' ').slice(1).join(' ').split(':');
  705. const commandName = commandData[0].trim();
  706. const newPosition = parseInt(commandData[1].trim());
  707. const groupId = msg.chat.id;
  709. if (!customCommands[groupId]) {
  710. customCommands[groupId] = {};
  711. }
  713. if (isNaN(newPosition) || newPosition <= 0) {
  714. bot.sendMessage(chatId, 'A nova posição do comando deve ser um valor numérico maior que zero.');
  715. return;
  716. }
  718. if (!customCommands[groupId][commandName]) {
  719. bot.sendMessage(chatId, `O comando '${commandName}' não existe.`);
  720. return;
  721. }
  723. customCommands[groupId][commandName].order = newPosition;
  725. const sortedCommands = Object.entries(customCommands[groupId]).sort((a, b) => a[1].order - b[1].order);
  726. customCommands[groupId] = Object.fromEntries(sortedCommands);
  728. fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
  730. bot.sendMessage(chatId, `Posição do comando '${commandName}' atualizada para '${newPosition}'.`);
  732. menuOptions = createMenuButtons(groupId);
  733. });
  734. break;
  735. case '/editar_texto':
  736. checkAdminPermission(msg, async () => {
  737. const commandName = msg.text.split(' ').slice(1).join(' ');
  738. const groupId = msg.chat.id;
  740. if (!customCommands[groupId]) {
  741. customCommands[groupId] = {};
  742. }
  744. if (!customCommands[groupId][commandName]) {
  745. bot.sendMessage(chatId, `O comando '${commandName}' não existe.`);
  746. return;
  747. }
  749. if (!msg.reply_to_message || !msg.reply_to_message.text) {
  750. bot.sendMessage(chatId, 'Você precisa responder a uma mensagem para editar o texto do comando.');
  751. return;
  752. }
  754. const newMessageText = msg.reply_to_message.text;
  756. customCommands[groupId][commandName].text = newMessageText;
  758. fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
  760. bot.sendMessage(chatId, `Texto do comando '${commandName}' atualizado.`);
  762. menuOptions = createMenuButtons(groupId);
  763. });
  764. break;
  765. case '/editar_comando':
  766. checkAdminPermission(msg, async () => {
  767. const commandData = msg.text.split(' ').slice(1).join(' ').split(':');
  768. const currentCommandName = commandData[0].trim();
  769. const newCommandName = commandData[1].trim();
  770. const groupId = msg.chat.id;
  772. if (!customCommands[groupId]) {
  773. customCommands[groupId] = {};
  774. }
  776. if (!customCommands[groupId][currentCommandName]) {
  777. bot.sendMessage(chatId, `O comando '${currentCommandName}' não existe.`);
  778. return;
  779. }
  781. if (customCommands[groupId][newCommandName]) {
  782. bot.sendMessage(chatId, `O novo nome '${newCommandName}' já está em uso.`);
  783. return;
  784. }
  786. customCommands[groupId][newCommandName] = customCommands[groupId][currentCommandName];
  787. delete customCommands[groupId][currentCommandName];
  789. fs.writeFileSync(jsonFilePathMenu, JSON.stringify(customCommands, null, 4));
  791. bot.sendMessage(chatId, `Nome do comando '${currentCommandName}' atualizado para '${newCommandName}'.`);
  793. menuOptions = createMenuButtons(groupId);
  794. });
  795. break;
  796. }
  797. }
  798. }
  799. });
  800. bot.on('callback_query', (callbackQuery) => {
  801. const msg = callbackQuery.message;
  802. const data = JSON.parse(callbackQuery.data);
  803. const user_callbackId = callbackQuery.from.id;
  804. const userId = data.userId;
  805. const groupId = msg.chat.id;
  807. if (!isChatAllowed(groupId)) {
  808. bot.sendMessage(groupId, `O bot não está autorizado a ser usado neste grupo.`);
  809. return;
  810. }
  812. switch (data.command) {
  813. case 'undo_warn':
  814. bot.getChatMember(groupId, user_callbackId)
  815. .then(chatMember => {
  816. const memberStatus = chatMember.status;
  817. if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
  818. const status = chatMember.status;
  819. if (status === 'administrator' || status === 'creator') {
  820. if (warnings[groupId][userId] && warnings[groupId][userId] > 0) {
  821. warnings[groupId][userId]--;
  822. bot.editMessageText('Aviso removido.', {
  823. chat_id: groupId,
  824. message_id: msg.message_id
  825. });
  826. saveWarnings();
  827. } else {
  828. bot.sendMessage(groupId, 'Este usuário não possui advertências.');
  829. }
  830. } else {
  831. bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
  832. }
  833. }
  834. })
  835. .catch(error => {
  836. console.error('Erro ao obter informações do membro do chat:', error.message);
  837. });
  838. break;
  839. case 'undo_ban':
  840. bot.getChatMember(groupId, user_callbackId)
  841. .then(chatMember => {
  842. const memberStatus = chatMember.status;
  843. if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
  844. const status = chatMember.status;
  845. if (status === 'administrator' || status === 'creator') {
  846. bot.unbanChatMember(groupId, userId);
  847. bot.editMessageText('Banimento removido.', {
  848. chat_id: groupId,
  849. message_id: msg.message_id
  850. });
  851. } else {
  852. bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
  853. }
  854. }
  855. })
  856. .catch(error => {
  857. console.error('Erro ao obter informações do membro do chat:', error.message);
  858. });
  859. break;
  860. case 'undo_mute':
  861. bot.getChatMember(groupId, user_callbackId)
  862. .then(chatMember => {
  863. const memberStatus = chatMember.status;
  864. if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
  865. const status = chatMember.status;
  866. if (status === 'administrator' || status === 'creator') {
  867. const options = { can_send_messages: true };
  868. bot.restrictChatMember(groupId, userId, options);
  869. bot.editMessageText('Ação de mutar desfeita com sucesso.', {
  870. chat_id: groupId,
  871. message_id: msg.message_id
  872. });
  873. } else {
  874. bot.answerCallbackQuery(callbackQuery.id, 'Você não tem permissão para executar este comando.');
  875. }
  876. }
  877. })
  878. .catch(error => {
  879. console.error('Erro ao obter informações do membro do chat:', error.message);
  880. });
  881. break;
  882. case 'callback_menu':
  883. menuOptions = createMenuButtons(groupId);
  884. const commands = customCommands[groupId];
  885. if (commands && Object.keys(commands).length > 0) {
  886. bot.getChatMember(groupId, user_callbackId)
  887. .then(chatMember => {
  888. const memberStatus = chatMember.status;
  889. if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
  890. let username = '';
  891. if (chatMember.user.username) {
  892. username = '@' + chatMember.user.username;
  893. } else if (chatMember.user.first_name) {
  894. username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
  895. }
  896. bot.sendPhoto(groupId, 'bot.png', {
  897. caption: `Solicitado por: ${username}\n\nSelecione uma ação:`,
  898. reply_markup: menuOptions.reply_markup,
  899. }).then(sentMessage => {
  900. const messageId = sentMessage.message_id;
  901. const delaySeconds = 90;
  902. setTimeout(() => {
  903. bot.deleteMessage(groupId, messageId)
  904. .catch(error => {
  905. console.error('Erro ao excluir mensagem:', error.message);
  906. });
  907. }, delaySeconds * 1000);
  908. }).catch(error => {
  909. console.error('Erro ao enviar mensagem:', error.message);
  910. });
  911. }
  912. })
  913. .catch(error => {
  914. console.error('Erro ao obter informações do membro do chat:', error.message);
  915. });
  916. } else {
  917. bot.sendMessage(groupId, 'Nenhum comando personalizado foi criado ainda');
  918. }
  919. break;
  920. default:
  921. const command = data.command.replace('action_', '');
  922. if (customCommands[groupId] && customCommands[groupId][command]) {
  923. bot.getChatMember(groupId, user_callbackId)
  924. .then(chatMember => {
  925. const memberStatus = chatMember.status;
  926. if (memberStatus === 'member' || memberStatus === 'administrator' || memberStatus === 'creator') {
  927. let username = '';
  928. if (chatMember.user.username) {
  929. username = '@' + chatMember.user.username;
  930. } else if (chatMember.user.first_name) {
  931. username = `${chatMember.user.first_name} (ID: ${chatMember.user.id.toString()})`;
  932. }
  933. bot.sendMessage(groupId, `${customCommands[groupId][command].text}\n\nSolicitado por: ${username}`, { parse_mode: 'HTML' }).then(sentMessage => {
  934. const messageId = sentMessage.message_id;
  935. const delaySeconds = 90;
  936. setTimeout(() => {
  937. bot.deleteMessage(groupId, messageId)
  938. .catch(error => {
  939. console.error('Erro ao excluir mensagem:', error.message);
  940. });
  941. }, delaySeconds * 1000);
  942. }).catch(error => {
  943. if (error.message.includes(`can't parse entities: Can't find end tag corresponding to start tag code`)) {
  944. bot.sendMessage(groupId, `Erro: Alguma tag foi utilizada de forma incorreta neste comando.`);
  945. } else {
  946. bot.sendMessage(groupId, `Erro: ${error.message}`);
  947. }
  948. });
  949. }
  950. })
  951. .catch(error => {
  952. console.error('Erro ao obter informações do membro do chat:', error.message);
  953. });
  954. } else {
  955. bot.sendMessage(groupId, 'Este comando personalizado não está disponível.');
  956. }
  957. break;
  958. }
  959. });
  960. bot.on('new_chat_members', (msg) => {
  961. const chatId = msg.chat.id;
  962. const newMembers = msg.new_chat_members;
  964. if (!isChatAllowed(chatId)) {
  965. bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
  966. return;
  967. }
  969. newMembers.forEach((member) => {
  970. const welcomeMessage = welcomeMessages[Math.floor(Math.random() * welcomeMessages.length)];
  972. let username = '';
  973. if (member.username) {
  974. username = '@' + member.username;
  975. } else if (member.first_name) {
  976. username = `${member.first_name} (ID: ${member.id.toString()})`;
  977. }
  979. const text = `Bem-vindo(a) ${username}\n${welcomeMessage}\n\nAperte no botão a baixo para ver as opções do grupo.`;
  980. const keyboard = {
  981. inline_keyboard: [
  982. [
  983. {
  984. text: 'menu',
  985. callback_data: JSON.stringify({ command: 'callback_menu', userId: member.id.toString() })
  986. }
  987. ]
  988. ]
  989. };
  991. bot.sendMessage(chatId, text, { reply_markup: JSON.stringify(keyboard) })
  992. .then(sentMessage => {
  993. const messageId = sentMessage.message_id;
  994. const delaySeconds = 90;
  995. setTimeout(() => {
  996. bot.deleteMessage(chatId, messageId)
  997. .catch(error => {
  998. console.error('Erro ao excluir mensagem:', error.message);
  999. });
  1000. }, delaySeconds * 1000);
  1001. }).catch(error => {
  1002. console.error('Erro ao enviar mensagem:', error.message);
  1003. });
  1004. });
  1005. });
  1006. bot.on('left_chat_member', (msg) => {
  1007. const chatId = msg.chat.id;
  1008. const userName = msg.left_chat_member.username;
  1009. const firstName = msg.left_chat_member.first_name;
  1010. const lastName = msg.left_chat_member.last_name || '';
  1011. const message = `O usuário ${firstName} ${lastName} (@${userName}) saiu do grupo.`;
  1013. if (!isChatAllowed(chatId)) {
  1014. bot.sendMessage(chatId, `O bot não está autorizado a ser usado neste grupo.`);
  1015. return;
  1016. }
  1018. bot.sendMessage(chatId, message)
  1019. .then(sentMessage => {
  1020. const messageId = sentMessage.message_id;
  1021. const delaySeconds = 60;
  1022. setTimeout(() => {
  1023. bot.deleteMessage(chatId, messageId)
  1024. .catch(error => {
  1025. console.error('Erro ao excluir mensagem:', error.message);
  1026. });
  1027. }, delaySeconds * 1000);
  1028. }).catch(error => {
  1029. console.error('Erro ao enviar mensagem:', error.message);
  1030. });
  1031. });
  1032. bot.on('polling_error', (error) => {
  1033. console.error(error.message);
  1034. });
  1036. function checkAdminPermission(msg, callback) {
  1037. const chatId = msg.chat.id;
  1038. bot.getChatMember(chatId, msg.from.id).then((chatMember) => {
  1039. if (chatMember.status === 'administrator' || chatMember.status === 'creator') {
  1040. callback();
  1041. } else {
  1042. bot.answerCallbackQuery(chatId, 'Você não tem permissão para usar este comando.');
  1043. }
  1044. });
  1045. }
  1046. function checkCreatorPermission(msg, callback) {
  1047. const chatId = msg.chat.id;
  1048. bot.getChatMember(chatId, msg.from.id).then((chatMember) => {
  1049. if (chatMember.status === 'creator') {
  1050. callback();
  1051. } else {
  1052. bot.answerCallbackQuery(chatId, 'Você não tem permissão para usar este comando.');
  1053. }
  1054. });
  1055. }
  1056. function sendMessageWithUndoButton(chatId, text, undoCallbackData) {
  1057. const keyboard = {
  1058. inline_keyboard: [
  1059. [
  1060. {
  1061. text: 'Desfazer',
  1062. callback_data: undoCallbackData
  1063. }
  1064. ]
  1065. ]
  1066. };
  1068. bot.sendMessage(chatId, text, { reply_markup: JSON.stringify(keyboard) });
  1069. }
  1070. function createMenuButtons(groupId) {
  1071. let commands = customCommands[groupId] ? Object.entries(customCommands[groupId]) : [];
  1073. commands.sort((a, b) => a[1].order - b[1].order);
  1075. const buttons = commands.map(command => ({ text: command[0], callback_data: JSON.stringify({ command: `action_${command[0]}` }) }));
  1076. const buttonsInRows = [];
  1077. for (let i = 0; i < buttons.length; i += 2) {
  1078. buttonsInRows.push(buttons.slice(i, i + 2));
  1079. }
  1080. return {
  1081. reply_markup: {
  1082. inline_keyboard: buttonsInRows
  1083. }
  1084. };
  1085. }
  1086. function isChatAllowed(chatId) {
  1087. return allowedGroupIds.includes(chatId.toString());
  1088. }
  1089. function saveWarnings() {
  1090. try {
  1091. fs.writeFileSync(jsonFilePathWarnings, JSON.stringify(warnings, null, 4));
  1092. console.log('Warnings salvos com sucesso.');
  1093. } catch (error) {
  1094. console.error('Erro ao salvar os warnings no arquivo JSON:', error);
  1095. }
  1096. }
comments powered by Disqus