3 | Discord bot that automatically downloads TikToks
4 |
5 | 
6 |
7 |
8 |
9 |
5 |
6 |
7 |
8 |
9 | ![](\"./other/readme/logo.png\"){kind=logo}
![\"Discord\"](\"https://img.shields.io/discord/792286443660771359?logo=discord\")
\r ![](\"https://img.shields.io/badge/servers-99%2B-green\"){kind=icon}
",
26 | "repository": {
27 | "type": "git",
28 | "url": "git+https://github.com/addyire/tiktok-download.git"
29 | },
30 | "keywords": [
31 | "tiktok",
32 | "discord",
33 | "bot",
34 | "download"
35 | ],
36 | "author": "Addy Ire",
37 | "bugs": {
38 | "url": "https://github.com/addyire/tiktok-download/issues"
39 | },
40 | "homepage": "https://github.com/addyire/tiktok-download#readme"
41 | }
42 |
--------------------------------------------------------------------------------
/modules/commands/color.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 |
3 | const { ServerOptions } = require('../mongo')
4 | const botInviteURL = require('../invite')
5 | const log = require('../log')
6 | const { settingsChange } = require('../messageGenerator')
7 |
8 | module.exports = class SetColor extends SlashCommand {
9 | constructor (client, creator) {
10 | super(creator, {
11 | name: 'color',
12 | description: 'Change the sidebar color',
13 | options: [
14 | {
15 | type: 3,
16 | name: 'color',
17 | description: 'The color itself. (Must be a hexcode like this: #ff0000)',
18 | required: true
19 | }
20 | ]
21 | })
22 | this.client = client
23 | }
24 |
25 | onError () {}
26 |
27 | async run (interaction) {
28 | let hasPerms
29 |
30 | try {
31 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
32 | } catch (err) {
33 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
34 | }
35 |
36 | if (!hasPerms) {
37 | throw new Error('You must have the ADMINISTRATOR permission to change settings.')
38 | }
39 |
40 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
41 | const args = interaction.data.data.options.reduce((a, b) => {
42 | a[b.name] = b.value
43 | return a
44 | }, {})
45 |
46 | log.info(`Set color to: ${args.color}`, { serverID: interaction.guildID })
47 |
48 | serverOptions.color = args.color
49 |
50 | await serverOptions.validate()
51 | await serverOptions.save()
52 |
53 | interaction.send({
54 | embeds: [
55 | settingsChange(`I have changed the color to \`${args.color}\``)
56 | ]
57 | })
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/modules/commands/progress.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 |
3 | const { ServerOptions } = require('../mongo')
4 | const botInviteURL = require('../invite')
5 | const { settingsChange } = require('../messageGenerator')
6 | const log = require('../log')
7 |
8 | module.exports = class Progress extends SlashCommand {
9 | constructor (client, creator) {
10 | super(creator, {
11 | name: 'progress',
12 | description: 'Change video download progress settings.',
13 | options: [
14 | {
15 | type: 5,
16 | name: 'enabled',
17 | description: 'Whether this is enabled or not.',
18 | required: true
19 | }
20 | ]
21 | })
22 | this.client = client
23 | }
24 |
25 | onError () {}
26 |
27 | async run (interaction) {
28 | let hasPerms
29 |
30 | try {
31 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
32 | } catch (err) {
33 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
34 | }
35 |
36 | if (!hasPerms) {
37 | throw new Error('You must have the ADMINISTRATOR permission to change settings.')
38 | }
39 |
40 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
41 | const args = interaction.data.data.options.reduce((a, b) => {
42 | a[b.name] = b.value
43 | return a
44 | }, {})
45 |
46 | serverOptions.progress.enabled = args.enabled
47 |
48 | await serverOptions.validate()
49 | await serverOptions.save()
50 |
51 | log.info(`${args.enabled ? 'Enabled' : 'Disabled'} progress message`, { serverID: interaction.guildID })
52 |
53 | interaction.send({
54 | embeds: [
55 | settingsChange(`I have ${args.enabled ? 'enabled' : 'disabled'} the progress message`)
56 | ]
57 | })
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Logs
2 | *.log
3 | npm-debug.log*
4 | yarn-debug.log*
5 | yarn-error.log*
6 | lerna-debug.log*
7 |
8 | # Diagnostic reports (https://nodejs.org/api/report.html)
9 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
10 |
11 | # Runtime data
12 | pids
13 | *.pid
14 | *.seed
15 | *.pid.lock
16 |
17 | # Directory for instrumented libs generated by jscoverage/JSCover
18 | lib-cov
19 |
20 | # Coverage directory used by tools like istanbul
21 | coverage
22 | *.lcov
23 |
24 | # nyc test coverage
25 | .nyc_output
26 |
27 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
28 | .grunt
29 |
30 | # Bower dependency directory (https://bower.io/)
31 | bower_components
32 |
33 | # node-waf configuration
34 | .lock-wscript
35 |
36 | # Compiled binary addons (https://nodejs.org/api/addons.html)
37 | build/Release
38 |
39 | # Dependency directories
40 | node_modules/
41 | jspm_packages/
42 |
43 | # TypeScript v1 declaration files
44 | typings/
45 |
46 | # TypeScript cache
47 | *.tsbuildinfo
48 |
49 | # Optional npm cache directory
50 | .npm
51 |
52 | # Optional eslint cache
53 | .eslintcache
54 |
55 | # Microbundle cache
56 | .rpt2_cache/
57 | .rts2_cache_cjs/
58 | .rts2_cache_es/
59 | .rts2_cache_umd/
60 |
61 | # Optional REPL history
62 | .node_repl_history
63 |
64 | # Output of 'npm pack'
65 | *.tgz
66 |
67 | # Yarn Integrity file
68 | .yarn-integrity
69 |
70 | # dotenv environment variables file
71 | .env
72 | .env.test
73 |
74 | # parcel-bundler cache (https://parceljs.org/)
75 | .cache
76 |
77 | # Next.js build output
78 | .next
79 |
80 | # Nuxt.js build / generate output
81 | .nuxt
82 | dist
83 |
84 | # Gatsby files
85 | .cache/
86 | # Comment in the public line in if your project uses Gatsby and *not* Next.js
87 | # https://nextjs.org/blog/next-9-1#public-directory-support
88 | # public
89 |
90 | # vuepress build output
91 | .vuepress/dist
92 |
93 | # Serverless directories
94 | .serverless/
95 |
96 | # FuseBox cache
97 | .fusebox/
98 |
99 | # DynamoDB Local files
100 | .dynamodb/
101 |
102 | # TernJS port file
103 | .tern-port
104 |
105 | #Settings
106 | settings.json
107 |
--------------------------------------------------------------------------------
/modules/commands/settings.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 | const Discord = require('discord.js')
3 |
4 | const { ServerOptions } = require('../mongo')
5 | const botInviteURL = require('../invite')
6 | const log = require('../log')
7 | module.exports = class Settings extends SlashCommand {
8 | constructor (client, creator) {
9 | super(creator, {
10 | name: 'settings',
11 | description: 'Displays the current server settings.'
12 | })
13 | this.client = client
14 | }
15 |
16 | onError () {}
17 |
18 | async run (interaction) {
19 | let hasPerms
20 |
21 | try {
22 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
23 | } catch (err) {
24 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
25 | }
26 |
27 | if (!hasPerms) {
28 | throw new Error('You must have the ADMINISTRATOR permission to view settings.')
29 | }
30 |
31 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false }).exec()
32 |
33 | // Create embed
34 | const e = new Discord.MessageEmbed()
35 | .setTitle('Server Settings')
36 | .setColor(serverOptions.color)
37 | .setDescription('Here are the settings for this server')
38 |
39 | const data = serverOptions.toObject()
40 |
41 | // Delete db stuff
42 | delete data._id
43 | delete data.serverID
44 | delete data.__v
45 |
46 | for (const key of Object.keys(data)) {
47 | const cat = data[key]
48 | let str = ''
49 |
50 | if (key === 'banned' || key === 'limiter') continue
51 |
52 | if (typeof cat === 'object') {
53 | for (const item of Object.keys(cat)) {
54 | if (typeof cat[item] === 'object') continue
55 | str += `\`${item}\`: \`${cat[item]}\`\n`
56 | }
57 | } else {
58 | str = `\`${cat}\``
59 | }
60 |
61 | e.addField(key, str)
62 | }
63 |
64 | interaction.send({ embeds: [e.toJSON()] })
65 |
66 | log.info('Displaying settings', { serverID: interaction.guildID })
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/modules/mongo.js:
--------------------------------------------------------------------------------
1 | // Require stuff
2 | const mongoose = require('mongoose')
3 | const { mongo } = require('../other/settings.json')
4 | const log = require('./log')
5 |
6 | mongoose.connect(mongo, { useNewUrlParser: true, useUnifiedTopology: true })
7 |
8 | // Define a function that checks if a string is a color code
9 | const colorValidator = (v) => (/^#([0-9a-f]{3}){1,2}$/i).test(v)
10 |
11 | // Create link style type
12 | class LinkStyle extends mongoose.SchemaType {
13 | constructor (key, options) {
14 | super(key, options, 'LinkStyle')
15 | }
16 |
17 | cast (val) {
18 | if (['disabled', 'embed', 'button', 'both'].indexOf(val) === -1) {
19 | throw new Error('Not a valid type')
20 | }
21 | return val
22 | }
23 | }
24 |
25 | mongoose.Schema.Types.LinkStyle = LinkStyle
26 |
27 | // Create the schema
28 | const serverSchema = new mongoose.Schema({
29 | details: {
30 | enabled: {
31 | type: Boolean,
32 | default: true
33 | },
34 | description: {
35 | type: Boolean,
36 | default: true
37 | },
38 | author: {
39 | type: Boolean,
40 | default: true
41 | },
42 | requester: {
43 | type: Boolean,
44 | default: true
45 | },
46 | analytics: {
47 | type: Boolean,
48 | default: true
49 | },
50 | link: {
51 | type: LinkStyle,
52 | default: 'button'
53 | }
54 | },
55 | progress: {
56 | enabled: {
57 | type: Boolean,
58 | default: true
59 | }
60 | },
61 | autodownload: {
62 | enabled: {
63 | type: Boolean,
64 | default: true
65 | },
66 | deletemessage: {
67 | type: Boolean,
68 | default: true
69 | },
70 | smart: {
71 | type: Boolean,
72 | default: true
73 | },
74 | displayErrors: {
75 | type: Boolean,
76 | default: true
77 | }
78 | },
79 | color: {
80 | type: String,
81 | validate: {
82 | validator: colorValidator,
83 | message: p => `${p.value} is not a valid color.`
84 | },
85 | default: '#FF00FF'
86 | },
87 | banned: {
88 | users: {
89 | type: [String],
90 | default: []
91 | },
92 | channels: {
93 | type: [String],
94 | default: []
95 | }
96 | },
97 | serverID: String
98 | })
99 |
100 | // Load schema
101 | const ServerOptions = mongoose.model('server', serverSchema)
102 |
103 | // Export schema
104 | module.exports = { ServerOptions }
105 |
106 | // Log database events
107 | mongoose.connection.on('connected', () => {
108 | log.info('Successfully connected to database!')
109 | })
110 | mongoose.connection.on('error', (err) => {
111 | log.error(`Mongo Error \n${err}`)
112 | console.error(err)
113 | })
114 | mongoose.connection.on('disconnected', () => {
115 | log.error('Disconnected from database!')
116 | })
117 |
--------------------------------------------------------------------------------
/modules/commands/tiktok.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 | const fs = require('fs')
3 |
4 | const { ServerOptions } = require('../mongo')
5 | const TikTokParser = require('../tiktok')
6 | const { owner } = require('../../other/settings.json')
7 | const log = require('../log')
8 | const { tikTokMessage } = require('../messageGenerator')
9 |
10 | module.exports = class TikTok extends SlashCommand {
11 | constructor (client, creator) {
12 | super(creator, {
13 | name: 'tiktok',
14 | description: 'Downloads a TikTok',
15 | options: [
16 | {
17 | type: 3,
18 | name: 'url',
19 | description: 'The URL of the TikTok',
20 | required: true
21 | }
22 | ]
23 | })
24 | }
25 |
26 | onError () {}
27 |
28 | async run (interaction) {
29 | await interaction.defer()
30 |
31 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
32 |
33 | const args = interaction.data.data.options === undefined
34 | ? {}
35 | : interaction.data.data.options.reduce((a, b) => {
36 | a[b.name] = b.value
37 | return a
38 | }, {})
39 |
40 | if (serverOptions.banned.users.indexOf(interaction.user.id) !== -1) throw new Error('You have been banned from using me.')
41 | if (!testURL(args.url)) throw new Error('Not a valid URL')
42 |
43 | log.info(`📩 - Processing Video: ${args.url}`, { serverID: interaction.guildID })
44 |
45 | TikTokParser(args.url, interaction.guildID, () => {}).then(videoData => {
46 | const requester = {
47 | avatarURL: interaction.user.avatarURL,
48 | name: `${interaction.user.username}#${interaction.user.discriminator}`
49 | }
50 |
51 | const response = tikTokMessage(videoData, serverOptions, requester, true)
52 | response.file = {
53 | name: 'tiktok.mp4',
54 | file: fs.readFileSync(videoData.videoPath)
55 | }
56 |
57 | interaction.send(response).then(() => {
58 | videoData.purge()
59 | })
60 | }).catch(err => {
61 | log.warn('Encountered this error while downloading video with interaction' + err, { serverID: interaction.guildID })
62 |
63 | const e = {
64 | title: ':rotating_light: Error',
65 | description: "I couldn't download that video for some reason. Check to make sure the video is not private.",
66 | color: parseInt('FF0000', 16),
67 | footer: {
68 | text: `Please contact ${owner.tag} if you believe this is an error`
69 | }
70 | }
71 |
72 | interaction.send({ embeds: [e] })
73 | })
74 | }
75 | }
76 |
77 | function testURL (url) {
78 | return /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w\-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)/.test(url)
79 | }
80 |
--------------------------------------------------------------------------------
/modules/commands/autodownload.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 |
3 | const { ServerOptions } = require('../mongo')
4 | const botInviteURL = require('../invite')
5 | const log = require('../log')
6 | const { settingsChange } = require('../messageGenerator')
7 |
8 | module.exports = class Progress extends SlashCommand {
9 | constructor (client, creator) {
10 | super(creator, {
11 | name: 'autodownload',
12 | description: 'Set whether to automatically download TikToks. No command necessary.',
13 | options: [
14 | {
15 | type: 5,
16 | name: 'enabled',
17 | description: 'Whether this is enabled or not.',
18 | required: true
19 | },
20 | {
21 | type: 5,
22 | name: 'deletemessage',
23 | description: 'Delete the message with the URL in it.',
24 | required: false
25 | },
26 | {
27 | type: 5,
28 | name: 'smartdelete',
29 | description: 'When enabled, the message will not be deleted if there is more than just the URL in it.',
30 | required: false
31 | },
32 | {
33 | type: 5,
34 | name: 'errors',
35 | description: 'When disabled, no error message will be sent when a tiktok cannot be downloaded for whatever reason.',
36 | required: false
37 | }
38 | ]
39 | })
40 | this.client = client
41 | }
42 |
43 | onError () {}
44 |
45 | async run (interaction) {
46 | let hasPerms
47 |
48 | try {
49 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
50 | } catch (err) {
51 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
52 | }
53 |
54 | if (!hasPerms) {
55 | throw new Error('You must have the ADMINISTRATOR permission to change settings.')
56 | }
57 |
58 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
59 | const args = interaction.data.data.options.reduce((a, b) => {
60 | a[b.name] = b.value
61 | return a
62 | }, {})
63 |
64 | serverOptions.autodownload.enabled = args.enabled !== undefined ? args.enabled : serverOptions.autodownload.enabled
65 | serverOptions.autodownload.deletemessage = args.deletemessage !== undefined ? args.deletemessage : serverOptions.autodownload.deletemessage
66 | serverOptions.autodownload.smartdelete = args.smartdelete !== undefined ? args.smartdelete : serverOptions.autodownload.smartdelete
67 | serverOptions.autodownload.displayErrors = args.errors !== undefined ? args.errors : serverOptions.autodownload.displayErrors
68 |
69 | log.info('Changed auto download settings', { serverID: interaction.guildID })
70 |
71 | await serverOptions.validate()
72 | await serverOptions.save()
73 |
74 | interaction.send({
75 | embeds: [
76 | settingsChange(`I have successfully ${args.enabled ? 'updated' : 'disabled'} auto download!`)
77 | ]
78 | })
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/modules/commands/help.js:
--------------------------------------------------------------------------------
1 | const { MessageEmbed, MessageActionRow, MessageButton } = require('discord.js')
2 | const { SlashCommand } = require('slash-create')
3 |
4 | const { ServerOptions } = require('../mongo')
5 | const { version } = require('../../package.json')
6 | const { owner, emojis, helplink, voteURL } = require('../../other/settings.json')
7 | const { tiktok, github, discord } = emojis
8 | const botInviteURL = require('../invite')
9 | const log = require('../log')
10 |
11 | module.exports = class Help extends SlashCommand {
12 | constructor (client, creator) {
13 | super(creator, {
14 | name: 'help',
15 | description: 'Displays helpful information'
16 | })
17 | this.client = client
18 | }
19 |
20 | onError () {}
21 |
22 | async run (interaction) {
23 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
24 |
25 | const response = {}
26 |
27 | response.embeds = [new MessageEmbed()
28 | .setTitle('TokTik Downloader')
29 | .setURL(botInviteURL)
30 | .setDescription("This bot automagically replaces TikTok URL's with a MP4 file so you don't have to leave discord to watch it. \n*If you are being DM'd responses to commands make sure the bot has sufficient permissions to send messages in ALL channels.*")
31 | .addFields({
32 | name: 'Usage',
33 | value: 'If autodownload is enabled, you can just send a TikTok and the bot will download it. To enabled/disable this use the /autodownload command.'
34 | }, {
35 | name: 'Commands',
36 | value: 'Type / and click on the TokTik icon to see all the available commands!'
37 | }, {
38 | name: 'Open Source',
39 | value: 'You can view the code [here](https://github.com/addyire/tiktok-download) on GitHub!'
40 | }, {
41 | name: 'Help',
42 | value: `For any additional help you can join the [official help discord]${helplink ? '(' + helplink + ')' : 'not linked'}. You can also create an issue on GitHub!`
43 | })
44 | .setColor(serverOptions.color)
45 | .setFooter(`Contact ${owner.tag} for any questions or help with this bot. | Version: ${version}`)
46 | .toJSON()
47 | ]
48 |
49 | const buttons = [
50 | new MessageButton({
51 | style: 'LINK',
52 | label: 'GitHub',
53 | url: 'https://github.com/addyire/tiktok-download',
54 | emoji: github
55 | }),
56 | new MessageButton({
57 | style: 'LINK',
58 | label: 'Invite',
59 | url: botInviteURL,
60 | emoji: tiktok
61 | })
62 | ]
63 |
64 | helplink && buttons.push(new MessageButton({
65 | style: 'LINK',
66 | label: 'Help',
67 | url: helplink,
68 | emoji: discord
69 | }))
70 |
71 | voteURL && buttons.push(new MessageButton({
72 | style: 'LINK',
73 | label: 'Vote',
74 | emoji: '🗳️',
75 | url: voteURL
76 | }))
77 | response.components = [
78 | new MessageActionRow()
79 | .addComponents(buttons)
80 | .toJSON()
81 | ]
82 |
83 | interaction.send(response)
84 |
85 | log.info('Sent help information', { serverID: interaction.guildID })
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/modules/commands/disable.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 |
3 | const { ServerOptions } = require('../mongo')
4 | const botInviteURL = require('../invite')
5 | const { listBanned } = require('../messageGenerator')
6 |
7 | module.exports = class SetColor extends SlashCommand {
8 | constructor (client, creator) {
9 | super(creator, {
10 | name: 'disable',
11 | description: 'Disable for a specific user or channel',
12 | guildIDS: ['855275193022021653'],
13 | options: [
14 | {
15 | type: 6,
16 | name: 'user',
17 | description: 'The user to disable'
18 | },
19 | {
20 | type: 7,
21 | name: 'channel',
22 | description: 'The channel to disable'
23 | }
24 | ]
25 | })
26 | this.client = client
27 | }
28 |
29 | onError () {}
30 |
31 | async run (interaction) {
32 | let hasPerms
33 |
34 | try {
35 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
36 | } catch (err) {
37 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
38 | }
39 |
40 | if (!hasPerms) throw new Error('You must have the ADMINISTRATOR permission to change settings.')
41 |
42 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
43 | const args = interaction.data.data.options === undefined
44 | ? {}
45 | : interaction.data.data.options.reduce((a, b) => {
46 | a[b.name] = b.value
47 | return a
48 | }, {})
49 |
50 | if (args.user && args.channel) throw new Error('You must specifiy either a user or channel to disable toktik download for.')
51 |
52 | if (args.channel) {
53 | const channelObj = await this.client.channels.fetch(args.channel)
54 |
55 | if (channelObj.type !== 'GUILD_TEXT') throw new Error('The channel you provided is not a text channel!')
56 |
57 | if (serverOptions.banned.channels.indexOf(args.channel) !== -1) {
58 | serverOptions.banned.channels = serverOptions.banned.channels.filter(i => i !== args.channel)
59 | } else {
60 | serverOptions.banned.channels.push(args.channel)
61 | }
62 | } else if (args.user) {
63 | if (serverOptions.banned.users.indexOf(args.user) !== -1) {
64 | serverOptions.banned.users = serverOptions.banned.users.filter(i => i !== args.user)
65 | } else {
66 | serverOptions.banned.users.push(args.user)
67 | }
68 | }
69 |
70 | const embed = await listBanned(serverOptions, this.client)
71 |
72 | await serverOptions.validate()
73 | await serverOptions.save()
74 |
75 | interaction.send({
76 | embeds: [embed] //,
77 | // components: [{
78 | // type: ComponentType.ACTION_ROW,
79 | // components: [{
80 | // type: ComponentType.BUTTON,
81 | // style: ButtonStyle.PRIMARY,
82 | // label: 'butt',
83 | // custom_id: 'my_butt',
84 | // emoji: { name: '👌' }
85 | // }]
86 | // }]
87 | })
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/modules/messageGenerator.js:
--------------------------------------------------------------------------------
1 | const { MessageEmbed, MessageActionRow, MessageButton } = require('discord.js')
2 | const { emojis } = require('../other/settings.json')
3 |
4 | function tikTokMessage (videoData, guildSettings, requester, interaction = false) {
5 | // Create response
6 | const tiktok = videoData.videoURL
7 | const response = {}
8 |
9 | // Define the server details for easier access
10 | const serverDetails = guildSettings.details
11 | // If they have video details enabled....
12 | if (serverDetails.enabled && (serverDetails.description || serverDetails.requester || serverDetails.author || serverDetails.analytics)) {
13 | // Set the response embed to be the information they want
14 | const [title, url] = serverDetails.link === 'embed' || serverDetails.link === 'both' ? ['View On TikTok', tiktok] : [undefined, undefined]
15 |
16 | response.embeds = [{
17 | title,
18 | url,
19 | description: serverDetails.description ? videoData.text : undefined,
20 | timestamp: serverDetails.requester ? new Date().toISOString() : undefined,
21 | color: parseInt(guildSettings.color.substring(1), 16),
22 | author: serverDetails.author
23 | ? {
24 | name: `${videoData.authorMeta.nickName} (${videoData.authorMeta.name})`,
25 | icon_url: videoData.authorMeta.avatar
26 | }
27 | : undefined,
28 | footer: serverDetails.requester
29 | ? {
30 | text: `Requested by ${requester.name}`,
31 | icon_url: requester.avatarURL
32 | }
33 | : undefined,
34 | fields: serverDetails.analytics
35 | ? [
36 | { name: ':arrow_forward: Plays', value: videoData.playCount, inline: true },
37 | { name: ':heart: Likes', value: videoData.diggCount, inline: true },
38 | { name: ':mailbox_with_mail: Shares', value: videoData.shareCount, inline: true }
39 | ]
40 | : undefined
41 | }]
42 | } else if (interaction) {
43 | response.embeds = [{
44 | description: 'Here\'s your video',
45 | color: parseInt(guildSettings.color.substring(1), 16)
46 | }]
47 | }
48 |
49 | // Add buttons if needed
50 | response.components = (serverDetails.link === 'button' || serverDetails.link === 'both') && serverDetails.enabled
51 | ? [new MessageActionRow()
52 | .addComponents(
53 | new MessageButton({
54 | style: 'LINK',
55 | emoji: emojis.tiktok,
56 | url: tiktok,
57 | label: 'View On TikTok'
58 | })
59 | )
60 | ]
61 | : undefined
62 |
63 | return response
64 | }
65 |
66 | async function listBanned (serverOptions, client) {
67 | const embed = new MessageEmbed()
68 | .setTitle('Disabled Users/Channels')
69 | .setDescription('Autodownload will not work for the following users or channels')
70 | .setColor(serverOptions.color)
71 |
72 | const { channels, users } = serverOptions.banned
73 |
74 | const userStr = users.length === 0 ? 'None' : await users.reduce(async (str, usr) => str + `${(await client.users.fetch(usr)).tag}\n`, '')
75 | const channelStr = channels.length === 0 ? 'None' : channels.reduce((str, id) => str + `<#${id}>\n`, '')
76 |
77 | embed.addFields({
78 | name: 'Channels',
79 | value: channelStr
80 | }, {
81 | name: 'Users',
82 | value: userStr
83 | })
84 |
85 | return embed.toJSON()
86 | }
87 |
88 | function settingsChange (message) {
89 | // Generate message embed
90 | const res = new MessageEmbed()
91 |
92 | // Set the title and description
93 | res.setTitle(':tools: Settings Changed')
94 | res.setDescription(message)
95 |
96 | // Turn the embed into json and return
97 | return res.toJSON()
98 | }
99 |
100 | module.exports = { settingsChange, tikTokMessage, listBanned }
101 |
--------------------------------------------------------------------------------
/modules/commands/details.js:
--------------------------------------------------------------------------------
1 | const { SlashCommand } = require('slash-create')
2 |
3 | const { ServerOptions } = require('../mongo')
4 | const botInviteURL = require('../invite')
5 | const { settingsChange, tikTokMessage } = require('../messageGenerator')
6 | const log = require('../log')
7 |
8 | module.exports = class Details extends SlashCommand {
9 | constructor (client, creator) {
10 | super(creator, {
11 | name: 'details',
12 | description: 'Change what video details to show after sending a TikTok.',
13 | options: [
14 | {
15 | type: 5,
16 | name: 'enabled',
17 | description: 'Whether this is enabled or not.',
18 | required: true
19 | },
20 | {
21 | type: 5,
22 | name: 'description',
23 | description: 'Show the description of the video. (Default: True)',
24 | required: false
25 | },
26 | {
27 | type: 5,
28 | name: 'author',
29 | description: 'Show the author of the TikTok.',
30 | required: false
31 | },
32 | {
33 | type: 5,
34 | name: 'requester',
35 | description: 'Show who requested the video and when.',
36 | required: false
37 | },
38 | {
39 | type: 5,
40 | name: 'analytics',
41 | description: 'Show things like video plays, comments, and shares.',
42 | required: false
43 | },
44 | {
45 | type: 3,
46 | name: 'link',
47 | description: 'Show the link of the TikTok.',
48 | required: false,
49 | choices: [
50 | {
51 | name: 'disabled',
52 | value: 'disabled'
53 | },
54 | {
55 | name: 'embed',
56 | value: 'embed'
57 | },
58 | {
59 | name: 'button',
60 | value: 'button'
61 | },
62 | {
63 | name: 'both',
64 | value: 'both'
65 | }
66 | ]
67 | }
68 | ]
69 | })
70 | this.client = client
71 | }
72 |
73 | onError () {}
74 |
75 | async run (interaction) {
76 | let hasPerms
77 |
78 | try {
79 | hasPerms = (await (await this.client.guilds.fetch(interaction.guildID)).members.fetch(interaction.user.id)).permissions.has('ADMINISTRATOR')
80 | } catch (err) {
81 | throw new Error(`I am not in this server as a bot. Please have an administrator click [this](${botInviteURL}) link to invite me.`)
82 | }
83 |
84 | if (!hasPerms) {
85 | throw new Error('You must have the ADMINISTRATOR permission to change settings.')
86 | }
87 |
88 | const serverOptions = await ServerOptions.findOneAndUpdate({ serverID: interaction.guildID }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
89 | const args = interaction.data.data.options.reduce((a, b) => {
90 | a[b.name] = b.value
91 | return a
92 | }, {})
93 |
94 | serverOptions.details.enabled = args.enabled
95 | serverOptions.details.analytics = args.analytics === undefined ? serverOptions.details.analytics : args.analytics
96 | serverOptions.details.author = args.author === undefined ? serverOptions.details.author : args.author
97 | serverOptions.details.description = args.description === undefined ? serverOptions.details.description : args.description
98 | serverOptions.details.requester = args.requester === undefined ? serverOptions.details.requester : args.requester
99 | serverOptions.details.link = args.link === undefined ? serverOptions.details.link : args.link
100 |
101 | if (!serverOptions.details.analytics && !serverOptions.details.author && !serverOptions.details.description && !serverOptions.details.requester && serverOptions.details.link === 'disabled') {
102 | serverOptions.details.enabled = false
103 | }
104 |
105 | await serverOptions.validate()
106 | await serverOptions.save()
107 |
108 | log.info('Changed details', { serverID: interaction.guildID })
109 |
110 | // Create a tiktok message using dummy data
111 | const preview = tikTokMessage({
112 | videoURL: botInviteURL,
113 | text: 'The video description will go here!',
114 | authorMeta: {
115 | name: 'Author Username',
116 | nickName: 'Author Nick Name',
117 | avatar: 'https://static.thenounproject.com/png/82455-200.png'
118 | },
119 | playCount: '5M',
120 | diggCount: '600K',
121 | shareCount: '100'
122 | }, serverOptions, {
123 | name: `${interaction.user.username}#${interaction.user.discriminator}`,
124 | icon_url: interaction.user.avatarURL
125 | }, true)
126 |
127 | preview.embeds.splice(0, 0, settingsChange(args.enabled ? 'Here is a preview of what the details will look like next time I send a TikTok:' : 'Next time you request a TikTok, only the video will be sent.'))
128 |
129 | interaction.send(preview)
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/modules/tiktok.js:
--------------------------------------------------------------------------------
1 | const TikTokScraper = require('tiktok-scraper')
2 | const ffmpeg = require('fluent-ffmpeg')
3 |
4 | ffmpeg.setFfmpegPath(require('ffmpeg-static'))
5 |
6 | const STATUS = {
7 | SKIPPED: [
8 | { name: ':white_check_mark: Downloaded', value: 'Complete!', inline: true },
9 | { name: ':fast_forward: Compressed', value: 'Skipped!', inline: true }
10 | ],
11 | COMPRESSING: [
12 | { name: ':white_check_mark: Downloaded', value: 'Complete!', inline: true },
13 | { name: ':thought_balloon: Compressing', value: 'Thinking...', inline: true }
14 | ],
15 | COMPLETE: [
16 | { name: ':white_check_mark: Downloaded', value: 'Complete!', inline: true },
17 | { name: ':white_check_mark: Compressed', value: 'Complete!', inline: true }
18 | ],
19 | NOT_PERMITTED: [
20 | { name: ':white_check_mark: Downloaded', value: 'Complete!', inline: true },
21 | { name: ':white_check_mark: Compressed', value: ':x: Not Permitted :x:', inline: true }
22 | ]
23 | }
24 |
25 | const https = require('https')
26 | const http = require('http')
27 | const fs = require('fs')
28 | const path = require('path')
29 |
30 | const { compression, relativeDownloadPath, tiktok } = require('../other/settings.json')
31 | const { proxies, sessions } = tiktok
32 | const log = require('./log')
33 |
34 | // Set constants
35 | const basePath = path.join(__dirname, '..', relativeDownloadPath)
36 | const DISCORD_MAX_SIZE = compression.max_size
37 | const AUDIO_BITRATE = compression.audio_bitrate
38 | const SETTINGS = {
39 | proxy: !Array.isArray(proxies) || proxies.length === 0 ? '' : proxies,
40 | sessionList: !Array.isArray(sessions) || sessions.length === 0 ? [''] : sessions
41 | }
42 |
43 | function processTikTok (videoURL, guildID, statusChange) {
44 | // Create random videoID
45 | const videoID = Math.random().toString(36).substr(7)
46 | let returnInfo = { videoURL }
47 |
48 | // Return a promise
49 | return new Promise((resolve, reject) => {
50 | // Get video metaData then...
51 | TikTokScraper.getVideoMeta(videoURL, SETTINGS).then((videoMeta) => {
52 | // Store the headers for downloading the video
53 | const headers = videoMeta.headers
54 |
55 | // Store data about the video
56 | returnInfo = { ...returnInfo, ...videoMeta.collector[0] }
57 | returnInfo.videoPath = path.join(basePath, `${videoID}.mp4`)
58 |
59 | // Shorten the numbers
60 | returnInfo.playCount = shortNum(returnInfo.playCount)
61 | returnInfo.diggCount = shortNum(returnInfo.diggCount)
62 | returnInfo.shareCount = shortNum(returnInfo.shareCount)
63 | returnInfo.commentCount = shortNum(returnInfo.commentCount)
64 |
65 | return download(returnInfo.videoUrl, { headers }, returnInfo.videoPath)
66 | }).then(() => {
67 | const videoSize = fs.statSync(returnInfo.videoPath).size
68 |
69 | // If the video is too big to upload to discord
70 | if (videoSize > DISCORD_MAX_SIZE) {
71 | // If the servers does not have compression enabled...
72 | if (!hasCompression(guildID)) {
73 | // Update status message
74 | statusChange(STATUS.NOT_PERMITTED)
75 | // Throw an error
76 | reject(new Error('Video file too large and compression is not enabled on this server.'))
77 | }
78 |
79 | // Update the status message
80 | statusChange(STATUS.COMPRESSING)
81 |
82 | // Calculate stuff for the video
83 | const oldPath = returnInfo.videoPath
84 | const newVideoPath = path.join(basePath, `${videoID}c.mp4`)
85 | const videoLength = returnInfo.videoMeta.duration
86 | const wantedSize = DISCORD_MAX_SIZE * 0.8 // Sometimes the compression is more than expected so this is done to mitigate that.
87 | const videoBitRate = ((wantedSize / 128) / videoLength) - AUDIO_BITRATE // Calculate the bitrate
88 |
89 | // Open video in ffmpeg
90 | ffmpeg(returnInfo.videoPath)
91 | .videoBitrate(videoBitRate) // Set the bitrate to the calculated bitrate
92 | .audioBitrate(AUDIO_BITRATE) // Set the audio bitrate. (this probably isn't made)
93 | .save(newVideoPath) // Save to the compressed video path
94 | .on('error', e => { // If an error occurs...
95 | log.error(`❌ - FAILED TO COMPRESS VIDEO\n${e}`, { serverID: guildID })
96 | reject(new Error('Failed to compress the video.')) // Throw a error which will be handled later
97 | })
98 | .on('end', () => { // Once compression is complete
99 | // Update the status message
100 | statusChange(STATUS.COMPLETE)
101 |
102 | // Define the videos purge function
103 | returnInfo.purge = () => {
104 | fs.unlinkSync(oldPath)
105 | fs.unlinkSync(newVideoPath)
106 | }
107 | returnInfo.videoPath = newVideoPath
108 | returnInfo.videoName = `${videoID}c.mp4`
109 |
110 | // Return all the data once everything is complete
111 | resolve(returnInfo)
112 | })
113 | } else { // Otherwise...
114 | // Update the status message to say compression isn't required
115 | statusChange(STATUS.SKIPPED)
116 |
117 | // Set variables in the returnInfo
118 | returnInfo.videoName = `${videoID}.mp4`
119 | returnInfo.purge = () => {
120 | fs.unlinkSync(returnInfo.videoPath)
121 | }
122 |
123 | // Resolve the promise with the information
124 | resolve(returnInfo)
125 | }
126 | }).catch(err => {
127 | // Reject with the error that was encountered
128 | reject(err)
129 | })
130 | })
131 | }
132 |
133 | // Some download function I found on stack overflow that lets me use request headers
134 | function download (url, options, filePath) {
135 | const proto = !url.charAt(4).localeCompare('s') ? https : http
136 |
137 | return new Promise((resolve, reject) => {
138 | const file = fs.createWriteStream(filePath)
139 | let fileInfo = null
140 |
141 | const request = proto.get(url, options, response => {
142 | if (response.statusCode !== 200) {
143 | reject(new Error(`Failed to get '${url}' (${response.statusCode})`))
144 | return
145 | }
146 |
147 | fileInfo = {
148 | mime: response.headers['content-type'],
149 | size: parseInt(response.headers['content-length'], 10)
150 | }
151 |
152 | response.pipe(file)
153 | })
154 |
155 | // The destination stream is ended by the time it's called
156 | file.on('finish', () => resolve(fileInfo))
157 |
158 | request.on('error', err => {
159 | fs.unlink(filePath, () => reject(err))
160 | })
161 |
162 | file.on('error', err => {
163 | fs.unlink(filePath, () => reject(err))
164 | })
165 |
166 | request.end()
167 | })
168 | }
169 |
170 | // Function to check if a server has compression or not
171 | function hasCompression (guildID) {
172 | // If restrict is not enabled then return true
173 | if (!compression.restrict) return true
174 | // If serverID is in list of allowed servers, return true
175 | if (compression.servers.indexOf(guildID) !== -1) return true
176 | // Otherwise return false
177 | return false
178 | }
179 |
180 | // Function to shorten numbers
181 | function shortNum (num) {
182 | if (num >= 1000000) {
183 | return num / 1000000 + 'M'
184 | } else if (num >= 1000) {
185 | return num / 1000 + 'K'
186 | } else return String(num)
187 | }
188 |
189 | module.exports = processTikTok
190 |
--------------------------------------------------------------------------------
/bot.js:
--------------------------------------------------------------------------------
1 | const { SlashCreator, GatewayServer } = require('slash-create')
2 | const path = require('path')
3 | const Discord = require('discord.js')
4 | const { FLAGS } = Discord.Intents
5 | const mongoose = require('mongoose')
6 | const fs = require('fs')
7 |
8 | const TikTokParser = require('./modules/tiktok')
9 | const { ServerOptions } = require('./modules/mongo')
10 | const { bot, status, owner } = require('./other/settings.json')
11 | const log = require('./modules/log')
12 | const botInviteURL = require('./modules/invite')
13 | const { tikTokMessage } = require('./modules/messageGenerator')
14 |
15 | const STARTERS = ['https://vm.tiktok.com/', 'http://vm.tiktok.com/', 'https://www.tiktok.com/', 'http://www.tiktok.com/', 'https://m.tiktok.com/v/', 'http://m.tiktok.com/v/', 'https://vt.tiktok.com/', 'http://vt.tiktok.com/']
16 |
17 | // Initialize the bot and slash commands
18 | const client = new Discord.Client({ intents: [FLAGS.GUILDS, FLAGS.GUILD_MESSAGES, FLAGS.DIRECT_MESSAGES] })
19 | const creator = new SlashCreator({
20 | applicationID: bot.id,
21 | publicKey: bot.publicKey,
22 | token: bot.token
23 | })
24 |
25 | // Setup slash-create
26 | creator
27 | .withServer(new GatewayServer(handler => client.ws.on('INTERACTION_CREATE', handler)))
28 | .registerCommands(fs.readdirSync(path.join(__dirname, 'modules', 'commands')).map(file => {
29 | return new (require(`./modules/commands/${file}`))(client, creator)
30 | }))
31 | .syncCommands()
32 |
33 | // Whenever this is a slash-command error run this function...
34 | creator.on('commandError', async (command, error, interaction) => {
35 | // TODO Replace entire function. This is dumb
36 | if (error) {
37 | log.error(`${error.message}`, { serverID: interaction.guildID })
38 | }
39 |
40 | let e
41 |
42 | try {
43 | // Create a empty reason string
44 | let reason = ''
45 |
46 | // If the error type is a validation error
47 | if (error instanceof mongoose.Error.ValidationError) {
48 | // For each of validation errors
49 | for (const field in error.errors) {
50 | // Add the reason to the message with a new line.
51 | const thisE = error.errors[field]
52 | reason += `${thisE.path}: ${thisE.message}\n`
53 | }
54 | } else {
55 | // Otherwise set the reason to the error message.
56 | reason = error.message
57 | }
58 |
59 | // Create error message
60 | e = new Discord.MessageEmbed()
61 | .setTitle(':rotating_light: Error')
62 | .setColor('#ff0000')
63 | .setDescription(reason)
64 | .setFooter(`If you believe this is a bug please contact ${owner.tag}`)
65 | .toJSON()
66 | } catch (err) {
67 | log.error(`Fatal crash trying to generate error message: ${err}`)
68 |
69 | e = new Discord.MessageEmbed()
70 | .setTitle(':rotating_light: Fatal Error')
71 | .setDescription(`A fatal error has occurred. Please contact ${owner.tag} to report this bug.`)
72 | .setColor('#ff0000')
73 | .toJSON()
74 | } finally {
75 | // Respond with error
76 | interaction.send({ embeds: [e] })
77 | }
78 | })
79 |
80 | // On bot ready...
81 | client.on('ready', () => {
82 | // Log that the bot is ready.
83 | log.info('Bot ready!')
84 | log.info(`Invite Link: ${botInviteURL}`)
85 |
86 | const [serverCount, memberCount] = getMemberServerCount()
87 |
88 | // Log server and member count
89 | log.info(`I am in ${serverCount} servers, serving ${memberCount} users.`)
90 |
91 | // Define function to update teh status
92 | const setStatus = () => {
93 | client.user.setPresence({
94 | activity: {
95 | name: status
96 | },
97 | status: 'dnd'
98 | })
99 | }
100 |
101 | // Run Now
102 | setStatus()
103 | // Every 15 minutes...
104 | setInterval(setStatus, 15 * 60 * 1000)
105 | })
106 |
107 | // Whenever the bot joins a server...
108 | client.on('guildCreate', member => {
109 | // Get server and member count
110 | const [serverCount, memberCount] = getMemberServerCount()
111 |
112 | // Log that joined a server
113 | log.info(`Joined a new server! Now I am in ${serverCount} servers`)
114 |
115 | // Send the bot owner a message
116 | messageOwner(`I just joined the server: "${member.name}". It has ${member.memberCount} users!\nServer Count: ${serverCount} | Member Count: ${memberCount}`)
117 | })
118 |
119 | // Whenever the bot gets removed from a server...
120 | client.on('guildDelete', server => {
121 | // Get server and member count
122 | const [serverCount, memberCount] = getMemberServerCount()
123 |
124 | // Generate the message
125 | const message = typeof server === 'undefined' ? 'A server I was in was just deleted.' : `I was just removed from: "${server.name}" which had ${server.memberCount} users.`
126 |
127 | // Log and send message to the owner
128 | log.info(`Got removed from a server! Now I am in ${serverCount} servers`)
129 | messageOwner(message + `\nServer Count: ${serverCount} | Member Count: ${memberCount}`)
130 | })
131 |
132 | // On every message...
133 | client.on('message', async message => {
134 | // Return if user is a bot
135 | if (message.author.bot) return
136 |
137 | // Find if there is a tiktok link in the message, if there is see if there is anything else
138 | const tiktok = getTikTokFromStr(message.content)
139 | const onlyTikTok = message.content.split(' ').length === 1
140 |
141 | // If no tiktok return
142 | if (tiktok === undefined) return
143 |
144 | // Figure out weather bot has permission to speak in the channel with the tiktok.
145 | // If not set the channel to the dm channel of the user who sent the tiktok
146 | const channel = message.channel.permissionsFor(client.user).has('SEND_MESSAGES') ? message.channel : message.author
147 |
148 | // Get options for this server
149 | const guildOptions = await ServerOptions.findOneAndUpdate({ serverID: message.guild.id }, {}, { upsert: true, new: true, setDefaultsOnInsert: true, useFindAndModify: false })
150 |
151 | // Check if this user or channel is banned
152 | if (guildOptions.banned.channels.indexOf(message.channel.id) + guildOptions.banned.users.indexOf(message.author.id) !== -2) return
153 |
154 | // If they don't have autodownload enabled then return
155 | if (!guildOptions.autodownload.enabled) return
156 |
157 | // Define some variables
158 | let videoStatus, statusMessage
159 | let statusUpdater = () => {}
160 |
161 | // If they have progress messages enabled, create the message and send it
162 | if (guildOptions.progress.enabled) {
163 | // Creating the message
164 | videoStatus = {
165 | title: 'Video Status',
166 | description: 'Downloading the video and checking if compression is required...',
167 | color: guildOptions.color,
168 | fields: [
169 | { name: ':x: Downloaded', value: 'Waiting...', inline: true },
170 | { name: ':x: Compressed', value: 'Waiting...', inline: true }
171 | ]
172 | }
173 |
174 | // Sending it
175 | statusMessage = await channel.send({ embeds: [videoStatus] })
176 |
177 | // Define status updater
178 | statusUpdater = (status) => {
179 | videoStatus.fields = status
180 | statusMessage.edit({ embeds: [videoStatus] })
181 | }
182 | }
183 |
184 | // Log that the bot got a request for a video
185 | log.info(`📩 - Processing Video: ${tiktok}`, { serverID: message.guild.id })
186 |
187 | // Get the video data
188 | TikTokParser(tiktok, message.guild.id, statusUpdater).then(async videoData => {
189 | // With the video data...
190 | const requester = {
191 | avatarURL: message.author.avatarURL(),
192 | name: message.author.tag
193 | }
194 | // Start making the message its going to send
195 | const response = tikTokMessage(videoData, guildOptions, requester)
196 | response.files = [videoData.videoPath]
197 |
198 | // Wait for message to send...
199 | await channel.send(response).catch(err => {
200 | log.error(`⚠️ - ERROR SENDING VIDEO\n${err}`, { serverID: message.guild.id })
201 | })
202 |
203 | // If the message is deletable, and they have autodelete enabled, then...
204 | if (message.deletable && ((guildOptions.autodownload.deletemessage && guildOptions.autodownload.smartdelete && onlyTikTok) || (guildOptions.autodownload.deletemessage && !guildOptions.autodownload.smartdelete))) {
205 | // Delete the video
206 | message.delete()
207 | }
208 |
209 | // If there was a status message...
210 | if (statusMessage && statusMessage.deletable) {
211 | // Delete the status messsage.
212 | statusMessage.delete()
213 | }
214 |
215 | // Delete the local video file(s)
216 | videoData.purge()
217 | }).catch(err => {
218 | // If theres an error...
219 | // Log error
220 | log.error(`⚠️ - ERROR PROCESSING VIDEO\n${err}`, { serverID: message.guild.id })
221 |
222 | // If there is a status message and it is deletable...
223 | if (statusMessage && statusMessage.deletable) {
224 | // Delete the status message if there is one
225 | statusMessage.delete()
226 | }
227 |
228 | // Check if they want errors to be displayed
229 | if (guildOptions.autodownload.displayErrors) {
230 | // Send user the error message
231 | channel.send({
232 | embeds: [new Discord.MessageEmbed()
233 | .setTitle(':rotating_light: Error')
234 | .setColor('#ff0000')
235 | .setDescription('I couldn\'t download that video for some reason. Check to make sure the video is not private.')
236 | .setFooter(`Please contact ${owner.tag} if you believe this is an error`)
237 | ]
238 | })
239 | }
240 | })
241 | })
242 |
243 | // Function to get a tiktok url from a string
244 | // The url could be anywhere in the string.
245 | function getTikTokFromStr (msg) {
246 | // Split the string and for each element...
247 | for (const element of msg.split(' ')) {
248 | // Loop through all the possible tiktok video starters...
249 | for (const starter of STARTERS) {
250 | // If there is a match then return the item of the first array
251 | if (element.startsWith(starter)) return element
252 | }
253 | }
254 |
255 | // Otherwise return undefined because nothing was found
256 | return undefined
257 | }
258 |
259 | // Function that messages the owner
260 | function messageOwner (msg) {
261 | // Get the owner by their ID
262 | client.users.fetch(owner.id).then(usr => {
263 | // Send them a message
264 | usr.send(msg)
265 | }).catch(err => log.error(`👤 - Couldn't Find Owner\nError: ${err}\nMessage: ${msg}`))
266 | }
267 |
268 | // Function to calculate member and server count
269 | function getMemberServerCount () {
270 | return client.guilds.cache.reduce((acc, item) => {
271 | acc[0] += 1
272 | acc[1] += item.memberCount
273 | return acc
274 | }, [0, 0])
275 | }
276 |
277 | // Dumb workaround for slash-create
278 | module.exports = client
279 |
280 | // Login with bot
281 | client.login(bot.token)
282 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.