2020-02-21 00:26:49 +00:00
|
|
|
const gm = require("gm");
|
2020-05-20 18:24:57 +00:00
|
|
|
const cron = require("cron");
|
2020-02-27 15:49:32 +00:00
|
|
|
const { promisify } = require("util");
|
2019-09-13 20:02:41 +00:00
|
|
|
const client = require("../utils/client.js");
|
|
|
|
const database = require("../utils/database.js");
|
2020-04-26 21:55:33 +00:00
|
|
|
const collections = require("../utils/collections.js");
|
2019-09-13 20:02:41 +00:00
|
|
|
const logger = require("../utils/logger.js");
|
2019-11-13 00:09:06 +00:00
|
|
|
const messages = require("../messages.json");
|
2019-09-13 20:02:41 +00:00
|
|
|
const misc = require("../utils/misc.js");
|
2020-06-27 17:18:26 +00:00
|
|
|
const soundPlayer = require("../utils/soundplayer.js");
|
2020-04-10 02:40:52 +00:00
|
|
|
const helpGenerator =
|
|
|
|
process.env.OUTPUT !== "" ? require("../utils/help.js") : null;
|
|
|
|
const twitter =
|
|
|
|
process.env.TWITTER === "true" ? require("../utils/twitter.js") : null;
|
2019-09-13 20:02:41 +00:00
|
|
|
|
|
|
|
// run when ready
|
|
|
|
module.exports = async () => {
|
|
|
|
// make sure settings/tags exist
|
2019-12-16 18:13:38 +00:00
|
|
|
for (const [id] of client.guilds) {
|
2020-04-10 02:40:52 +00:00
|
|
|
const guildDB = (
|
|
|
|
await database.guilds
|
2020-04-26 21:55:33 +00:00
|
|
|
.findOne({
|
2020-04-10 02:40:52 +00:00
|
|
|
id: id,
|
|
|
|
})
|
|
|
|
.exec()
|
2020-04-26 21:55:33 +00:00
|
|
|
);
|
2019-10-28 20:21:06 +00:00
|
|
|
if (!guildDB) {
|
2019-12-29 16:56:32 +00:00
|
|
|
logger.log(`Registering guild database entry for guild ${id}...`);
|
2019-11-05 15:52:46 +00:00
|
|
|
const newGuild = new database.guilds({
|
|
|
|
id: id,
|
2019-10-28 20:21:06 +00:00
|
|
|
tags: misc.tagDefaults,
|
2020-02-27 15:49:32 +00:00
|
|
|
prefix: "&",
|
2020-04-10 02:40:52 +00:00
|
|
|
warns: {},
|
|
|
|
disabledChannels: []
|
2019-10-28 20:21:06 +00:00
|
|
|
});
|
|
|
|
await newGuild.save();
|
2020-04-10 02:40:52 +00:00
|
|
|
} else if (guildDB) {
|
|
|
|
if (!guildDB.warns) {
|
|
|
|
logger.log(`Creating warn object for guild ${id}...`);
|
|
|
|
guildDB.set("warns", {});
|
|
|
|
await guildDB.save();
|
|
|
|
} else if (!guildDB.disabledChannels) {
|
|
|
|
logger.log(`Creating disabled channels object for guild ${id}...`);
|
|
|
|
guildDB.set("disabledChannels", []);
|
|
|
|
await guildDB.save();
|
|
|
|
}
|
2020-02-27 15:49:32 +00:00
|
|
|
}
|
2019-10-28 20:21:06 +00:00
|
|
|
}
|
2019-09-13 20:02:41 +00:00
|
|
|
|
2020-05-20 18:24:57 +00:00
|
|
|
const job = new cron.CronJob("0 0 * * 0", async () => {
|
|
|
|
logger.log("Deleting stale guild entries in database...");
|
|
|
|
const guildDB = (await database.guilds.find({}).exec());
|
|
|
|
for (const { id } of guildDB) {
|
|
|
|
if (!client.guilds.get(id)) {
|
|
|
|
await database.guilds.deleteMany({ id: id });
|
|
|
|
logger.log(`Deleted entry for guild ID ${id}.`);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
logger.log("Finished deleting stale entries.");
|
|
|
|
});
|
|
|
|
job.start();
|
|
|
|
|
2020-04-26 21:55:33 +00:00
|
|
|
const global = (await database.global.findOne({}).exec());
|
|
|
|
if (!global) {
|
|
|
|
const countObject = {};
|
|
|
|
for (const command of collections.commands.keys()) {
|
|
|
|
countObject[command] = 0;
|
|
|
|
}
|
|
|
|
const newGlobal = new database.global({
|
|
|
|
cmdCounts: countObject
|
|
|
|
});
|
|
|
|
await newGlobal.save();
|
|
|
|
} else {
|
|
|
|
for (const command of collections.commands.keys()) {
|
|
|
|
if (!global.cmdCounts.has(command)) {
|
|
|
|
global.cmdCounts.set(command, 0);
|
|
|
|
await global.save();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-05 17:40:09 +00:00
|
|
|
// generate docs
|
|
|
|
if (helpGenerator) {
|
|
|
|
await helpGenerator(process.env.OUTPUT);
|
|
|
|
}
|
|
|
|
|
2019-09-13 20:02:41 +00:00
|
|
|
// set activity (a.k.a. the gamer code)
|
|
|
|
(async function activityChanger() {
|
2020-02-26 01:57:44 +00:00
|
|
|
client.editStatus("dnd", {
|
2020-04-10 02:40:52 +00:00
|
|
|
name: `${misc.random(messages)} | @esmBot help`,
|
2020-02-26 01:57:44 +00:00
|
|
|
});
|
2019-09-13 20:02:41 +00:00
|
|
|
setTimeout(activityChanger, 900000);
|
|
|
|
})();
|
|
|
|
|
2020-02-21 00:26:49 +00:00
|
|
|
// add gm extensions
|
|
|
|
gm.prototype.writePromise = promisify(gm.prototype.write);
|
|
|
|
gm.prototype.streamPromise = promisify(gm.prototype.stream);
|
|
|
|
gm.prototype.sizePromise = promisify(gm.prototype.size);
|
|
|
|
gm.prototype.identifyPromise = promisify(gm.prototype.identify);
|
2020-03-15 17:54:51 +00:00
|
|
|
gm.prototype.bufferPromise = function(format, delay, type) {
|
2020-02-26 01:57:44 +00:00
|
|
|
return new Promise((resolve, reject) => {
|
2020-04-10 02:40:52 +00:00
|
|
|
this.in(
|
|
|
|
delay ? "-delay" : "",
|
|
|
|
delay ? delay.split("/").reverse().join("x") : ""
|
|
|
|
)
|
|
|
|
.out(
|
|
|
|
type !== "sonic" ? "-layers" : "",
|
|
|
|
type !== "sonic" ? "OptimizeTransparency" : ""
|
|
|
|
)
|
2020-04-12 19:51:48 +00:00
|
|
|
.out(type !== "sonic" ? "-fuzz" : "", type !== "sonic" ? "2%" : "")
|
2020-04-20 20:52:22 +00:00
|
|
|
.out("+profile", "xmp")
|
2020-04-10 02:40:52 +00:00
|
|
|
.out("-limit", "memory", "64MB")
|
|
|
|
.out("-limit", "map", "128MB")
|
|
|
|
.stream(format, (err, stdout, stderr) => {
|
2020-02-26 19:23:18 +00:00
|
|
|
if (err) return reject(err);
|
|
|
|
const chunks = [];
|
|
|
|
stdout.on("data", (chunk) => {
|
|
|
|
chunks.push(chunk);
|
|
|
|
});
|
|
|
|
// these are 'once' because they can and do fire multiple times for multiple errors,
|
|
|
|
// but this is a promise so you'll have to deal with them one at a time
|
|
|
|
stdout.once("end", () => {
|
|
|
|
resolve(Buffer.concat(chunks));
|
|
|
|
});
|
|
|
|
stderr.once("data", (data) => {
|
|
|
|
reject(data.toString());
|
|
|
|
});
|
2020-02-26 01:57:44 +00:00
|
|
|
});
|
2020-02-25 20:45:47 +00:00
|
|
|
});
|
2020-02-26 01:57:44 +00:00
|
|
|
};
|
2020-02-21 00:26:49 +00:00
|
|
|
|
2020-06-27 17:18:26 +00:00
|
|
|
await soundPlayer.connect();
|
|
|
|
|
2019-11-15 16:59:50 +00:00
|
|
|
// tweet stuff
|
2019-11-23 23:23:28 +00:00
|
|
|
if (twitter !== null && twitter.active === false) {
|
2020-03-14 23:03:45 +00:00
|
|
|
const blocks = await twitter.client.blocks.ids();
|
2019-11-18 01:57:12 +00:00
|
|
|
const tweet = async () => {
|
2020-04-10 02:40:52 +00:00
|
|
|
const tweets = (
|
|
|
|
await database.tweets
|
|
|
|
.find({
|
|
|
|
enabled: true,
|
|
|
|
})
|
|
|
|
.exec()
|
|
|
|
)[0];
|
2019-11-18 01:57:12 +00:00
|
|
|
const tweetContent = await misc.getTweet(tweets);
|
2019-11-23 23:23:28 +00:00
|
|
|
try {
|
2020-03-14 23:03:45 +00:00
|
|
|
const info = await twitter.client.statuses.update(tweetContent);
|
|
|
|
logger.log(`Tweet with id ${info.id_str} has been posted.`);
|
|
|
|
// with status code ${info.resp.statusCode} ${info.resp.statusMessage}
|
2019-11-23 23:23:28 +00:00
|
|
|
} catch (e) {
|
|
|
|
const error = JSON.stringify(e);
|
|
|
|
if (error.includes("Status is a duplicate.")) {
|
|
|
|
logger.log("Duplicate tweet, will retry in 30 minutes");
|
|
|
|
} else {
|
|
|
|
logger.error(e);
|
|
|
|
}
|
|
|
|
}
|
2019-11-18 01:57:12 +00:00
|
|
|
};
|
|
|
|
tweet();
|
|
|
|
setInterval(tweet, 1800000);
|
2019-11-23 23:23:28 +00:00
|
|
|
twitter.active = true;
|
2020-03-14 23:03:45 +00:00
|
|
|
const stream = twitter.client.statuses.filter(`@${process.env.HANDLE}`);
|
|
|
|
stream.on("data", async (tweet) => {
|
2020-04-10 02:40:52 +00:00
|
|
|
if (
|
|
|
|
tweet.user.screen_name !== "esmBot_" &&
|
|
|
|
!blocks.ids.includes(tweet.user.id_str)
|
|
|
|
) {
|
|
|
|
const tweets = (
|
|
|
|
await database.tweets
|
|
|
|
.find({
|
|
|
|
enabled: true,
|
|
|
|
})
|
|
|
|
.exec()
|
|
|
|
)[0];
|
2019-11-23 23:23:28 +00:00
|
|
|
let tweetContent;
|
2020-04-10 02:40:52 +00:00
|
|
|
if (
|
|
|
|
tweet.text.includes("@this_vid") ||
|
|
|
|
tweet.text.includes("@DownloaderBot") ||
|
|
|
|
tweet.text.includes("@GetVideoBot") ||
|
|
|
|
tweet.text.includes("@DownloaderB0t") ||
|
|
|
|
tweet.text.includes("@thisvid_")
|
|
|
|
) {
|
2019-11-23 23:23:28 +00:00
|
|
|
tweetContent = await misc.getTweet(tweet, true, true);
|
|
|
|
} else {
|
|
|
|
tweetContent = await misc.getTweet(tweets, true);
|
|
|
|
}
|
2019-11-15 16:59:50 +00:00
|
|
|
const payload = {
|
|
|
|
status: `@${tweet.user.screen_name} ${tweetContent}`,
|
2020-04-10 02:40:52 +00:00
|
|
|
in_reply_to_status_id: tweet.id_str,
|
2019-11-15 16:59:50 +00:00
|
|
|
};
|
2020-03-14 23:03:45 +00:00
|
|
|
const info = await twitter.client.statuses.update(payload);
|
|
|
|
logger.log(`Reply with id ${info.id_str} has been posted.`);
|
|
|
|
// with status code ${info.resp.statusCode} ${info.resp.statusMessage}
|
2019-11-15 16:59:50 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-04-10 02:40:52 +00:00
|
|
|
logger.log(
|
|
|
|
"info",
|
|
|
|
`Successfully started ${client.user.username}#${client.user.discriminator} with ${client.users.size} users in ${client.guilds.size} servers.`
|
|
|
|
);
|
|
|
|
};
|