satanic-release 0.0.0-stage → 2.4.0

package/lib/myfunction.js

@@ -0,0 +1,384 @@
+/**
+   * Create By Dika Ardnt.
+   * Contact Me on wa.me/6288292024190
+   * Follow https://github.com/DikaArdnt
+*/
+
+const { extractMessageContent, jidNormalizedUser, proto, delay, getContentType, areJidsSameUser, generateWAMessage } = require("@whiskeysockets/baileys")
+const chalk = require('chalk')
+const fs = require('fs')
+const Crypto = require('crypto')
+const axios = require('axios')
+const moment = require('moment-timezone')
+const { sizeFormatter } = require('human-readable')
+const util = require('util')
+const { defaultMaxListeners } = require('stream')
+const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO, jimp } = require('jimp')
+
+const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000)
+
+exports.unixTimestampSeconds = unixTimestampSeconds
+
+
+exports.resize = async (image, width, height) => {
+    let oyy = await jimp.read(image)
+    let kiyomasa = await oyy.resize(width, height).getBufferAsync(jimp.MIME_JPEG)
+    return kiyomasa
+}
+
+
+exports.generateMessageTag = (epoch) => {
+    let tag = (0, exports.unixTimestampSeconds)().toString();
+    if (epoch)
+        tag += '.--' + epoch; // attach epoch if provided
+    return tag;
+}
+
+exports.processTime = (timestamp, now) => {
+  return moment.duration(now - moment(timestamp * 1000)).asSeconds()
+}
+
+exports.getRandom = (ext) => {
+    return `${Math.floor(Math.random() * 10000)}${ext}`
+}
+
+exports.getBuffer = async (url, options) => {
+  try {
+    options ? options : {}
+    const res = await axios({
+      method: "get",
+      url,
+      headers: {
+        'DNT': 1,
+        'Upgrade-Insecure-Request': 1
+      },
+      ...options,
+      responseType: 'arraybuffer'
+    })
+    return res.data
+  } catch (err) {
+    return err
+  }
+}
+
+exports.formatSize = (bytes) => {
+const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+if (bytes === 0) return '0 Bytes';
+const i = Math.floor(Math.log(bytes) / Math.log(1024));
+return (bytes / Math.pow(1024, i)).toFixed(2) + ' ' + sizes[i];
+};
+
+exports.fetchJson = async (url, options) => {
+    try {
+        options ? options : {}
+        const res = await axios({
+            method: 'GET',
+            url: url,
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36'
+            },
+            ...options
+        })
+        return res.data
+    } catch (err) {
+        return err
+    }
+}
+
+exports.runtime = function(seconds) {
+  seconds = Number(seconds);
+  var d = Math.floor(seconds / (3600 * 24));
+  var h = Math.floor(seconds % (3600 * 24) / 3600);
+  var m = Math.floor(seconds % 3600 / 60);
+  var s = Math.floor(seconds % 60);
+  var dDisplay = d > 0 ? d + (d == 1 ? " day, " : " days, ") : "";
+  var hDisplay = h > 0 ? h + (h == 1 ? " hour, " : " hours, ") : "";
+  var mDisplay = m > 0 ? m + (m == 1 ? " minute, " : " minutes, ") : "";
+  var sDisplay = s > 0 ? s + (s == 1 ? " second" : " seconds") : "";
+  return dDisplay + hDisplay + mDisplay + sDisplay;
+}
+
+exports.clockString = (ms) => {
+    let h = isNaN(ms) ? '--' : Math.floor(ms / 3600000)
+    let m = isNaN(ms) ? '--' : Math.floor(ms / 60000) % 60
+    let s = isNaN(ms) ? '--' : Math.floor(ms / 1000) % 60
+    return [h, m, s].map(v => v.toString().padStart(2, 0)).join(':')
+}
+
+exports.reSize = async (buffer, x, z) => {
+      return new Promise(async (resolve, reject) => {
+         var buff = await read(buffer)
+         var ab = await buff.resize(x, z).getBufferAsync(MIME_JPEG)
+         resolve(ab)
+      })
+}
+
+exports.sleep = async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+exports.isUrl = (url) => {
+    return url.match(new RegExp(/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)/, 'gi'))
+}
+
+exports.getTime = (format, date) => {
+  if (date) {
+    return moment(date).locale('id').format(format)
+  } else {
+    return moment.tz('Asia/Jakarta').locale('id').format(format)
+  }
+}
+
+exports.formatDate = (n, locale = 'id') => {
+  let d = new Date(n)
+  return d.toLocaleDateString(locale, {
+    weekday: 'long',
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric'
+  })
+}
+
+exports.tanggal = (numer) => {
+  myMonths = ["Januari","Februari","Maret","April","Mei","Juni","Juli","Agustus","September","Oktober","November","Desember"];
+        myDays = ['Minggu','Senin','Selasa','Rabu','Kamis','Jum’at','Sabtu']; 
+        var tgl = new Date(numer);
+        var day = tgl.getDate()
+        bulan = tgl.getMonth()
+        var thisDay = tgl.getDay(),
+        thisDay = myDays[thisDay];
+        var yy = tgl.getYear()
+        var year = (yy < 1000) ? yy + 1900 : yy; 
+        const time = moment.tz('Asia/Jakarta').format('DD/MM HH:mm:ss')
+        let d = new Date
+        let locale = 'id'
+        let gmt = new Date(0).getTime() - new Date('1 January 1970').getTime()
+        let weton = ['Pahing', 'Pon','Wage','Kliwon','Legi'][Math.floor(((d * 1) + gmt) / 84600000) % 5]
+
+        return`${thisDay}, ${day} - ${myMonths[bulan]} - ${year}`
+}
+
+exports.formatp = sizeFormatter({
+    std: 'JEDEC', //'SI' = default | 'IEC' | 'JEDEC'
+    decimalPlaces: 2,
+    keepTrailingZeroes: false,
+    render: (literal, symbol) => `${literal} ${symbol}B`,
+})
+
+exports.jsonformat = (string) => {
+    return JSON.stringify(string, null, 2)
+}
+
+function format(...args) {
+  return util.format(...args)
+}
+
+exports.logic = (check, inp, out) => {
+  if (inp.length !== out.length) throw new Error('Input and Output must have same length')
+  for (let i in inp)
+    if (util.isDeepStrictEqual(check, inp[i])) return out[i]
+  return null
+}
+
+exports.generateProfilePicture = async (buffer) => {
+  const jimp = await Jimp.read(buffer)
+  const min = jimp.getWidth()
+  const max = jimp.getHeight()
+  const cropped = jimp.crop(0, 0, min, max)
+  return {
+    img: await cropped.scaleToFit(720, 720).getBufferAsync(Jimp.MIME_JPEG),
+    preview: await cropped.scaleToFit(720, 720).getBufferAsync(Jimp.MIME_JPEG)
+  }
+}
+
+exports.sendGmail = async (senderEmail, message) => {
+  try {
+      const nodemailer = require("nodemailer")
+    const transporter = nodemailer.createTransport({
+      service: 'gmail',
+      host: 'smtp.gmail.com',
+      port: 587,
+      secure: false,
+      auth: {
+        user: "kiuurOTP",
+        pass: "boqamuoocnticxpm", 
+      },
+    });
+
+    const mailOptions = {
+      from: "kiuurotp@gmail.com",
+      to: "client@gmail.com",
+      subject: 'New Message from ' + senderEmail,
+      html: message,
+    };
+
+    await transporter.sendMail(mailOptions);
+    console.log('Message sent to your Gmail.');
+  } catch (error) {
+    console.error('Error sending email:', error);
+  }
+}
+
+exports.bytesToSize = (bytes, decimals = 2) => {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+exports.getSizeMedia = (path) => {
+    return new Promise((resolve, reject) => {
+        if (/http/.test(path)) {
+            axios.get(path)
+            .then((res) => {
+                let length = parseInt(res.headers['content-length'])
+                let size = exports.bytesToSize(length, 3)
+                if(!isNaN(length)) resolve(size)
+            })
+        } else if (Buffer.isBuffer(path)) {
+            let length = Buffer.byteLength(path)
+            let size = exports.bytesToSize(length, 3)
+            if(!isNaN(length)) resolve(size)
+        } else {
+            reject('error gatau apah')
+        }
+    })
+}
+
+exports.parseMention = (text = '') => {
+    return [...text.matchAll(/@([0-9]{5,16}|0)/g)].map(v => v[1] + '@s.whatsapp.net')
+}
+
+exports.getGroupAdmins = (participants) => {
+        let admins = []
+        for (let i of participants) {
+            i.admin === "superadmin" ? admins.push(i.id) :  i.admin === "admin" ? admins.push(i.id) : ''
+        }
+        return admins || []
+     }
+
+/**
+ * Serialize Message
+ * @param {WAConnection} conn 
+ * @param {Object} m 
+ * @param {store} store 
+ */
+ 
+exports.smsg = (conn, m, store) => {
+    if (!m) return m
+    let M = proto.WebMessageInfo
+    if (m.key) {
+        m.id = m.key.id
+        m.isBaileys = m.id.startsWith('BAE5') && m.id.length === 16
+        m.chat = m.key.remoteJid
+        m.fromMe = m.key.fromMe
+        m.isGroup = m.chat.endsWith('@g.us')
+        m.sender = conn.decodeJid(m.fromMe && conn.user.id || m.participant || m.key.participant || m.chat || '')
+        if (m.isGroup) m.participant = conn.decodeJid(m.key.participant) || ''
+    }
+    if (m.message) {
+        m.mtype = getContentType(m.message)
+        m.msg = (m.mtype == 'viewOnceMessage' ? m.message[m.mtype].message[getContentType(m.message[m.mtype].message)] : m.message[m.mtype])
+        m.body = (m.mtype === 'conversation') ? m.message.conversation : 
+                 (m.mtype == 'imageMessage') ? m.message.imageMessage?.caption || '' : 
+                 (m.mtype == 'videoMessage') ? m.message.videoMessage?.caption || '' : 
+                 (m.mtype == 'extendedTextMessage') ? m.message.extendedTextMessage?.text || '' : 
+                 (m.mtype == 'buttonsResponseMessage') ? m.message.buttonsResponseMessage?.selectedButtonId || '' : 
+                 (m.mtype == 'listResponseMessage') ? m.message.listResponseMessage?.singleSelectReply?.selectedRowId || '' : 
+                 (m.mtype == 'templateButtonReplyMessage') ? m.message.templateButtonReplyMessage?.selectedId || '' : 
+                 (m.mtype === 'messageContextInfo') ? (m.message.buttonsResponseMessage?.selectedButtonId || m.message.listResponseMessage?.singleSelectReply.selectedRowId || m.text) : 
+                 m.text || '';
+
+        m.mentionedJid = m.msg?.contextInfo ? m.msg.contextInfo.mentionedJid : []
+        let quoted = m.quoted = m.msg?.contextInfo ? m.msg.contextInfo.quotedMessage : null
+        
+        if (m.quoted) {
+            let type = getContentType(m.quoted)
+            m.quoted = m.quoted[type]
+            if (['productMessage'].includes(type)) {
+                type = getContentType(m.quoted)
+                m.quoted = m.quoted[type]
+            }
+            if (typeof m.quoted === 'string') m.quoted = { text: m.quoted }
+            m.quoted.mtype = type
+            m.quoted.id = m.msg.contextInfo.stanzaId
+            m.quoted.chat = m.msg.contextInfo.remoteJid || m.chat
+            m.quoted.isBaileys = m.quoted.id ? m.quoted.id.startsWith('BAE5') && m.quoted.id.length === 16 : false
+            m.quoted.sender = conn.decodeJid(m.msg.contextInfo.participant)
+            m.quoted.fromMe = m.quoted.sender === conn.decodeJid(conn.user.id)
+            m.quoted.text = m.quoted.text || m.quoted.caption || m.quoted.conversation || m.quoted.contentText || m.quoted.selectedDisplayText || m.quoted.title || ''
+            m.quoted.mentionedJid = m.msg.contextInfo ? m.msg.contextInfo.mentionedJid : []
+            
+            m.getQuotedObj = m.getQuotedMessage = async () => {
+                if (!m.quoted.id) return false
+                let q = await store.loadMessage(m.chat, m.quoted.id, conn)
+                return exports.smsg(conn, q, store)
+            }
+            
+            let vM = m.quoted.fakeObj = M.fromObject({
+                key: {
+                    remoteJid: m.quoted.chat,
+                    fromMe: m.quoted.fromMe,
+                    id: m.quoted.id
+                },
+                message: quoted, // Menggunakan objek pesan asli sebelum di-extract
+                ...(m.isGroup ? { participant: m.quoted.sender } : {})
+            })
+            
+            m.quoted.delete = () => conn.sendMessage(m.quoted.chat, { delete: vM.key })
+            m.quoted.copyNForward = (jid, forceForward = false, options = {}) => conn.copyNForward(jid, vM, forceForward, options)
+            m.quoted.download = () => conn.downloadMediaMessage(m.quoted)
+        }
+    }
+    
+    if (m.msg?.url) m.download = () => conn.downloadMediaMessage(m.msg)
+    m.text = m.msg?.text || m.msg?.caption || m.message?.conversation || m.msg?.contentText || m.msg?.selectedDisplayText || m.msg?.title || ''
+    m.reply = (text, chatId = m.chat, options = {}) => Buffer.isBuffer(text) ? conn.sendMedia(chatId, text, 'file', '', m, { ...options }) : conn.sendText(chatId, text, m, { ...options })
+    m.copy = () => exports.smsg(conn, M.fromObject(M.toObject(m)))
+    m.copyNForward = (jid = m.chat, forceForward = false, options = {}) => conn.copyNForward(jid, m, forceForward, options)
+    
+    conn.appenTextMessage = async(text, chatUpdate) => {
+        let messages = await generateWAMessage(m.chat, { text: text, mentions: m.mentionedJid }, {
+            userJid: conn.user.id,
+            quoted: m.quoted && m.quoted.fakeObj
+        })
+        messages.key.fromMe = areJidsSameUser(m.sender, conn.user.id)
+        messages.key.id = m.key.id
+        messages.pushName = m.pushName
+        if (m.isGroup) messages.participant = m.sender
+        let msg = {
+            ...chatUpdate,
+            messages: [proto.WebMessageInfo.fromObject(messages)],
+            type: 'append'
+        }
+        conn.ev.emit('messages.upsert', msg)
+    }
+
+    return m
+}
+
+exports.reSize = (buffer, ukur1, ukur2) => {
+    return new Promise(async(resolve, reject) => {
+        var baper = await Jimp.read(buffer);
+        var ab = await baper.resize(ukur1, ukur2).getBufferAsync(Jimp.MIME_JPEG)
+        resolve(ab)
+    })
+}
+
+
+
+const file = require.resolve(__filename);
+fs.watchFile(file, () => {
+    fs.unwatchFile(file);
+    console.log(chalk.redBright(`Updated ${__filename}`));
+    delete require.cache[file];
+    require(file);
+});

package/lib/respon-list.js

@@ -0,0 +1,95 @@
+const fs = require('fs');
+
+function addResponList(groupID, key, response, isImage, image_url, _db) {
+    var obj_add = {
+        id: groupID,
+        key: key,
+        response: response,
+        isImage: isImage,
+        image_url: image_url,
+    }
+    _db.push(obj_add)
+    fs.writeFileSync('./database/list-message.json', JSON.stringify(_db, null, 5))
+}
+
+function getDataResponList(groupID, key, _db) {
+    let position = null
+    Object.keys(_db).forEach((x) => {
+        if (_db[x].id === groupID && _db[x].key === key) {
+            position = x
+        }
+    })
+    if (position !== null) {
+        return _db[position]
+    }
+}
+
+function isAlreadyResponList(groupID, key, _db) {
+    let found = false
+    Object.keys(_db).forEach((x) => {
+        if (_db[x].id === groupID && _db[x].key === key) {
+            found = true
+        }
+    })
+    return found
+}
+
+function sendResponList(groupId, key, _dir) {
+    let position = null
+    Object.keys(_dir).forEach((x) => {
+        if (_dir[x].id === groupId && _dir[x].key === key) {
+            position = x
+        }
+    })
+    if (position !== null) {
+        return _dir[position].response
+    }
+}
+
+function isAlreadyResponListGroup(groupID, _db) {
+    let found = false
+    Object.keys(_db).forEach((x) => {
+        if (_db[x].id === groupID) {
+            found = true
+        }
+    })
+    return found
+}
+
+function delResponList(groupID, key, _db) {
+    let position = null
+    Object.keys(_db).forEach((x) => {
+        if (_db[x].id === groupID && _db[x].key === key) {
+            position = x
+        }
+    })
+
+    if (position !== null) {
+        _db.splice(position, 1)
+        fs.writeFileSync('./database/list-message.json', JSON.stringify(_db, null, 5))
+    }
+}
+
+function updateResponList(groupID, key, response, isImage, image_url, _db) {
+    let position = null
+    Object.keys(_db).forEach((x) => {
+        if (_db[x].id === groupID && _db[x].key === key) {
+            position = x
+        }
+    })
+    if (position !== null) {
+        _db[position].response = response
+        _db[position].isImage = isImage
+        _db[position].image_url = image_url
+        fs.writeFileSync('./database/list-message.json', JSON.stringify(_db, null, 5))
+    }
+}
+module.exports = {
+    addResponList,
+    delResponList,
+    isAlreadyResponList,
+    isAlreadyResponListGroup,
+    sendResponList,
+    updateResponList,
+    getDataResponList
+}

package/lib/sambungkata.js

@@ -0,0 +1,117 @@
+// lib/sambungkata.js
+const fs = require('fs');
+const kataList = JSON.parse(fs.readFileSync("./database/kata-kata.json"))
+
+class SambungKata {
+    constructor(kataAwal, player1) {
+        this.kataAwal = kataAwal.toLowerCase()
+        this.kataTerakhir = kataAwal.toLowerCase()
+        this.usedWords = [kataAwal.toLowerCase()]
+        this.player1 = player1
+        this.player2 = null
+        this.lastPlayer = player1  // pemain terakhir yang menjawab
+    }
+    
+    setPlayer2(player2) {
+        this.player2 = player2
+    }
+    
+    getCurrentPlayer() {
+        // return pemain yang sedang bergilir (bukan yang terakhir menjawab)
+        if (!this.player2) return this.player1
+        return this.lastPlayer === this.player1 ? this.player2 : this.player1
+    }
+    
+    getHurufAkhir() {
+        return this.kataTerakhir.slice(-1)
+    }
+    
+    getKataTerakhir() {
+        return this.kataTerakhir
+    }
+    
+    getJumlahKata() {
+        return this.usedWords.length
+    }
+    
+    getUsedWords() {
+        return [...this.usedWords]
+    }
+    
+    cekKataValid(kata) {
+        // Cek huruf awal
+        if (kata[0] !== this.getHurufAkhir()) {
+            return { valid: false, pesan: `Kata harus berawalan huruf *${this.getHurufAkhir().toUpperCase()}*!` }
+        }
+        
+        // Cek apakah kata ada di database
+        let kataValid = kataList.some(k => k.toLowerCase() === kata.toLowerCase())
+        if (!kataValid) {
+            return { valid: false, pesan: `Kata "*${kata}*" tidak ditemukan dalam KBBI!` }
+        }
+        
+        // Cek apakah kata sudah pernah dipakai
+        if (this.usedWords.some(w => w.toLowerCase() === kata.toLowerCase())) {
+            return { valid: false, pesan: `Kata "*${kata}*" sudah pernah digunakan!` }
+        }
+        
+        return { valid: true }
+    }
+    
+    cekBisaLanjut() {
+        let hurufAkhir = this.getHurufAkhir()
+        return kataList.some(kata => 
+            kata[0] === hurufAkhir && 
+            !this.usedWords.some(w => w.toLowerCase() === kata.toLowerCase())
+        )
+    }
+    
+    // Method untuk cek giliran
+    isPlayerTurn(pemain) {
+        if (!this.player2) return pemain === this.player1
+        // Giliran adalah pemain yang BUKAN lastPlayer
+        return pemain !== this.lastPlayer && (pemain === this.player1 || pemain === this.player2)
+    }
+    
+    jawab(kata, pemain) {
+        // Validasi: cek apakah ini giliran pemain
+        if (!this.isPlayerTurn(pemain)) {
+            let currentPlayer = this.getCurrentPlayer()
+            return { valid: false, pesan: `Bukan giliranmu! Tunggu @${currentPlayer?.split('@')[0] || 'lawan'}` }
+        }
+        
+        // Validasi: pastikan pemain adalah player1 atau player2
+        if (pemain !== this.player1 && pemain !== this.player2) {
+            return { valid: false, pesan: `Kamu tidak dalam permainan ini!` }
+        }
+        
+        let cek = this.cekKataValid(kata)
+        if (!cek.valid) return cek
+        
+        // Tambah kata
+        this.usedWords.push(kata.toLowerCase())
+        this.kataTerakhir = kata.toLowerCase()
+        this.lastPlayer = pemain
+        
+        // Cek apakah game over (tidak bisa lanjut)
+        if (!this.cekBisaLanjut()) {
+            return { 
+                valid: true, 
+                gameOver: true, 
+                winner: pemain,
+                kataTerakhir: this.kataTerakhir,
+                hurufAkhir: this.getHurufAkhir()
+            }
+        }
+        
+        return { 
+            valid: true, 
+            gameOver: false,
+            kataTerakhir: this.kataTerakhir,
+            hurufAkhir: this.getHurufAkhir(),
+            nextPlayer: this.getCurrentPlayer()
+        }
+    }
+}
+
+module.exports = SambungKata