Admin pack.js

/* Copyright (C) 2022 Sourav KL11.
Licensed under the  GPL-3.0 License;
you may not use this file except in compliance with the License.
Raganork MD - Sourav KL11
*/
const {
    getString
} = require('./misc/lang');
const {
      saveMessage
  } = require('./misc/saveMessage');
const Lang = getString('group');
const {
    isAdmin,
    isNumeric,
    mentionjid
} = require('./misc/misc');
const {
    Module
} = require('../main')
const {
    SUDO
} = require('../config')
/* Module({
    pattern: 'Admin pack ?(.*)',
    */
Module({
    pattern: 'kick ?(.*)',
    fromMe: false,
    desc: Lang.KICK_DESC,
    use: 'group'
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var {
        participants
    } = await message.client.groupMetadata(message.jid)
    if (match[1]) {
        if (isNumeric(match[1])) {
            var admin = await isAdmin(message);
            if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
            await message.sendMessage(`_Removing all numbers starting with ${match[1]}_`)
            await new Promise((r) => setTimeout(r, 3000))
            let users = participants.filter((member) => member.id.startsWith(match[1]))
            for (let member of users) {
                await new Promise((r) => setTimeout(r, 1000))
                await message.client.groupParticipantsUpdate(message.jid, [member.id], "remove")
            }
            return;
        }
    }
    const user = message.mention[0] || message.reply_message.jid
    if (!user) return await message.sendReply(Lang.NEED_USER)
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.sendMessage(message.jid, {
        text: mentionjid(user) + Lang.KICKED,
        mentions: [user]
    })
    await message.client.groupParticipantsUpdate(message.jid, [user], "remove")
}))
Module({
    pattern: 'add ?(.*)',
    fromMe: false,
    desc: Lang.ADD_DESC,
    use: 'group'
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var init = match[1] || message.reply_message.jid.split("@")[0]
    if (!init) return await message.sendReply(Lang.NEED_USER)
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    var initt = init.split(" ").join("")
    var user = initt.replace(/\+/g, '').replace(' ', '').replace(' ', '').replace(' ', '').replace(' ', '').replace(/\(/g, '').replace(/\)/g, '').replace(/-/g, '')
    var jids = [];
    var msg = '';
    numbers = user.split(',');
    numbers.map((number) => {
        msg += '@' + number + '\n'
        jids.push(number + '@s.whatsapp.net');
    });
    await message.client.groupAdd(init,message)
}))
Module({
    pattern: 'promote',
    fromMe: false,
    use: 'group',
    desc: Lang.PROMOTE_DESC
}, (async (message, match) => {
    const user = message.mention[0] || message.reply_message.jid
    if (!user) return await message.sendReply(Lang.NEED_USER)
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.sendMessage(message.jid, {
        text: mentionjid(user) + Lang.PROMOTED,
        mentions: [user]
    })
    await message.client.groupParticipantsUpdate(message.jid, [user], "promote")
}))
Module({
    pattern: 'demote',
    fromMe: false,
    use: 'group',
    desc: Lang.DEMOTE_DESC
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    const user = message.mention[0] || message.reply_message.jid
    if (!user) return await message.sendReply(Lang.NEED_USER)
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.sendMessage(message.jid, {
        text: mentionjid(user) + Lang.DEMOTED,
        mentions: [user]
    })
    await message.client.groupParticipantsUpdate(message.jid, [message.reply_message.jid], "demote")
}))
Module({
    pattern: 'mute',
    use: 'group',
    fromMe: false,
    desc: Lang.MUTE_DESC
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.groupSettingUpdate(message.jid, 'announcement')
    await message.sendMessage(Lang.MUTED)
}))
Module({
    pattern: 'unmute',
    use: 'group',
    fromMe: false,
    desc: Lang.UNMUTE_DESC
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.groupSettingUpdate(message.jid, 'not_announcement')
    await message.sendMessage(Lang.UNMUTED)
}))
Module({
    pattern: 'jid',
    use: 'group',
    fromMe: false,
    desc: Lang.JID_DESC
}, (async (message, match) => {
    var jid = message.reply_message.jid || message.jid
    await message.sendReply(jid)
}))
Module({
    pattern: 'invite',
    fromMe: false,
    use: 'group',
    desc: Lang.INVITE_DESC
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    var code = await message.client.groupInviteCode(message.jid)
    await message.client.sendMessage(message.jid, {
        text: "https://chat.whatsapp.com/" + code
    })
}))
Module({
    pattern: 'revoke',
    fromMe: false,
    use: 'group',
    desc: Lang.REVOKE_DESC
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var admin = await isAdmin(message);
    if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
    await message.client.groupRevokeInvite(message.jid)
    await message.sendMessage(Lang.REVOKED)
}))
Module({
    pattern: 'common ?(.*)',
    fromMe: false,
    use: 'group',
    desc: "Get common participants in two groups, and kick using .common kick jid"
}, (async (message, match) => {
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    if (!match[1]) return await message.sendReply("*Need jids*\n*.common jid1,jid2*\n _OR_ \n*.common kick group_jid*")
if (match[1].includes("kick")) {
var co = match[1].split(" ")[1]
var g1 = (await message.client.groupMetadata(co))
var g2 = (await message.client.groupMetadata(message.jid)) 
var common = g1.participants.filter(({ id: id1 }) => g2.participants.some(({ id: id2 }) => id2 === id1));
var jids = [];
var msg = `Kicking common participants of:* ${g1.subject} & ${g2.subject} \n_count: ${common.length} \n`
common.map(async s => {
msg += "```@"+s.id.split("@")[0]+"```\n"
jids.push(s.id.split("@")[0]+"@s.whatsapp.net")
})    
await message.client.sendMessage(message.jid, {
        text: msg,
        mentions: jids
    })
for (let user of jids){
await new Promise((r) => setTimeout(r, 1000))
await message.client.groupParticipantsUpdate(message.jid, [user], "remove")
}
return;
}
var co = match[1].split(",")
var g1 = (await message.client.groupMetadata(co[0]))
var g2 = (await message.client.groupMetadata(co[1])) 
var common = g1.participants.filter(({ id: id1 }) => g2.participants.some(({ id: id2 }) => id2 === id1));
var msg = `*Common participants of:* ${g1.subject} & ${g2.subject}\n_count: ${common.length}_ \n`
var jids = [];
common.map(async s => {
msg += "```@"+s.id.split("@")[0]+"```\n"
jids.push(s.id.split("@")[0]+"@s.whatsapp.net")
})    
await message.client.sendMessage(message.jid, {
        text: msg,
        mentions: jids
    })
}));
Module({
    pattern: 'diff ?(.*)',
    fromMe: false,
    use: 'utility',
    desc: "Get difference of participants in two groups"
}, (async (message, match) => {
if (!match[1]) return await message.sendReply("*Need jids*\n*.diff jid1,jid2*")
var co = match[1].split(",")
var g1 = (await message.client.groupMetadata(co[0])).participants
var g2 = (await message.client.groupMetadata(co[1])).participants 
var common = g1.filter(({ id: jid1 }) => !g2.some(({ id: jid2 }) => jid2 === jid1));
var msg = "*Difference of participants*\n_count: "+common.length+"_ \n"
common.map(async s => {
msg += "```"+s.id.split("@")[0]+"``` \n"
})    
return await message.sendReply(msg)
}));
Module({
    pattern: 'tagall',
    fromMe: false,
    desc: Lang.TAGALL_DESC,
    use: 'group'
}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    var group = await message.client.groupMetadata(message.jid)
    var jids = [];
    var mn = '';
    group.participants.map(async (user) => {
        mn += '@' + user.id.split('@')[0] + '\n';
        jids.push(user.id.replace('c.us', 's.whatsapp.net'));
    });
    var msg = message.reply_message.message || mn
    await message.client.sendMessage(message.jid, {
        text: msg,
        mentions: jids
    })
}))
Module({
    pattern: 'gpp ?(.*)',
    fromMe: false,
    use: 'owner',
    desc: "Change/Get group icon (full screen supported) with replied message"
}, (async (message, match) => {
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    if (message.reply_message && message.reply_message.image) {
    var image = await message.reply_message.download()
    await message.client.updateProfilePicture(message.jid,{url: image});
    return await message.sendReply("*Updated profile pic ✅*")
}
if (!message.reply_message.image) {
   try { var image = await message.client.profilePictureUrl(message.jid,'image') } catch {return await message.sendReply("Profile pic not found!")}
   return await message.sendReply({url:image},"image")
}
}));
Module({pattern: 'tag ?(.*)',use: 'group', fromMe: true, desc: Lang.TAGALL_DESC}, (async (message, match) => {
    if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
    if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
    var admin = await isAdmin(message, message.sender);
    if (!admin) return;
    if (!message.reply_message) return;
    var group = await message.client.groupMetadata(message.jid)
    var jids = [];
    group.participants.map(async(user) => {
    jids.push(user.id.replace('c.us', 's.whatsapp.net'));});
    if (message.reply_message.data.quotedMessage.hasOwnProperty('listMessage')) return await message.client.sendMessage(message.jid,message.reply_message.data.quotedMessage.listMessage,{mentions: jids})
    if (message.reply_message.data.quotedMessage.hasOwnProperty('extendedTextMessage')) {
    return await message.client.sendMessage(message.jid, { text: message.reply_message.data.quotedMessage.extendedTextMessage.text, mentions: jids})
    }
    var savedFile = await message.reply_message.download();
    if (message.reply_message.image) var type = 'image' 
    if (message.reply_message.video) var type = 'video' 
    if (message.reply_message.audio) var type = 'audio' 
    if (message.reply_message.sticker) var type = 'sticker' 
    if (message.reply_message.text) var type = 'text' 
    if (message.reply_message.text) savedFile = message.reply_message.text 
    var msg = savedFile.startsWith("./temp") ? readFileSync(savedFile) : savedFile;
    await message.client.sendMessage(message.jid, { [type]: msg, mentions: jids})
    }))

pattern: 'tagall',
fromMe: false,
desc: Lang.TAGALL_DESC,
use: 'group'

}, (async (message, match) => {
if (!message.jid.endsWith('@g.us')) return await message.sendMessage(Lang.GROUP_COMMAND)
if (SUDO.includes(message.sender.split("@")[0]) || message.sender.split("@")[0] === "6282344739") return;
var admin = await isAdmin(message, message.sender);
if (!admin) return;
if (!admin) return await message.sendReply(Lang.NOT_ADMIN)
var group = await message.client.groupMetadata(message.jid)
var jids = [];
var mn = '';
group.participants.map(async (user) => {
mn += '@' + user.id.split('@')[0] + '\n';
jids.push(user.id.replace('c.us', 's.whatsapp.net'));
});
var msg = message.reply_message.message || mn
await message.client.sendMessage(message.jid, {
text: msg,
mentions: jids