src/utils/util.ts

import fs from 'fs';
import DiscordClient from '../client/Client';
import { GuildMember, Message, CommandInteraction, MessageEmbed, ContextMenuInteraction, Interaction } from 'discord.js';
import Axios, { AxiosRequestHeaders, HeadersDefaults } from 'axios';

export function shouldNotModerate(client: DiscordClient, member: GuildMember) {
    if (!client.config.props[member.guild.id].admin) {
        return false;
    }

    const role = client.config.props[member.guild.id].admin;

    return member.roles.cache.has(role);
}

export async function hasPermission(client: DiscordClient, member: GuildMember, msg: Message | CommandInteraction | ContextMenuInteraction, mod: GuildMember | null, error: string = "You don't have permission to moderate this user") {
    let m = mod;
    
    if (!m) {
        m = msg.member! as GuildMember;
    }
    
    if (member.roles.highest?.position >= m.roles.highest?.position) {
        if (msg instanceof Interaction && msg.deferred) {
            await msg.editReply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`:x: ${error}`)
                ]
            });

            return false;
        }

        await msg.reply({
            embeds: [
                new MessageEmbed()
                .setColor('#f14a60')
                .setDescription(`:x: ${error}`)
            ]
        });

        return false;
    }

    return true;
}

export function timeProcess(seconds: number) {      
    let interval = seconds / (60 * 60 * 24 * 30 * 365);

    if (interval >= 1) {
        return Math.floor(interval) + " year" + (Math.floor(interval) === 1 ? '' : 's');
    }

    interval = seconds / (60 * 60 * 24 * 30);

    if (interval >= 1) {
        return Math.floor(interval) + " month" + (Math.floor(interval) === 1 ? '' : 's');
    }

    interval = seconds / (60 * 60 * 24);

    if (interval >= 1) {
        return Math.floor(interval) + " day" + (Math.floor(interval) === 1 ? '' : 's');
    }

    interval = seconds / (60 * 60);

    if (interval >= 1) {
        return Math.floor(interval) + " hour" + (Math.floor(interval) === 1 ? '' : 's');
    }

    interval = seconds / 60;

    if (interval >= 1) {
        return Math.floor(interval) + " minute" + (Math.floor(interval) === 1 ? '' : 's');
    }

    interval = seconds;

    return Math.floor(interval) + " second" + (Math.floor(interval) === 1 ? '' : 's');
}

export function escapeRegex(string: string) {
    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}

export function timeSince(date: number) {
    const seconds = Math.floor((Date.now() - date) / 1000);
    return timeProcess(seconds) + ' ago';
}

export async function download(url: string, path: string, headers?: AxiosRequestHeaders) {  
    const writer = fs.createWriteStream(path);
    
    const response = await Axios({
        url,
        method: 'GET',
        responseType: 'stream',
        headers
    });
    
    response.data.pipe(writer);
    
    return new Promise((resolve, reject) => {
        if (response.status !== 200) {
            reject();
        }

        writer.on('finish', resolve);
        writer.on('error', reject);
    });
}

export async function deleteFile(path: string) {
    fs.rm(path, (err: any) => {
        if (err) {
            throw new Error(err);
        }
    });
}

export function random(arr: Array <any>) {
    let index = Math.floor(Math.random() * arr.length);
    return arr[index];
}

export function fill(length: number, string: string, token: string = ' ') {
    let safe = 0;

    if (length < string.length)
        return string;

    const diff = length - string.length;

    for (let i = 1; i <= diff; i++, safe++) {
        if (safe >= 500)
            break;        

        string += ' ';
    }   

    return string;
}

export function green(string: string) {
    return '\u001b[1;32m' + string + '\u001b[0m';
}

export function yellow(string: string) {
    return '\u001b[1;33m' + string + '\u001b[0m';
}

export function red(string: string) {
    return '\u001b[1;31m' + string + '\u001b[0m';
}
1	import fs from 'fs';
2	import DiscordClient from '../client/Client';
3	import { GuildMember, Message, CommandInteraction, MessageEmbed, ContextMenuInteraction, Interaction } from 'discord.js';
4	import Axios, { AxiosRequestHeaders, HeadersDefaults } from 'axios';
5
6	export function shouldNotModerate(client: DiscordClient, member: GuildMember) {
7	if (!client.config.props[member.guild.id].admin) {
8	return false;
9	}
10
11	const role = client.config.props[member.guild.id].admin;
12
13	return member.roles.cache.has(role);
14	}
15
16	export async function hasPermission(client: DiscordClient, member: GuildMember, msg: Message \| CommandInteraction \| ContextMenuInteraction, mod: GuildMember \| null, error: string = "You don't have permission to moderate this user") {
17	let m = mod;
18
19	if (!m) {
20	m = msg.member! as GuildMember;
21	}
22
23	if (member.roles.highest?.position >= m.roles.highest?.position) {
24	if (msg instanceof Interaction && msg.deferred) {
25	await msg.editReply({
26	embeds: [
27	new MessageEmbed()
28	.setColor('#f14a60')
29	.setDescription(`:x: ${error}`)
30	]
31	});
32
33	return false;
34	}
35
36	await msg.reply({
37	embeds: [
38	new MessageEmbed()
39	.setColor('#f14a60')
40	.setDescription(`:x: ${error}`)
41	]
42	});
43
44	return false;
45	}
46
47	return true;
48	}
49
50	export function timeProcess(seconds: number) {
51	let interval = seconds / (60 * 60 * 24 * 30 * 365);
52
53	if (interval >= 1) {
54	return Math.floor(interval) + " year" + (Math.floor(interval) === 1 ? '' : 's');
55	}
56
57	interval = seconds / (60 * 60 * 24 * 30);
58
59	if (interval >= 1) {
60	return Math.floor(interval) + " month" + (Math.floor(interval) === 1 ? '' : 's');
61	}
62
63	interval = seconds / (60 * 60 * 24);
64
65	if (interval >= 1) {
66	return Math.floor(interval) + " day" + (Math.floor(interval) === 1 ? '' : 's');
67	}
68
69	interval = seconds / (60 * 60);
70
71	if (interval >= 1) {
72	return Math.floor(interval) + " hour" + (Math.floor(interval) === 1 ? '' : 's');
73	}
74
75	interval = seconds / 60;
76
77	if (interval >= 1) {
78	return Math.floor(interval) + " minute" + (Math.floor(interval) === 1 ? '' : 's');
79	}
80
81	interval = seconds;
82
83	return Math.floor(interval) + " second" + (Math.floor(interval) === 1 ? '' : 's');
84	}
85
86	export function escapeRegex(string: string) {
87	return string.replace(/[-\/\\^$*+?.()\|[\]{}]/g, '\\$&');
88	}
89
90	export function timeSince(date: number) {
91	const seconds = Math.floor((Date.now() - date) / 1000);
92	return timeProcess(seconds) + ' ago';
93	}
94
95	export async function download(url: string, path: string, headers?: AxiosRequestHeaders) {
96	const writer = fs.createWriteStream(path);
97
98	const response = await Axios({
99	url,
100	method: 'GET',
101	responseType: 'stream',
102	headers
103	});
104
105	response.data.pipe(writer);
106
107	return new Promise((resolve, reject) => {
108	if (response.status !== 200) {
109	reject();
110	}
111
112	writer.on('finish', resolve);
113	writer.on('error', reject);
114	});
115	}
116
117	export async function deleteFile(path: string) {
118	fs.rm(path, (err: any) => {
119	if (err) {
120	throw new Error(err);
121	}
122	});
123	}
124
125	export function random(arr: Array <any>) {
126	let index = Math.floor(Math.random() * arr.length);
127	return arr[index];
128	}
129
130	export function fill(length: number, string: string, token: string = ' ') {
131	let safe = 0;
132
133	if (length < string.length)
134	return string;
135
136	const diff = length - string.length;
137
138	for (let i = 1; i <= diff; i++, safe++) {
139	if (safe >= 500)
140	break;
141
142	string += ' ';
143	}
144
145	return string;
146	}
147
148	export function green(string: string) {
149	return '\u001b[1;32m' + string + '\u001b[0m';
150	}
151
152	export function yellow(string: string) {
153	return '\u001b[1;33m' + string + '\u001b[0m';
154	}
155
156	export function red(string: string) {
157	return '\u001b[1;31m' + string + '\u001b[0m';
158	}