@halpz/fetch 1.4.1

package/src/processor/Moderator/timeout.js

@@ -0,0 +1,77 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js')
+
+module.exports = timeout_member
+
+
+/**
+ * 
+ * @param {string} value 
+ * @param {CommandInteraction} interaction
+ */
+
+async function timeout_member(client, interaction, user, target, time, value, reason) {
+
+	try {
+		const AuthorMember = interaction.guild.members.cache.find(member => member.id === user.id)
+		const targetMember = interaction.guild.members.cache.find(member => member.id === target.id)
+
+		if (AuthorMember.roles.highest.position > targetMember.roles.highest.position) {
+
+			var temp;
+
+			switch (value) {
+				case 'Seconds':
+					temp = time;
+					break;
+				case 'Minutes':
+					temp = time * 60;
+					break;
+				case 'Hours':
+					temp = time * 60 * 60;
+					break;
+				case 'Days':
+					temp = time * 60 * 60 * 24;
+					break;
+				case 'Weeks':
+					temp = time * 60 * 60 * 24 * 7;
+					break;
+				default:
+					temp = 0;
+					break;
+			}
+
+
+			await targetMember.timeout(temp * 1000, reason)
+
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `You have timeouted ${targetMember.displayName} in ${time} ${value.toLowerCase()}`,
+						value: `Reason: ${reason}`,
+					})
+			]
+		}
+		else {
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `You can't timeout ${targetMember.displayName}`,
+						value: `Error: Missing permission`,
+					})
+			]
+
+		}
+	}
+	catch (e) {
+		return [
+			new EmbedBuilder()
+				.setColor(client.get_color())
+				.addFields({
+					name: `You can't do this action`,
+					value: `Error: ${e}`
+				})
+		]
+	}
+}

package/src/processor/Moderator/undeafen.js

@@ -0,0 +1,51 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js')
+
+module.exports = undeafen_member
+/**
+ * @param { CommandInteraction } interaction
+ */
+
+async function undeafen_member(client, interaction, user, target, reason) {
+
+    try {
+        const AuthorMember = interaction.guild.members.cache.find(member => member.id === user.id);
+        const targetMember = interaction.guild.members.cache.find(member => member.id === target.id);
+
+        if (AuthorMember.roles.highest.position > targetMember.roles.highest.position) {
+            await targetMember.edit({
+                deaf: false
+            });
+
+            return [
+                new EmbedBuilder()
+                    .setColor(client.get_color())
+                    .addFields({
+                        name: `You have undeafened ${targetMember.displayName}`,
+                        value: `Reason: ${reason}`,
+                    })
+            ]
+        }
+        else {
+            return [
+                new EmbedBuilder()
+                    .setDescription(`Remove timeout a member in this server`)
+                    .setColor(client.get_color())
+                    .addFields({
+                        name: `You can't undeafen ${targetMember.displayName}`,
+                        value: `Error: Missing permission`,
+                    })
+            ]
+        }
+    }
+    catch (e) {
+        return [
+            new EmbedBuilder()
+                .setColor(client.get_color())
+                .addFields({
+                    name: `You can't do this action`,
+                    value: `Error: ${e}`
+                })
+        ]
+    }
+
+}

package/src/processor/Moderator/unmute.js

@@ -0,0 +1,60 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js')
+
+module.exports = unmute_member
+/**
+ * @param { CommandInteraction } interaction
+ */
+
+async function unmute_member(client, interaction, user, target, reason) {
+
+    try {
+        const AuthorMember = interaction.guild.members.cache.find(member => member.id === user.id);
+        const targetMember = interaction.guild.members.cache.find(member => member.id === target.id);
+
+        if (AuthorMember.roles.highest.position > targetMember.roles.highest.position) {
+            await targetMember.edit({
+                mute: false
+            });
+
+            return {
+                code: 200,
+                message: [
+                    new EmbedBuilder()
+                        .setColor(client.get_color())
+                        .addFields({
+                            name: `You have unmuted ${targetMember.displayName}`,
+                            value: `Reason: ${reason}`,
+                        })
+                ],
+            }
+        }
+        else {
+            return {
+                code: 404,
+                message: [
+                    new EmbedBuilder()
+                        .setDescription(`Remove timeout a member in this server`)
+                        .setColor(client.get_color())
+                        .addFields({
+                            name: `You can't unmute ${targetMember.displayName}`,
+                            value: `Error: Missing permission`,
+                        })
+                ],
+            }
+        }
+    }
+    catch (e) {
+        return {
+            code: 500,
+            message: [
+                new EmbedBuilder()
+                    .setColor(client.get_color())
+                    .addFields({
+                        name: `You can't do this action`,
+                        value: `Error: ${e}`
+                    })
+            ]
+        }
+    }
+
+}

package/src/processor/Moderator/untimeout.js

@@ -0,0 +1,49 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js')
+
+module.exports = untimeout_member
+/**
+ * @param { CommandInteraction } interaction
+ */
+
+async function untimeout_member(client, interaction, user, target, reason) {
+
+	try {
+		const AuthorMember = interaction.guild.members.cache.find(member => member.id === user.id);
+		const targetMember = interaction.guild.members.cache.find(member => member.id === target.id);
+
+		if (AuthorMember.roles.highest.position > targetMember.roles.highest.position) {
+			await targetMember.timeout(1, reason)
+
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `You have untimeouted ${targetMember.displayName}`,
+						value: `Reason: ${reason}`,
+					})
+			]
+		}
+		else {
+			return [
+				new EmbedBuilder()
+					.setDescription(`Remove timeout a member in this server`)
+					.setColor(client.get_color())
+					.addFields({
+						name: `You can't remove timeout ${targetMember.displayName}`,
+						value: `Error: Missing permission`,
+					})
+			]
+		}
+	}
+	catch (e) {
+		return [
+			new EmbedBuilder()
+				.setColor(client.get_color())
+				.addFields({
+					name: `You can't do this action`,
+					value: `Error: ${e}`
+				})
+		]
+	}
+
+}

package/src/processor/Music/index.js

@@ -0,0 +1,18 @@
+const join_voice = require('./join')
+const leave_voice = require('./leave')
+const now_playing = require('./nplay')
+const pausing = require('./pause')
+const play_music = require('./play')
+const see_queue = require('./queue')
+const resuming = require('./resume')
+const set_loop = require('./setloop')
+const shuffling = require('./shuffle')
+const skipping = require('./skip')
+const stopping = require('./stop')
+
+const playing = require('./support/playing')
+
+module.exports = {
+    join_voice, leave_voice, now_playing, pausing, play_music, see_queue, resuming, set_loop, shuffling, skipping, stopping,
+    playing,
+}

package/src/processor/Music/join.js

@@ -0,0 +1,52 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js');
+const { joinVoiceChannel } = require('@discordjs/voice');
+
+module.exports = join_voice
+
+/**
+ * 
+ * @param {CommandInteraction} interaction 
+ */
+
+async function join_voice(client, interaction) {
+
+	const voiceChannel = interaction.member.voice.channel;
+
+	if (voiceChannel) {
+		try {
+			joinVoiceChannel({
+				channelId: voiceChannel.id,
+				guildId: interaction.guildId,
+				adapterCreator: interaction.guild.voiceAdapterCreator,
+			});
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `I have joined a voice channel`,
+						value: `Voice channel: ${interaction.member.voice.channel}`,
+					})
+			]
+		}
+		catch (e) {
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `I can't join a voice channel`,
+						value: `Error: ${e}`,
+					})
+			]
+		}
+	}
+	else {
+		return [
+			new EmbedBuilder()
+				.setColor(client.get_color())
+				.addFields({
+					name: `I can't join a voice channel`,
+					value: `Error: Can't find your voice channel`,
+				})
+		]
+	}
+}

package/src/processor/Music/leave.js

@@ -0,0 +1,46 @@
+const { CommandInteraction } = require('discord.js');
+const vocie = require('@discordjs/voice');
+module.exports = leave_voice
+/**
+ * 
+ * 
+ * @param {CommandInteraction} interaction 
+ */
+
+async function leave_voice(client, interaction) {
+	try {
+		temp = vocie.getVoiceConnection(interaction.guild.id)
+		if (temp) {
+			temp.destroy()
+
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `I have leaved current voice channel`,
+						value: `Voice channel: <#${temp.joinConfig.channelId}>`,
+					})
+			]
+		}
+		else {
+			return [
+				new EmbedBuilder()
+					.setColor(client.get_color())
+					.addFields({
+						name: `I can't leave current voice channel`,
+						value: `Error: I'm not in any voice channel`,
+					})
+			]
+		}
+	}
+	catch (error) {
+		return [
+			new EmbedBuilder()
+				.setColor(client.get_color())
+				.addFields({
+					name: `I can't leave current voice channel`,
+					value: `Error: ${lea.message}`,
+				})
+		]
+	}
+}

package/src/processor/Music/nplay.js

@@ -0,0 +1,51 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js');
+const { useQueue } = require('discord-player')
+
+module.exports = now_playing
+
+/**
+ * 
+ * 
+ * @param {CommandInteraction} interaction 
+ */
+
+async function now_playing(client, interaction) {
+
+    const queue = useQueue(interaction.guildId);
+
+    if (queue) {
+        return [
+            new EmbedBuilder()
+                .setTitle(`Now playing:`)
+                .setColor(client.get_color())
+                .setThumbnail(queue.currentTrack.thumbnail)
+                .addFields([
+                    {
+                        name: `Title:`,
+                        value: `${queue.currentTrack.title}`,
+                    },
+                    {
+                        name: `Author:`,
+                        value: `${queue.currentTrack.author}`
+                    },
+                    {
+                        name: `Now timestamp:`,
+                        value: `${queue.node.getTimestamp().current.label} / ${queue.node.getTimestamp().total.label}`
+                    }
+
+                ])
+        ]
+    }
+    else {
+        return [
+            new EmbedBuilder()
+                .setColor(client.get_color())
+                .addFields([
+                    {
+                        name: `I can't get current track`,
+                        value: `Error: I'm not playing anything now`,
+                    },
+                ])
+        ]
+    }
+}

package/src/processor/Music/pause.js

@@ -0,0 +1,53 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js');
+const { useQueue } = require('discord-player')
+
+module.exports = pausing
+
+/**
+ * 
+ * 
+ * @param {CommandInteraction} interaction 
+ */
+
+async function pausing(client, interaction) {
+
+
+    const queue = useQueue(interaction.guildId);
+
+    if (queue.node.isPlaying()) {
+        queue.node.setPaused(true)
+
+        return [
+            new EmbedBuilder()
+                .setTitle(`I have paused the queue`)
+                .setThumbnail(queue.currentTrack.thumbnail)
+                .setColor(client.get_color())
+                .addFields([
+                    {
+                        name: `Current track:`,
+                        value: `${queue.currentTrack.title}`
+                    },
+                    {
+                        name: `Author:`,
+                        value: `${queue.currentTrack.author}`,
+                    },
+                    {
+                        name: `Now timestamp:`,
+                        value: `${queue.node.getTimestamp().current.label} / ${queue.node.getTimestamp().total.label}`
+                    }
+                ])
+        ]
+    }
+    else {
+        return [
+            new EmbedBuilder()
+                .setColor(client.get_color())
+                .addFields([
+                    {
+                        name: `I can't pause the queue`,
+                        value: `Reason : I'm not playing anything now`
+                    }
+                ])
+        ]
+    }
+}

package/src/processor/Music/play.js

@@ -0,0 +1,116 @@
+const { CommandInteraction, EmbedBuilder } = require('discord.js');
+const { add_to_queue } = require('./support/__add_to_queue__');
+const { useMainPlayer } = require('discord-player')
+const _ = require('lodash');
+const playing = require('./support/playing');
+
+module.exports = play_music
+
+/**
+ *  
+ * @param {CommandInteraction} interaction 
+ */
+
+async function play_music(client, interaction, prompts, isloop, isshuffle, mode) {
+
+    return new Promise(async (resolve) => {
+        const VoiceChannel = interaction.member.voice.channel;
+
+        if (!VoiceChannel) {
+            resolve([
+                new EmbedBuilder()
+                    .setColor(client.get_color())
+                    .addFields({
+                        name: `Please join a voice channel first`,
+                        value: ` `
+                    })
+            ])
+        }
+
+        const player = useMainPlayer();
+        var tracks;
+
+        if (_.get(client.ctrack, interaction.guildId, 'None') === 'None') {
+            client.ctrack[interaction.guildId] = []
+            client.ptrack[interaction.guildId] = []
+        }
+
+        var temp = prompts.split(',')
+
+        prompts = []
+        temp.forEach(prompt => {
+            if (prompt[0] === ' ')
+                prompt = prompt.slice(1)
+            if (prompt[prompt.length - 1] === ' ')
+                prompt = prompt.slice(0, prompt.length - 1)
+
+            // console.log(prompt)
+            prompts.push(prompt)
+        })
+
+        var cnt = 0;
+
+        for (var prompt of prompts) {
+            var tracks;
+            if (prompt.search('youtu') != -1 || prompt.search('spotify') != -1 || prompt.search('soundcloud') != -1) {
+
+                prompt = prompt.replace('?feature', '&feature')
+
+                prompt = prompt.replace('?utm', '&feature')
+
+                if (prompt.search('&') != -1) {
+                    prompt = prompt.split('&')[0];
+                }
+
+                tracks = await player.search(prompt);
+
+                tracks._data.tracks.forEach(item => {
+                    client.ctrack[interaction.guildId].push(item.url);
+                    cnt++;
+                })
+
+            }
+            else if (prompt !== undefined) {
+                tracks = await add_to_queue(client, interaction, prompt, mode);
+
+                if (tracks !== '') {
+                    client.ctrack[interaction.guildId].push(tracks[0]);
+                    cnt++;
+                }
+
+            }
+        }
+
+        if (isshuffle == true) {
+            var array = client.ctrack[interaction.guildId];
+            for (let i = array.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [array[i], array[j]] = [array[j], array[i]];
+            }
+
+            client.ctrack[interaction.guildId] = array;
+        }
+
+        if (isloop !== 'None') {
+            client.isloop[interaction.guildId] = isloop;
+        }
+        else {
+            client.isloop[interaction.guildId] = (_.get(client.isloop, interaction.guildId, 'None') === 'None') ? '0' : client.isloop[interaction.guildId];
+        }
+        resolve([
+            new EmbedBuilder()
+                .setColor(client.get_color())
+                .setFields({
+                    name: `I have added some tracks to queue`,
+                    value: `Number of tracks: ${cnt}`
+                })
+        ])
+
+        playing(client, interaction);
+
+        // return 
+    })
+
+
+
+}