repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/coinflip.ts
|
<filename>commands/Fun/coinflip.ts
"use strict";
//Remember Download the stuff =)
import { Random } from "random-js";
const Math = require("math");
import Discord, { Client, Message } from "discord.js";
const random = new Random(); // uses the nativeMath engine
let heads = 1;
let tails = 0;
const value = Math.floor(Math.random());
module.exports = {
name: "coinflip",
aliases: ["ht", "th"],
description: "flips a coin",
category: "Fun",
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "coinflip",
run: async (client: Client, message: Message, args: string[]) => {
await value;
if (message.author.bot) return;
if (value === heads) {
const embed = new Discord.MessageEmbed()
.setTitle("You Got Heads!")
.setDescription("congrats you got heads!")
.setImage(
"https://lh3.googleusercontent.com/SRJZryeljJHRxVt6b_nCT_XWDKwDqgViehnN6yc-KXGQgZEb7KbVMhc2dW7P69yvCcvnTA=s87"
);
message.channel.send({ embeds: [embed] });
}
if (value === tails) {
const embed = new Discord.MessageEmbed()
.setTitle("You Got Tails!")
.setDescription("congrats you got tails!")
.setImage(
"https://lh3.googleusercontent.com/etXQadBecvemERl7DWSizrPRVHdrsHcNeAq_EYffM77UuAFbwLOWfJY1AqbkH9Z9U809_A=s85"
);
message.channel.send({ embeds: [embed] });
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/embed.ts
|
"use strict";
import { Client, Message } from "discord.js";
import { MessageEmbed } from "discord.js";
const ee = require("../../botconfig/embed.json");
module.exports = {
name: "embed",
category: "Fun",
aliases: ["say-embed"],
cooldown: 2,
usage: "embed <TITLE> ++ <DESCRIPTION>",
description: "Resends a message from you as an Embed",
run: async (client: Client, message: Message, args: string[]) => {
try {
if (!args[0]) {
let embed = new MessageEmbed()
.setColor(ee.wrongcolor)
.setFooter(ee.footertext, ee.footericon)
.setTitle(
`❌ ERROR | You didn't provided a Title, nor a Description`
);
return message.channel.send({ embeds: [embed] });
}
let userargs = args.join(" ").split("++");
let title = userargs[0];
let desc = userargs.slice(1).join(" ");
let embed = new MessageEmbed()
.setColor(ee.color)
.setFooter(ee.footertext, ee.footericon)
.setTitle(title ? title : "")
.setDescription(desc ? desc : "");
message.channel.send({ embeds: [embed] });
} catch (e) {
const errHandler = require("../../handlers/errorHandler");
errHandler.erroHandler(e, message);
}
},
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/webshot.ts
|
"use strict";
import puppeteer from "puppeteer";
import Discord, { Client, Message } from "discord.js";
import fs from "fs";
module.exports = {
name: "screenie",
description: "Take a screenshot of a website",
category: "Fun",
memberpermissions: "VIEW_CHANNEL",
adminPermOverride: true,
cooldown: 5,
usage: "screenie <link-needs to start with https:// or http://>",
run: async (client: Client, message: Message, args: string[]) => {
function isValidHttpUrl(string: string) {
try {
let url = new URL(string);
} catch (_) {
return false;
}
return true;
}
if (!isValidHttpUrl(args[0]))
return message.channel.send(
"The link you sent does not start with https or http"
);
if (
message.content.includes("porn") ||
message.content.includes("xxx") ||
message.content.includes("nude") ||
message.content.includes("boobs") ||
message.content.includes("dick") ||
message.content.includes("penis") ||
message.content.includes("pussy")
)
return message.channel.send(
"The link you have provided is explicit or in our banned websites list"
);
message.channel.send("Searching ...");
const browser = await puppeteer.launch({
executablePath: "/usr/bin/chromium",
headless: true,
args: ["--no-sandbox", "--disable-setuid-sandbox"],
});
const page = await browser.newPage();
await page.goto(args[0]);
const buffer = (await page.screenshot()) as Buffer;
await browser.close();
let p = new Discord.MessageAttachment(buffer, "picture.png");
let embed = new Discord.MessageEmbed()
.setTitle(`Result For ${args[0]}`)
.setImage("attachment://picture.png")
.setColor("GREEN");
message.channel.send({ embeds: [embed], files: [p] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/changeprefix.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import prefixSchema from "../Schemas/prefixSchema";
import { clearCache } from "../Utils/prefix-load";
import { Client, CommandInteraction, MessageMentions } from "discord.js";
module.exports = {
name: "changeprefix",
description: "Changes The Prefix",
options: [
{ type: 3, name: "prefix", description: "the prefix", required: true },
],
run: async (client: Client, interaction: CommandInteraction) => {
const isAdmin: boolean =
interaction.memberPermissions?.has("ADMINISTRATOR")!;
const prefix: string = interaction.options.getString("prefix")!;
if (
MessageMentions.USERS_PATTERN.test(prefix!) ||
MessageMentions.ROLES_PATTERN.test(prefix!) ||
MessageMentions.CHANNELS_PATTERN.test(prefix!)
) {
return interaction.reply("Mentions are not allowed to be prefixes");
}
if (isAdmin) {
if (prefix === "b!") {
await prefixSchema.deleteOne({ _id: interaction.guild?.id });
clearCache();
return interaction.reply("Changed The Prefix To Default");
} else
await prefixSchema.findOneAndUpdate(
{ _id: interaction.guild?.id },
{
_id: interaction.guild?.id,
prefix,
},
{ upsert: true }
);
clearCache();
return interaction.reply(`Changed The Prefix To ${prefix}`);
} else
return interaction.reply({
content: "Invalid Perms, Perms Expected:`MANAGE_GUILD`",
ephemeral: true,
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
Schemas/welcomeSchema.ts
|
"use strict";
import mongoose from "mongoose";
const welcomeSchema = new mongoose.Schema({
_id: {
type: String,
required: true,
unique: true,
},
DM: {
type: String,
required: true,
},
text: {
type: String,
required: true,
},
channelID: {
type: String,
required: true,
},
});
export default mongoose.model<IwelcomeSchema>("welcomeSchema", welcomeSchema);
interface IwelcomeSchema extends mongoose.Document {
_id: string;
DM: string;
text: string;
channelID: string;
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Economy/work.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
"use strict";
import Discord, { Message, Client } from "discord.js";
import workSchema from "../../Schemas/workSchema";
import id from "../../botconfig/id.json";
import s from "../../botconfig/salary.json";
import money from "../../Constructors/economy";
import { default as axios } from "axios";
const economy = new money();
module.exports = {
name: "work",
description: "work ",
category: "Economy",
guildOnly: true,
memberpermissions: "VIEW_CHANNEL",
adminPermOverride: true,
cooldown: 60 * 60 * 1,
usage: "work",
run: async (client: Client, message: Message) => {
let job;
try {
let j = await workSchema.findOne({
userID: message.author.id,
});
if (!j) {
return message.reply("You do not have a job! Run b!hire");
} else job = j.job;
} catch (err) {
return message.channel.send("Error Has Occured Try Again Later");
}
if (!job) {
message.reply("You do not have a job! Run b!hire");
}
let salary1 = s[1];
let salary2 = s[2];
let salary3 = s[3];
let possibleJobs: any[] = [];
await axios
.get("https://random-word-api.herokuapp.com/word?number=1")
.then((val) => possibleJobs.push(val.data.toString()));
let embed = new Discord.MessageEmbed()
.setTitle(`JOB:${job}`)
.setDescription("Type the word in")
.addField("Word:", `${possibleJobs[0]}`, true)
.setColor("GREEN");
message.channel.send({ embeds: [embed] });
let sal: any;
if (job === id[1]) {
sal = salary1;
} else if (job === id[2]) {
sal = salary2;
} else if (job === id[3]) {
sal = salary3;
}
const randomCoins = Math.floor(Math.random() * 500) + 1;
let filter = (m: Message) => m.author.id === message.author.id;
message.channel
.awaitMessages({
filter,
max: 1,
time: 10000,
errors: ["time"],
})
.then(async (m) => {
const msg = m.first();
if (msg?.content === possibleJobs[0]) {
msg?.channel.send(`CORRECT YOU HAVE EARNT ${sal}YBCs`);
economy.addCoins(msg?.author.id!, parseInt(sal));
return;
} else {
msg?.channel.send(`WRONG! YOU HAVE EARNT ${randomCoins}YBCs`);
}
economy.addCoins(msg?.author.id!, randomCoins);
return;
})
.catch((err) => {
if (err) {
message.channel.send(`Sed time ran out here is ${randomCoins}YBCs`);
economy.addCoins(message.author.id, randomCoins);
}
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
util.ts
|
module.exports = {
msToHMS: (duration: number) => {
var seconds = (duration / 1000) % 60;
var minutes = (duration / (1000 * 60)) % 60;
var hours = (duration / (1000 * 60 * 60)) % 60;
hours = 10 > hours ? 0 + hours : hours;
minutes = minutes < 10 ? 0 + minutes : minutes;
seconds = seconds < 10 ? 0 + seconds : seconds;
return `${hours}:${minutes}:${seconds}`;
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/OWNER/eval.ts
|
"use strict";
import { Client, Message } from "discord.js";
module.exports = {
name: "eval",
aliases: ["evaluate"],
description: "Evals code",
category: "OWNER",
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "eval [secrets]",
run: async (client: Client, message: Message, args: string[]) => {
if (message.author.id !== "8<PASSWORD>") return;
let banned = ["rm", "rf", "remove", "delete", "./"];
let bannedTrue = false;
banned.forEach((word) => {
if (message.content.includes(word)) {
message.channel.send("Banned Command");
bannedTrue = true;
}
});
args.shift();
bannedTrue ? null : eval(args.join(" "));
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/OWNER/computer-eval.ts
|
import { exec } from "child_process";
import { Client, Message, MessageEmbed } from "discord.js";
module.exports = {
name: "sys-eval",
description: "OWNER",
category: "OWNER",
memberpermissions: ["VIEW_CHANNEL"],
cooldown: 20,
usage: "systemeval <eval>",
run: async (client: Client, message: Message, args: string[]) => {
if (message.author.id !== "8<PASSWORD>")
return message.channel.send("You are not the owner of this bot!");
else
exec(args.join(" "), (err, stdout, stderr) => {
const embed = new MessageEmbed()
.setTitle(`You Executed\`\`\`${args.join(" ")}\`\`\``)
.setColor("RED");
if (err) embed.addField("Error", `\`\`\`sh\n${err.stack}\n\`\`\``);
if (stdout) embed.addField("Out", `\`\`\`sh\n${stdout}\n\`\`\``);
if (stderr) embed.addField("stderr", `\`\`\`sh\n${stderr}\n\`\`\``);
message.channel.send({ embeds: [embed] });
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/userinfo.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import {
Client,
CommandInteraction,
GuildMember,
MessageEmbed,
UserFlagsString,
} from "discord.js";
module.exports = {
name: "userinfo",
description: "Shows Information Of A Member In The Server",
options: [{ type: 6, name: "user", description: "The User", required: true }],
run: async (client: Client, interaction: CommandInteraction) => {
const user = interaction.options.getUser("user");
const member = interaction.inCachedGuild()
? interaction.options.getMember("user")
: null;
const flags = user?.flags?.toArray();
const flagEmojis: { [key: string]: string } = {
HOUSE_BRAVERY: "<:hypebravery:909007331688321036>",
PARTNERED_SERVER_OWNER: "<:partner:882895897321693194>",
HYPESQUAD_EVENTS: "<:hypesquademploy:909006344445644830>",
BUG_HUNTER_LEVEL_1: "<:BugHunter:909007077580632064>",
HOUSE_BRILLIANCE: "<:hypebrilliance:909007529810464808>",
HOUSE_BALANCE: "<:hypebalance:909007655962570752>",
EARLY_SUPPORTER: "<:earlysupport:909007830919553025>",
TEAM_USER: "TEAM_USER",
BUGHUNTER_LEVEL_2: "<:Bug_buster_badge:909008807630356491> ",
VERIFIED_BOT: "<:verified:909009092448768081>",
EARLY_VERIFIED_BOT_DEVELOPER: "<:earlybotdev:909009315308908554>",
DISCORD_CERTIFIED_MODERATOR: "<:certmod:909009568745525268> ",
};
const embed = new MessageEmbed()
.setTitle(`${user?.tag}'s Info`)
.addField(
"Joined Server",
`<t:${Math.floor(
member?.joinedTimestamp ? member?.joinedTimestamp : 1000 / 1000
)}:R>`,
true
)
.addField(
"Account Created",
`<t:${Math.floor(
user?.createdTimestamp ? user?.createdTimestamp : 1000 / 1000
)}:R>`,
true
);
member?.premiumSinceTimestamp
? embed.addField(
"Boosting Since",
`<t:${Math.floor(member?.premiumSinceTimestamp / 1000)}:R>`,
true
)
: null;
const flag = flags
? flags.length < 1
? "NONE"
: flags
.map((e: string) => flagEmojis[e])
.toString()
.replace(/,/g, ", ")
: null;
embed
.setColor("LIGHT_GREY")
.addField(
"Has `MANAGE_GUILD`",
`\`${(Number(member?.permissions.bitfield) & 0x20) == 0x20}\``,
true
)
.addField("Bot?", `\`${user?.bot.toString()}\``, true)
.addField("Badges", `${flag}`, false)
.addField(
"Roles",
member
? member.roles.cache.toJSON().toString().replace(/,/g, "\n")
: "None"
)
.setThumbnail(user ? user.displayAvatarURL({ size: 2048 }) : "");
interaction.reply({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
lib/trainer.ts
|
import axios from "axios";
import Logger from "./logger";
const toBeTrained: string[] = [];
const logger = new Logger("Lib - Trainer");
setInterval(async () => {
await axios.post(
`https://chatbot.yourbetterassistant.me/train`,
{
toBeTrained,
},
{
headers: {
"User-Agent": "YourBetterAssistant",
},
}
);
logger.info(`Trained ${toBeTrained.length} messages`);
toBeTrained.length = 0;
}, 1000 * 60 * 60);
export default function Trainer(message: string) {
toBeTrained.push(message);
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Music/resume.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
"use strict";
import { Client, Message, MessageEmbed } from "discord.js";
module.exports = {
name: "resume",
aliases: ["resume", "unpause"],
description: "Resumes the song",
category: "Music",
guildOnly: true,
memberpermissions: ["CONNECT", "SPEAK"],
cooldown: 3,
usage: "resume",
run: async (client: Client, message: Message, args: string[]) => {
const server_queue = client.queue.get(message.guild?.id!);
if (!server_queue) {
return message.reply(
"This server has no current songs playing nor am I connected to a vc"
);
}
if (
message.guild?.me?.voice.channel?.id !== message.member?.voice.channel?.id
)
return message.channel.send("You are not in the same vc");
server_queue.player.resume();
let embed = new MessageEmbed()
.setTitle("Now Playing!")
.addField("Now Playing:", `${server_queue.player.queue.current.title}`)
.setColor("YELLOW");
if (server_queue.player.queue.tracks.length > 0) {
embed.addField(
"Next Song",
`${server_queue.player.queue.tracks[0].title}`
);
}
message.reply("Resumed");
message.channel.send({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Economy/beg.ts
|
"use strict";
import { Client, Message } from "discord.js";
import money from "../../Constructors/economy";
const economy = new money();
module.exports = {
name: "beg",
description: "beg for YBCs",
category: "Economy",
guildOnly: true,
memberpermissions: "VIEW_CHANNEL",
cooldown: 20,
usage: "beg",
run: async (client: Client, message: Message, args: string[]) => {
const randomCoins = Math.floor(Math.random() * 99) + 1; // Random amount of coins.
await economy.addCoins(message.member?.id!, randomCoins);
message.reply({
content: `You have gotten ${randomCoins}YBCs from begging!`,
allowedMentions: { repliedUser: true },
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
handlers/events.ts
|
import { readdirSync } from "fs";
import { Client } from "discord.js";
import Table from "cli-table";
import color from "chalk";
const table = new Table();
table.push([color.redBright("Event"), color.redBright("Loaded")]);
module.exports = function (client: Client) {
function loadDir(dir: string) {
const files = readdirSync(`dist/events/${dir}`).filter((file) =>
file.endsWith(".js")
);
for (const file of files) {
const event = require(`../events/${dir}/${file}`);
const eventName = file.split(".")[0];
try {
client.on(eventName, (...args: any[]) => event(client, ...args));
table.push([color.green(eventName), color.green("Yes")]);
} catch (err: any) {
table.push([
color.redBright(eventName),
color.redBright(`${err.stack}`),
]);
}
}
}
["client", "guild"].forEach((dir) => loadDir(dir));
console.log(table.toString());
};
// import { Client } from "discord.js";
// import fs from "fs";
// const ascii = require("ascii-table");
// let table = new ascii("Events");
// table.setHeading("Events", "Load status");
// const allevents: any[] = [];
// module.exports = async (client: Client) => {
// try {
// const load_dir = (dir: string) => {
// const event_files = fs
// .readdirSync(`./events/${dir}`)
// .filter((file) => file.endsWith(".js"));
// for (const file of event_files) {
// const event = require(`../events/${dir}/${file}`);
// let eventName = file.split(".")[0];
// allevents.push(eventName);
// client.on(eventName, event.bind(null, client));
// }
// };
// await ["client", "guild"].forEach((e) => load_dir(e));
// for (let i = 0; i < allevents.length; i++) {
// try {
// table.addRow(allevents[i], "Ready");
// } catch (e: any) {
// console.log(String(e.stack).red);
// }
// }
// console.log(table.toString().cyan);
// try {
// const stringlength = 69;
// console.log("\n");
// console.log(
// ` ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓`
// .green.bold
// );
// console.log(
// ` ┃ `.green.bold +
// " ".repeat(-1 + stringlength - ` ┃ `.length) +
// "┃".green.bold
// );
// console.log(
// `| Welcome to SERVICE HANDLER!`.green.bold +
// " ".repeat(
// -1 +
// stringlength -
// ` ┃ `.length -
// `Welcome to SERVICE HANDLER!`.length
// ) +
// "┃".green.bold
// );
// console.log(
// ` ┃ `.green.bold +
// " ".repeat(-1 + stringlength - ` ┃ `.length) +
// "┃".green.bold
// );
// console.log(
// ` ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛`
// .green.bold
// );
// } catch {
// /* */
// }
// try {
// const stringlength2 = 69;
// console.log("\n");
// console.log(
// ` ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓`
// .yellow.bold
// );
// console.log(
// ` ┃ `.yellow.bold +
// " ".repeat(-1 + stringlength2 - ` ┃ `.length) +
// "┃".yellow.bold
// );
// console.log(
// `| Logging into the BOT...`.yellow.bold +
// " ".repeat(
// -1 + stringlength2 - ` ┃ `.length - `Logging into the BOT...`.length
// ) +
// "┃".yellow.bold
// );
// console.log(
// ` ┃ `.yellow.bold +
// " ".repeat(-1 + stringlength2 - ` ┃ `.length) +
// "┃".yellow.bold
// );
// console.log(
// ` ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛`
// .yellow.bold
// );
// } catch {
// /* */
// }
// } catch (e: any) {
// console.log(String(e.stack).bgRed);
// }
// };
// /** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
events/client/ready.ts
|
"use strict";
//here the event starts
require("dotenv").config();
import logger from "../../lib/logger";
import mongo from "../../botconfig/mongo";
import { Client, MessageAttachment, TextChannel } from "discord.js";
import axios from "axios";
const Logger = new logger("Events - Ready");
module.exports = async (client: Client) => {
try {
Logger.log(`Logged into ${client.user?.tag}`, true);
} catch {
/* */
}
//Change status each 10 minutes
let change;
try {
change = false;
client.user?.setStatus("dnd");
client.user?.setActivity(`${client.users.cache.size} users`, {
type: "WATCHING",
});
setInterval(async () => {
client.user?.setActivity(`${client.users.cache.size} users`, {
type: "WATCHING",
});
}, 600000);
} catch (e: any) {
Logger.error(e);
}
await mongo().then((mongoose) => {
try {
Logger.info("Connected!");
} catch (err: any) {
Logger.error(`error \n\n ${err.stack}`);
}
});
client.guilds.cache.forEach((guild) => {
Logger.log(guild.name);
});
client.interactions.forEach(async (inter) => {
//return client.api.applications(client.user.id).commands.set([])
if (inter.guild == true && !inter.options) {
client.api
.applications(client.user?.id)
.guilds("879927834058043492")
.commands.post({
data: {
name: inter.name,
description: inter.description,
default_permission: inter.permissions == false ? false : true,
},
});
} else if (inter.guild == true && inter.options) {
client.api
.applications(client.user?.id)
.guilds("879927834058043492")
.commands.post({
data: {
name: inter.name,
description: inter.description,
options: inter.options,
default_permission: inter.permissions == false ? false : true,
},
});
} else if (!inter.guild && inter.options) {
client.api.applications(client.user?.id).commands.post({
data: {
name: inter.name,
description: inter.description,
options: inter.options,
default_permission: inter.permissions == false ? false : true,
},
});
} else {
await client.api.applications(client.user?.id).commands.post({
data: {
name: inter.name,
description: inter.description,
default_permission: inter.permissions == false ? false : true,
},
});
}
});
await axios
.post("https://api.yourbetterassistant.me/api/bot/stats/update", {
secret: process.env.APISECRET,
commands: Array.from(client.commands),
interaction: Array.from(client.interactions),
})
.then(() => {
Logger.info("Posted Stats To Backend");
});
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
/**/
|
YourBetterAssistant/yourbetterassistant
|
commands/Music/queue.ts
|
"use strict";
import { Client, Message, MessageEmbed } from "discord.js";
module.exports = {
name: "queue",
aliases: ["q"],
description: "Shows the current queue",
category: "Music",
guildOnly: true,
memberpermissions: ["CONNECT", "SPEAK"],
adminPermOverride: true,
cooldown: 5,
usage: "queue",
run: async (client: Client, message: Message, args: string[]) => {
const server_queue = client.queue.get(message.guild?.id!);
if (!server_queue)
return message.channel.send(
"This server does not have a queue, start playing music to use this command"
);
if (
message.member?.voice.channel?.id !== message.guild?.me?.voice.channel?.id
)
return message.channel.send(
`Join <#${message.guild?.me?.voice.channel?.id}> to use this command `
);
let embed = new MessageEmbed()
.setTitle("Queue")
.setColor("BLUE")
.addField(
"Now Playing",
`${
!server_queue.player.queue.current.title
? "Unknown"
: server_queue.player.queue.current.title
}`
);
let i = 1;
if (server_queue.player.queue.tracks.length > 0) {
embed.addField(
"Next Song",
`${server_queue.player.queue.tracks[0].title}`
);
}
server_queue.player.queue.tracks.forEach((track: any) =>
embed.addField(`Song ${i++}`, `${track.title}`, true)
);
server_queue.player.queue.tracks.length === 0 &&
!server_queue.player.queue.current
? message.reply("Nothing is in the queue")
: message.reply({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Economy/withdraw.ts
|
"use strict";
import { Client, Message } from "discord.js";
import money from "../../Constructors/economy";
const economy = new money();
module.exports = {
name: "withdraw",
aliases: ["with"],
description: "withdraw money",
category: "Economy",
guildOnly: true,
memberpermissions: "VIEW_CHANNEL",
cooldown: 10,
usage: "withdraw <amount>",
run: async (client: Client, message: Message, args: string[]) => {
//if(isNaN(args[0])) return message.channel.send('That is not a real number')
let coins = args[0];
let user = message.author;
message.reply(`Withdrawing ${coins}YMCs from the bank!`);
if (coins === "all") {
await economy.withdraw(user.id, coins, message);
return;
}
if (isNaN(parseInt(coins))) {
return message.reply("that is not a number");
} else await economy.withdraw(user.id, parseInt(coins), message);
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/meme.ts
|
<gh_stars>0
"use strict";
const gottem = require("djs-meme");
import Discord, { Client, Message } from "discord.js";
module.exports = {
name: "meme",
description: "sends a meme",
category: "Fun",
guildOnly: true,
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "meme",
run: async (client: Client, message: Message, args: string[]) => {
const Meme = await gottem.meme();
let embed = new Discord.MessageEmbed()
.setTitle(Meme.embed.title)
.setURL(Meme.embed.url)
.setImage(Meme.embed.image.url)
.setFooter(Meme.embed.footer.text)
.setColor(Meme.embed.color)
.setTimestamp(Meme.embed.timestamp);
message.channel.send({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
Schemas/unknownCommand.ts
|
"use strict";
import mongoose from "mongoose";
const unknownCommand = new mongoose.Schema({
guildId: {
type: String,
required: true,
},
});
export default mongoose.model<IunknownCommand>(
"unknownCommand",
unknownCommand
);
interface IunknownCommand extends mongoose.Document {
guildId: string;
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/sudo.ts
|
"use strict";
import { Client, Message, TextChannel } from "discord.js";
module.exports = {
name: "sudo",
aliases: ["imitate"],
description: "makes a webhook of the defined user",
category: "Fun",
guildOnly: true,
memberpermissions: "MANAGE_WEBHOOKS",
cooldown: 10,
usage: "sudo <user> <message>",
run: async (client: Client, message: Message, args: string[]) => {
if (!args[0]) return message.reply("Who is the user?");
if (!args[1]) return message.reply("What is the message?");
const member = message.mentions.members?.first();
if (
message.content.split(" ")[0] ===
(`<@!${client.user?.id}>` || `<@${client.user?.id}>`)
) {
const member = message.mentions.members?.first(2)[1];
const msg = args.slice(1).join(" ");
const webhook = await (message.channel as TextChannel).createWebhook(
member?.displayName!,
{
avatar: member?.user?.displayAvatarURL(),
reason: "Sudo Command Executed",
}
);
message.delete();
await webhook.send(msg);
webhook.delete("No use");
return;
}
const msg = args.slice(1).join(" ");
const webhook = await (message.channel as TextChannel).createWebhook(
member?.displayName!,
{
avatar: member?.user?.displayAvatarURL(),
reason: "Sudo Command Executed",
}
);
message.delete();
await webhook.send(msg);
webhook.delete("No use");
},
};
|
YourBetterAssistant/yourbetterassistant
|
events/client/reconnecting.ts
|
<gh_stars>0
"use strict";
//here the event starts
module.exports = () => {
console.log(`Reconnceting at ${new Date()}.`);
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
Utils/checkAutoMod.ts
|
<gh_stars>0
import { Message } from "discord.js";
import autoMod from "../Schemas/autoMod";
import logger from "../lib/logger";
const Logger = new logger("Utils - AutoMod");
const autoModCache: { id: string | undefined; strictmode: string }[] = [];
export async function checkAutoMod(message: Message) {
let result = await autoModCache.find((i) => i.id == message?.guild?.id);
if (!result) {
let result = await autoMod.findOne({ guildId: message?.guild?.id });
Logger.info("new cache for automod");
if (!result) {
autoModCache.push({ id: message?.guild?.id, strictmode: "none" });
} else {
autoModCache.push({
id: message?.guild?.id,
strictmode: result.strictMode.toString(),
});
}
} else {
}
result = await autoModCache.find((i) => i.id == message?.guild?.id);
return result;
}
export async function forceNewCache() {
autoModCache.length = 0;
// let result=await autoMod.findOne({guildId:message.guild.id})
// if(!result.guildId){
// autoModCache.push({id:message.guild.id, strictmode:'none'})
// }else{
// autoModCache.push({id:message.guild.id, strictmode:result.strictMode})
// }
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/akinator.ts
|
<gh_stars>0
"use strict";
import { Client, Message } from "discord.js";
const akinator = require("discord.js-akinator");
module.exports = {
name: "akinator",
aliases: ["aki"],
description: "Akinator",
category: "Fun",
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "akinator",
run: async (client: Client, message: Message, args: string[]) => {
const language = "en"; //The Language of the Game
const childMode = false; //Whether to use Akinator's Child Mode
const useButtons = true; //Whether to use Discord's Buttons
akinator(message, {
language: language, //Defaults to "en"
childMode: childMode, //Defaults to "false"
useButtons: useButtons, //Defaults to "false"
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
ecosystem.config.ts
|
<gh_stars>1-10
//For PM2
module.exports = {
apps : [{
name : "YBA",
script : "./start.js",
exec_mode:"cluster",
instances:1,
out_file:'./logs.log',
error_file:'./err.log'
}]
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Administration/roleremove.ts
|
<gh_stars>0
"use strict";
import { Client, Message } from "discord.js";
module.exports = {
name: "roleremove",
description: "remove roles to users",
category: "Administration",
memberpermissions: "MANAGE_ROLES",
adminPermOverride: true,
cooldown: 2,
usage: "role <user> <roleID>",
run: async (client: Client, message: Message, args: string[]) => {
if (!args[1])
return message.channel.send("Which role do you expect me to remove?");
if (!args[0]) return message.channel.send("Who is going to lose the role?");
let user = message.mentions.users.first();
if (!user) return message.channel.send("The user could not be found");
let role = args.slice(1).join(" ");
let rolguild = message.guild?.roles.cache.find((r) => r.name === role);
if (!rolguild)
rolguild = message.guild?.roles.cache.find((r) => r.id === role);
let uv = message.guild?.members.cache.get(user.id);
uv?.roles.remove(rolguild!).catch((err) => {
message.channel.send("An error happened");
return;
});
message.channel.send("Roles changed");
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/inventory.ts
|
<gh_stars>0
//@ts-check
import { Client, CommandInteraction, MessageEmbed } from "discord.js";
import inventory from "../Schemas/inventory";
module.exports = {
name: "inventory",
description: "Inventory",
options: [
{ name: "list", description: "list your inventory", type: 1 },
{
name: "use",
description: "Use an item",
type: 1,
options: [{ name: "item", description: "Name of the item", type: 3 }],
},
],
run: async (client: Client, interaction: CommandInteraction) => {
const embed = new MessageEmbed();
if (interaction.options.getSubcommand() === "list") {
embed
.setTitle("Inventory of " + interaction.user.tag)
.setColor("ORANGE")
.setTimestamp(Date.now());
const extractedItems: { name: string; count: number }[] = [];
const inv = await inventory.findOne({ userId: interaction.user.id });
// @ts-ignore
if (!inv) return interaction.reply("Get An Inventory By Running b!bal");
if (inv.inventory.length < 1)
return interaction.reply(
"There is literally Nothing In Your Inventory!"
);
for (const item of inv.inventory) {
const isExist = extractedItems.find(
(i) => i.name.toLowerCase() === item.toLowerCase()
);
if (isExist) {
isExist.count = isExist.count + 1;
} else {
extractedItems.push({ name: item, count: 1 });
}
//typeof isExist==='object'?extractedItems[index]={name:item.toLowerCase(), count:isExist.count++}:extractedItems.push({name:item.toLowerCase(), count:1})
}
for (const item of extractedItems) {
embed.addField(item.name + `(${item.count.toString()})`, "\u200b");
}
embed.fields.length < 2
? embed.addField("Literally Nothing Else", "\u200b")
: null;
// console.log(extractedItems)
interaction
.deferReply()
.then(() => interaction.editReply({ embeds: [embed] }));
} else if (interaction.options.getSubcommand() == "use") {
interaction.reply("test");
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Economy/give.ts
|
<filename>commands/Economy/give.ts<gh_stars>0
"use strict";
import { Message, Client } from "discord.js";
import money from "../../Constructors/economy";
const currency = new money();
import { reply } from "../../exports";
module.exports = {
name: "donate",
aliases: ["give"],
description: "donate your YBCs to someone else",
category: "Economy",
memberpermissions: "VIEW_CHANNEL",
cooldown: 10,
usage: "give <coins> <user>",
run: async (client: Client, message: Message, args: string[]) => {
if (isNaN(parseInt(args[0])))
return message.channel.send("That is not a real number");
const member = message.mentions?.members?.first();
let coins = args[0];
if (!member)
return message.channel.send("Who are you giving the coins to?");
if (!coins) return message.channel.send("How many coins are you giving?");
await currency.donate(member.id, parseInt(coins), message);
reply(`You have given ${member}, ${coins}YBCs`, true, message);
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Administration/ban.ts
|
"use strict";
import serverConfSchema from "../../Schemas/serverConfSchema";
import { reply } from "../../exports";
import { Client, Message } from "discord.js";
module.exports = {
name: "ban",
description: "bans members",
category: "Administration",
guildOnly: true,
memberpermissions: "BAN_MEMBERS",
cooldown: 2,
usage: "ban <member>",
run: async (client: Client, message: Message, args: string[]) => {
const cache: { [key: string]: any } = {};
try {
let result = await serverConfSchema.findOne({ _id: message.guild?.id });
let admin = result?.adminroleID;
cache[message.guild?.id!] = { admin };
} catch (err) {
message.channel.send("Something occured while running the ban command");
}
const user = message.mentions.members?.first();
// If we have a user mentioned
var reason;
reason = args[1];
if (user) {
// Now we get the member from the user
if (user.id === message.author.id)
return message.channel.send("You can't ban yourself");
if (user.id === client.user?.id)
return message.channel.send("I cannot ban myself");
let admin = cache[message.guild?.id!].admin;
if (message.member?.roles.cache.some((r) => r.id === admin))
return reply("You cannot kick an admin+", true, message);
// If the member is in the guild
if (user) {
/**
* Kick the member
* Make sure you run this on a member, not a user!
* There are big differences between a user and a member
*/
user
.ban({ reason })
.then(() => {
// We let the message author know we were able to kick the person
reply(`Successfully Banned ${user?.user.tag}`, true, message);
})
.catch((err) => {
// An error happened
// This is generally due to the bot not being able to kick the member,
// either due to missing permissions or role hierarchy
reply("I was unable to Ban the member", true, message);
// Log the error
});
} else {
// The mentioned user isn't in this guild
reply("That user isn't in this guild!", true, message);
}
// Otherwise, if no user was mentioned
} else {
reply("You didn't mention the user to Ban!", true, message);
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
Utils/checkChatChannel.ts
|
<reponame>YourBetterAssistant/yourbetterassistant<gh_stars>0
import axios from "axios";
import { Message, TextChannel } from "discord.js";
import chatBot from "../Schemas/chatbot";
async function check(message: Message) {
let check = await chatBot.findOne({ guildID: message.guild?.id });
if (check) {
let ch = check.channelID;
if (message.channel.id === ch) {
async function urlGet(url: string) {
let axios = require("axios").default;
axios
.get(url)
.then(function (response: any) {
// handle success
message.reply(response.data.message);
})
.catch(function (error: any) {
// handle error
console.log(error);
})
.then(function () {});
}
urlGet(
`https://chatbot.yourbetterassistant.me/?message=${message.content}`
);
return;
}
}
}
export default check;
|
YourBetterAssistant/yourbetterassistant
|
commands/Music/previous.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import { Client, Message, MessageEmbed } from "discord.js";
module.exports = {
name: "previous",
description: "Plays the previous song",
category: "Music",
memberpermissions: ["VIEW_CHANNEL", "CONNECT", "SPEAK"],
cooldown: 5,
usage: "previous",
run: async (client: Client, message: Message, args: string[]) => {
let server_queue = client.queue.get(message.guild?.id!);
if (!server_queue) {
return message.reply(
"This server has no current songs playing nor am I connected to a vc"
);
}
if (
message.guild?.me?.voice.channel?.id !== message.member?.voice.channel?.id
)
return message.channel.send("You are not in the same vc");
if (!server_queue) {
server_queue = client.queue.get(message.guild?.id!);
}
if (!server_queue.player.queue.previous[0])
return message.channel.send("There Were No Previous Songs Playing");
server_queue.player.queue.add([server_queue.player.queue.previous[0]], {
requester: message.author,
}); // you can pass the requester in the second parameter
let embed = new MessageEmbed()
.setTitle("Now Playing")
.addField("Now Playing:", server_queue.player.queue.current.title)
.setColor("GREEN");
if (server_queue.player.queue.tracks.length > 0) {
embed.addField(
"Next Song",
`${server_queue.player.queue.tracks[0].title}`
);
}
if (server_queue.player.playing) {
message.channel.send(
`Added to queue: \`${server_queue.player.queue.previous[0].title}\` `
);
}
message.channel.send({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Music/skip.ts
|
import { Client, Message } from "discord.js";
module.exports = {
name: "skip",
description: "skips a song",
category: "Music",
guildOnly: true,
memberpermissions: ["VIEW_CHANNEL", "CONNECT", "SPEAK"],
cooldown: 5,
usage: "skip",
run: async (client: Client, message: Message, args: string[]) => {
const server_queue = client.queue.get(message.guild?.id!);
if (
message.guild?.me?.voice.channel?.id !== message.member?.voice.channel?.id
)
return message.channel.send("You are not in the same vc");
if (!server_queue) {
return message.reply(
"This server has no current songs playing nor am I connected to a vc"
);
}
server_queue.player.queue.next();
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/prefix.ts
|
import { Client, CommandInteraction, MessageEmbed } from "discord.js";
module.exports = {
name: "prefix",
description: "Reminder of what the prefix is",
options: [],
run: async (client: Client, interaction: CommandInteraction) => {
if (!interaction.guild) return interaction.reply("No prefix for dms");
const embed = new MessageEmbed()
.setTitle("Prefix")
.setDescription(
`The prefix is \`${client.prefix[interaction.guild.id]}\``
);
interaction.reply({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Information/botinfo.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
"use strict";
import { Client, Message, MessageEmbed } from "discord.js";
import funcs from "../../handlers/functions";
const osInfo = require("@felipebutcher/node-os-info");
import packageJson from "../../package.json";
module.exports = {
name: "botinfo",
description: "Shows stats of bot",
category: "Information",
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "botinfo",
run: async (client: Client, message: Message, args: string[]) => {
const { duration } = funcs;
const version = [];
version.push(packageJson.version);
message.channel.sendTyping();
let embed = new MessageEmbed()
.setTitle("Bot-Info")
.addField(
"Users",
`**${client.users.cache.size}** users being watched`,
true
)
.addField(
"Servers",
`${client.guilds.cache.size} servers being watched`,
true
)
.addField("Gateway", `${client.ws.gateway}`, true)
.addField("Ping", `${client.ws.ping}ms`, true)
.addField("Shards", `${client.ws.shards.size} shards being used`, true)
.addField("Websocket Status", `${client.ws.status}`, true)
.addField("Uptime", `${duration(client.uptime!)}`, true)
.addField("Command Size", client.commands.size.toString(), true)
.addField("Slash Commands Size", client.interactions.size.toString())
.addField("Version", version[0])
.addField("** **", "** **")
.setColor("BLUE");
osInfo.cpu((cpu: number) => {
embed.addField("CPU-Load", `${Math.round(cpu * 100)}%`, true);
});
osInfo.mem((memory: number) => {
embed.addField("Memory Used", `${Math.round(memory * 100)}%`, true);
});
setTimeout(function () {
message.channel.send({ embeds: [embed] });
}, 2000);
version.length = 0;
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/OWNER/pull.ts
|
import { Message } from "discord.js";
import { Client } from "discord.js";
("use strict");
import { exec } from "child_process";
import { reply } from "../../exports";
module.exports = {
name: "pull",
description: "pulls the latest version of this code from github",
category: "OWNER",
memberpermissions: "VIEW_CHANNEL",
cooldown: 2,
usage: "pull",
run: async (client: Client, message: Message) => {
let ownerId = "827388013062389761";
if (message.author.id !== ownerId) {
message.channel.send("You cannot pull");
return;
}
let link = "https://www.github.com/NotTimIsReal/yourbetterassistant";
reply(`Pulling from **${link}**`, true, message);
exec(`git pull ${link}`, (err) => {
if (err) return message.reply(`Error: \`\`\`${err.stack}\`\`\``);
});
message.reply("Do you want me to reboot");
let filter = (m: Message) => m.author.id === message.author.id;
message.channel
.awaitMessages({
filter,
max: 1,
time: 10000,
errors: ["time"],
})
.then((m) => {
const msg = m.first();
if (msg?.content.startsWith("yes")) {
exec("pm2 restart 0");
} else {
return message.channel.send("Cancelled");
}
});
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/profilepic.ts
|
"use strict";
import Discord, { Client, CommandInteraction } from "discord.js";
module.exports = {
name: "profilepic",
description: "Sends photo of profile pic",
options: [{ name: "user", description: "user", type: 6 }],
run: async (client: Client, interaction: CommandInteraction) => {
let embed = new Discord.MessageEmbed().setColor("RANDOM");
let user = interaction.options.getUser("user");
if (!user) {
embed
.setImage(interaction.user.displayAvatarURL())
.setTitle(`${interaction.user.username}'s Profile Image`);
interaction.reply({ embeds: [embed] });
} else {
embed.setImage(user.displayAvatarURL()).setTitle(`Profile Image`);
interaction.reply({ embeds: [embed] });
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/saveone.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import { GuildMember, User } from "discord.js";
("use strict");
import { Client, CommandInteraction, MessageEmbed } from "discord.js";
module.exports = {
name: "saveone",
description: "Save One",
options: [{ name: "user", description: "user", type: 6 }],
run: async (client: Client, interaction: CommandInteraction) => {
let user = interaction.options.getUser("user") as User;
const embed = new MessageEmbed().setTitle("Save One!").setColor("GREEN");
if (!user) {
let img = interaction?.user.displayAvatarURL();
img = img.replace(".webp", ".png");
embed.setImage(
`https://api.weky.xyz/canvas/saveonlyone?image=${img}&image2=https://cdn.discordapp.com/avatars/155149108183695360/19a5ee4114b47195fcecc6646f2380b1.png&image3=https://cdn.discordapp.com/avatars/270904126974590976/d60c6bd5971f06776ba96497117f7f58.png`
);
interaction.reply({ embeds: [embed] });
return;
} else {
let img = user.displayAvatarURL();
img = img.replace(".webp", ".png");
embed.setImage(
`https://api.weky.xyz/canvas/saveonlyone?image=${img}&image2=https://cdn.discordapp.com/avatars/155149108183695360/19a5ee4114b47195fcecc6646f2380b1.png&image3=https://cdn.discordapp.com/avatars/270904126974590976/d60c6bd5971f06776ba96497117f7f58.png`
);
interaction.reply({ embeds: [embed] });
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
botconfig/mongo.ts
|
require("dotenv").config();
import mongoose from "mongoose";
import { mongoPath } from "./config.json";
import Logger from "../lib/logger";
const logger = new Logger("Utils - MongoDB");
export default async () => {
await mongoose.connect(mongoPath).catch((err) => {
logger.error(err);
});
return mongoose;
};
|
YourBetterAssistant/yourbetterassistant
|
Schemas/chatbot.ts
|
<reponame>YourBetterAssistant/yourbetterassistant<filename>Schemas/chatbot.ts
"use strict";
import mongoose from "mongoose";
const chatBot = new mongoose.Schema({
guildID: {
type: String,
required: true,
},
channelID: {
type: String,
required: true,
},
});
export default mongoose.model<Ichatbot>("chatbot", chatBot);
interface Ichatbot {
guildID: string;
channelID: string;
}
|
YourBetterAssistant/yourbetterassistant
|
events/client/guildDelete.ts
|
<reponame>YourBetterAssistant/yourbetterassistant<filename>events/client/guildDelete.ts<gh_stars>0
"use strict";
import chatbot from "../../Schemas/chatbot";
import countSchema from "../../Schemas/countSchema";
import logSchema from "../../Schemas/logSchema";
import prefix from "../../Schemas/prefixSchema";
import rr from "../../Schemas/rrSchema";
import conf from "../../Schemas/serverConfSchema";
import welcome from "../../Schemas/welcomeSchema";
import mongo from "../../botconfig/mongo";
import { Client, Guild } from "discord.js";
module.exports = async (client: Client, guild: Guild) => {
await mongo().then(async () => {
try {
await chatbot.findOneAndRemove({ guildID: guild.id });
await countSchema.findOneAndRemove({ _id: guild.id });
await logSchema.findOneAndRemove({ _id: guild.id });
await prefix.findOneAndRemove({ _id: guild.id });
await conf.findOneAndRemove({ _id: guild.id });
await welcome.findOneAndRemove({ _id: guild.id });
} catch (err) {}
});
};
|
YourBetterAssistant/yourbetterassistant
|
Utils/level.ts
|
import Levels from "discord-xp";
import { Message } from "discord.js";
async function level(message: Message) {
if (message.author.bot) return;
if (message.guild) return;
const randomAmountOfXp = Math.floor(Math.random() * 29 + 1);
let hasLeveledUp = await Levels.appendXp(
message.author.id,
message.guildId!,
randomAmountOfXp
);
if (!hasLeveledUp) return;
const user = await Levels.fetch(message.author.id, message.guildId!);
message.channel.send(
`${message.author}, congratulations! You have leveled up to **${user.level}**. :tada:`
);
}
export default level;
|
YourBetterAssistant/yourbetterassistant
|
Constructors/autoModUser.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import { Message } from "discord.js";
import model from "../Schemas/autoMod";
const badwords = require("badwords/array");
function isUpperCase(str: string) {
if (
str.includes("@") ||
str.includes("<") ||
str.includes(
">" ||
str.includes("!") ||
str.includes("%") ||
str.includes("#") ||
str.includes("&")
)
)
return false;
if (str.length < 5) return false;
else {
return str === str.toUpperCase();
}
}
class Model {
public message: any;
public client: any;
constructor(message: Message) {
this.message = message;
this.client = message.client;
}
async checkProfanity() {
const message = this.message;
badwords.forEach((word: string) => {
if (message.content.includes(word)) {
const channel = message.channel;
const author = message.author;
message.delete();
channel.send(
`${message.author}, Strict-Mode is Enabled Please Don't Use That Word Again`
);
}
});
}
async allCaps() {
const message = this.message;
if (isUpperCase(message.content) === true) {
return message.channel.send("Stop Spamming Caps!");
}
}
}
export default Model;
|
YourBetterAssistant/yourbetterassistant
|
handlers/errorHandler.ts
|
<gh_stars>0
"use strict";
import Discord, { Message } from "discord.js";
import Logger from "../lib/logger";
function errHandler(e: any, message?: Message, command?: { name: string }) {
const logger = new Logger("Handler - ErrorHandler");
let embed = new Discord.MessageEmbed();
if (!message) return;
if (!message.guild) return logger.error(e);
embed
.addField("Guild:", message.guild.id.toString())
.addField("GuildName", message.guild.name)
.addField("Command", command ? command.name.toString() : "null")
.addField("Error", `\`${e.stack}\``)
.setTimestamp(new Date());
const channel = message.client.channels.cache.get("889101477421912064");
message.channel.send(
`Something happened while running \`${
command ? command.name.toString() : "null"
}\`, This has been logged and reported to the developers`
);
return channel?.isText() ? channel.send({ embeds: [embed] }) : null;
}
export default errHandler;
|
YourBetterAssistant/yourbetterassistant
|
events/client/warn.ts
|
"use strict";
//here the event starts
module.exports = () => {
console.warn();
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
Schemas/levellingEnabled.ts
|
"use strict";
import mongoose from "mongoose";
const levellingEnabled = new mongoose.Schema({
guildID: {
type: String,
required: true,
},
enabled: {
type: Boolean,
required: true,
},
});
export default mongoose.model<IlevellingEnabled>(
"levellingEnabled",
levellingEnabled
);
interface IlevellingEnabled extends mongoose.Document {
guildID: string;
enabled: boolean;
}
|
YourBetterAssistant/yourbetterassistant
|
commands/Fun/fastTyper.ts
|
"use strict";
import { Client, Message } from "discord.js";
import { reply } from "../../exports";
module.exports = {
name: "fasttyper",
aliases: ["typer"],
description: "typer game",
category: "Fun",
memberpermissions: "VIEW_CHANNEL",
cooldown: 10,
usage: "typer",
run: async (client: Client, message: Message, args: string[]) => {
reply("Starting", false, message);
const djsGames = require("djs-games");
const FastTyper = new djsGames.FastTyper();
FastTyper.startGame(message);
},
};
|
YourBetterAssistant/yourbetterassistant
|
slash/webserverstatus.ts
|
<gh_stars>0
import { Client, CommandInteraction } from "discord.js";
import https from "https";
module.exports = {
name: "webserverstatus",
description: "Shows Status of https://yourbetterassistant.me",
run: async (client: Client, interaction: CommandInteraction) => {
try {
interaction.deferReply();
https.get({ host: "yourbetterassistant.me" }, function (res) {
if (res.statusCode === 200)
return interaction.editReply("The Webserver Returned A 200 OK!");
else
interaction.editReply(
"The Webserver Returned a " +
res.statusCode +
" " +
res.statusMessage
);
interaction.followUp(
"I don't think that is good I will send a bug report on behalf of you"
);
const fChannel = client.channels.cache.get("897048482366521436");
return fChannel?.isText()
? fChannel.send(
`<@!827388013062389761> https://yourbetterassistant.me returned a ${res.statusCode} ${res.statusMessage}`
)
: null;
});
} catch (err) {
interaction.editReply(
"An Error Occured While Pinging The Webserver A bug report will be sent"
);
const fChannel = client.channels.cache.get("897048482366521436");
return fChannel?.isText()
? fChannel.send(
`<@!827388013062389761> https://yourbetterassistant.me returned an unknown error this error occured while running \`webserverstatus.js\``
)
: null;
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Information/serverinfo.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
"use strict";
import { Client, Message, MessageEmbed } from "discord.js";
import funcs from "../../handlers/functions";
module.exports = {
name: "serverinfo",
description: "shows an in-depth result of the server",
category: "Information",
memberpermissions: "VIEW_CHANNEL",
cooldown: 5,
usage: "serverinfo",
run: async (client: Client, message: Message, args: string[]) => {
const { delay } = funcs;
args;
//https://discord.com/developers/docs/resources/guild#guild-object-guild-features
let msg = await message.channel.send("Getting Info...");
delay(1000);
msg.edit("Results Found! Placing information...");
let embed = new MessageEmbed()
.setTitle(`Server Info of ${message.guild?.name}`)
.setColor("DARK_BLUE")
.setThumbnail(
`https://cdn.discordapp.com/icons/${message.guild?.id}/${message.guild?.icon}`
)
.addFields(
{
name: "Members",
value: `${message.guild?.memberCount}`,
inline: true,
},
{ name: "Owner", value: `<@!${message.guild?.ownerId}>`, inline: true },
{
name: "Humans",
value: message.guild?.members.cache
.filter((m) => !m.user.bot)
.size.toString()!,
inline: true,
},
{
name: "Bots",
value: message.guild?.members.cache
.filter((m) => m.user.bot)
.size.toString()!,
inline: true,
},
{
name: "Banned Members",
value: message.guild?.bans.cache.size.toString()!,
inline: true,
},
{
name: "Roles",
value: message.guild?.roles.cache.size.toString()!,
inline: true,
},
{
name: "Rules Channel",
value: `<#${message.guild?.rulesChannelId}>`,
inline: true,
},
{
name: "Emojis",
value: message.guild?.emojis.cache.size.toString()!,
inline: true,
},
{
name: "Stickers",
value: message.guild?.stickers.cache.size.toString()!,
inline: true,
},
{
name: "Verification Level",
value: message.guild?.verificationLevel!,
inline: true,
},
{
name: "Created At",
value: `<t:${Math.floor(message.guild?.createdTimestamp! / 1000)}>`,
inline: true,
},
{ name: "Features:", value: "**\n**", inline: false }
);
let e = 1;
message.guild?.features.forEach((i) =>
embed.addField(
` Feature ${e++}`,
` <a:greentick:881473012162002984> ${i}`,
false
)
);
msg.edit({ embeds: [embed] });
},
};
//
|
YourBetterAssistant/yourbetterassistant
|
slash/whodidthis.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import {
Client,
CommandInteraction,
Interaction,
MessageEmbed,
} from "discord.js";
module.exports = {
name: "whodidthis",
description: "Who did this",
options: [{ name: "user", description: "user", type: 6 }],
run: async (client: Client, interaction: CommandInteraction) => {
let user = interaction.options.getUser("user");
const embed = new MessageEmbed()
.setTitle("Who Did This???")
.setColor("GREEN");
if (!user) {
let img = interaction.user.avatarURL({ format: "png" });
embed.setImage(`https://api.weky.xyz/canvas/whodidthis?image=${img}`);
interaction.reply({ embeds: [embed] });
return;
} else {
let img = user.displayAvatarURL({ format: "png" });
embed.setImage(`https://api.weky.xyz/canvas/whodidthis?image=${img}`);
interaction.reply({ embeds: [embed] });
}
},
};
//https://api.weky.xyz/canvas/whodidthis?image=${img}
|
YourBetterAssistant/yourbetterassistant
|
Schemas/rrSchema.ts
|
"use strict";
import mongoose from "mongoose";
let reqStr = {
type: String,
required: true,
};
const rrSchema = new mongoose.Schema({
guildId: reqStr,
role1: {
type: Object,
required: true,
},
role2: {
type: Object,
required: true,
},
messageId: reqStr,
});
export default mongoose.model<IbuttonRoles>("buttonRoles", rrSchema);
interface IbuttonRoles extends mongoose.Document {
guildId: string;
role1: {
name: string;
id: string;
};
role2: {
name: string;
id: string;
};
messageId: string;
}
|
YourBetterAssistant/yourbetterassistant
|
events/client/error.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
"use strict";
//here the event starts
module.exports = (client: any, error: { stack: any }) => {
return console.log(`An error occured \n\n\n\n\n ${error.stack}`);
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
Schemas/store.ts
|
<filename>Schemas/store.ts
"use strict";
import mongoose from "mongoose";
const store = new mongoose.Schema({
id: {
type: String,
required: true,
},
items: {
type: Array,
required: true,
},
use: {
type: String,
required: true,
},
});
export default mongoose.model<IStore>("store", store);
interface IStore extends mongoose.Document {
id: string;
items: Array<{ name: string; price: string; description: string }>;
use: string;
}
|
YourBetterAssistant/yourbetterassistant
|
slash/store.ts
|
<gh_stars>0
import {
Client,
CommandInteraction,
MessageEmbed,
TextChannel,
} from "discord.js";
import economy from "../Constructors/economy";
import inventory from "../Schemas/inventory";
import store from "../Schemas/store";
const eco = new economy();
function replicate(arr: string | any[], times: number) {
var al = arr.length,
rl = al * times,
res = new Array(rl);
for (var i = 0; i < rl; i++) res[i] = arr[i % al];
return res;
}
module.exports = {
name: "store",
description: "Store",
options: [
{ name: "list", description: "list the store", type: 1 },
{
name: "buy",
description: "Buy an item",
type: 1,
options: [
{ name: "item", description: "item", type: 3, required: true },
{ name: "amount", description: "How much(default=1)", type: 10 },
],
},
{
name: "add",
description: "Developer Only!",
type: 1,
options: [
{ name: "item", description: "Item Name", type: 3, required: true },
{ name: "price", description: "Price", type: 10, required: true },
{
name: "description",
description: "Description",
type: 3,
required: true,
},
],
},
],
run: async (client: Client, interaction: CommandInteraction) => {
if (interaction.options.getSubcommand() === "list") {
const embed = new MessageEmbed()
.setTitle("Shop Items!!!")
.setFooter("Requested By: " + interaction.user.tag)
.setTimestamp(new Date())
.setColor("DARK_GOLD");
const items = await store.findOne({ id: "1" });
if (!items) {
return interaction.reply("The Store Is Currently Empty");
} else {
for (const item of items.items) {
embed.addField(
`${item.name}`,
`${
item.description
}- [${item.price.toString()}](https://yourbetterassistant.me)YBCs`,
true
);
}
interaction.reply({ embeds: [embed] });
}
} else if (
(interaction.options.getSubcommand() === "add" &&
interaction.user.id === "827388013062389761") ||
(interaction.options.getSubcommand() === "add" &&
interaction.user.id === "660665680827514929")
) {
const itemInfo: { name: string; price: string; description: string }[] =
[];
const name = interaction.options.getString("item");
const price = interaction.options.getNumber("price");
const description = interaction.options.getString("description");
itemInfo.push({
name: name!,
price: price?.toString()!,
description: description!,
});
const items = await store.findOne({ id: "1" });
if (!items) {
await store.findOneAndUpdate(
{ id: "1" },
{ id: "1", items: [itemInfo[0]] },
{ upsert: true }
);
} else {
itemInfo.push(...items.items);
await store.findOneAndUpdate(
{ id: "1" },
{ id: "1", items: itemInfo },
{ upsert: true }
);
}
itemInfo.length = 0;
return interaction.reply(
`Added Item \`${name}\`, with price \`${price}YBCs\` with a description of \`${description}\``
);
} else if (
interaction.options.getSubcommand() === "add" &&
interaction.user.id !== "827388013062389761"
) {
const name = interaction.options.getString("item");
const price = interaction.options.getNumber("price");
const description = interaction.options.getString("description");
const channel = client.channels.cache.get(
"885726936314306570"
) as TextChannel;
const embed = new MessageEmbed()
.setTitle("New Suggested Store Item")
.setDescription(
`Item \`${name}\`, with price \`${price}YBCs\` with a description of \`${description}\``
)
.setColor("GOLD")
.setAuthor(
interaction.user.tag,
interaction.user.displayAvatarURL({ format: "png", dynamic: true })
);
channel?.send({ embeds: [embed] });
return interaction.reply({
content:
"You Are Not Whitelisted to do this but I will add this as a suggestion",
ephemeral: true,
});
} else if (interaction.options.getSubcommand() === "buy") {
let realItem = false;
const validItem = [];
validItem.length = 0;
let price: any[] = [];
const useritem = interaction.options.getString("item") as string;
var amount = interaction.options.getNumber("amount") || 1;
const embed = new MessageEmbed().setTitle("Purchase").setColor("BLUE");
const s = await store.findOne({ id: "1" });
const preinv = await inventory.findOne({ userId: interaction.user.id });
const item = s?.items.find(
(i) => i.name.toLowerCase() === useritem.toLowerCase()
);
if (!item) {
realItem = false;
} else {
price.push(
s?.items.find((i) => i.name.toLowerCase() === useritem.toLowerCase())
?.price
);
realItem = true;
validItem.push(item.name);
validItem.push(...replicate(validItem, amount - 1));
}
const sucess = await eco.deductCoins(
interaction.user.id,
price[0] * amount
);
if (sucess === false) return interaction.reply("Insufficent Funds");
else if (realItem === false) {
embed.setDescription(
`The Item \`${useritem}\` is not a valid item in the store lol`
);
return interaction.reply({ embeds: [embed] });
} else if (amount > 100) {
return interaction.reply(
"You Cannot Get More Than 100 of any item at once"
);
} else if (!preinv) {
return interaction.reply(
"You don't have a bank account ot any money get a job! Or do b!bal to get an account"
);
} else {
embed.setDescription(
`You have Bought \`${amount}\` \`${
amount == 1 ? useritem : useritem + "s"
}\``
);
}
await interaction.reply({ embeds: [embed] });
preinv
? await inventory.findOneAndUpdate(
{ userId: interaction.user.id },
{
userId: interaction.user.id,
inventory: [...preinv.inventory, ...validItem],
},
{ upsert: true }
)
: await inventory.findOneAndUpdate(
{ userId: interaction.user.id },
{ userId: interaction.user.id, inventory: [...validItem] },
{ upsert: true }
);
}
},
};
|
YourBetterAssistant/yourbetterassistant
|
events/client/guildCreate.ts
|
"use strict";
import Discord, { Client, Guild } from "discord.js";
import funcs from "../../handlers/functions";
module.exports = async (client: Client, guild: Guild) => {
await guild.members.fetch({ force: true });
try {
} catch (err) {
return;
}
let possibleChannel = [
"chatting",
"general",
"chat",
"talk",
"speak",
"idk",
"bot-commands",
"bot",
"commands",
];
let channel: any[] = [];
let returnTrue: boolean;
let guildChannel: any | string = "889412487768850432";
guild.channels.cache.forEach((c) => {
possibleChannel.forEach((ch) => {
if (c.name.toLowerCase().includes(ch)) {
channel.push(c);
return (returnTrue = true);
}
if (returnTrue == true) return;
});
});
let channelRandom = channel[Math.floor(Math.random() * channel.length)];
const embed = new Discord.MessageEmbed()
.setColor("ORANGE")
.setTitle("Hello!")
.setDescription(
"Hi I am YourBetterAssistant I suggest setting me up with my amazing administration commands as without doing that I will be rather useless. My prefix is `b!` so I suggest using b!help as you first command"
)
.setTimestamp(new Date());
channelRandom.send({ embeds: [embed] });
guildChannel = client.channels.cache.get(guildChannel);
guildChannel.send(
`New Joined Guild!\n name: ${guild.name} \n id:${
guild.id
}\ntime:${funcs.getPrettyDate()}`
);
};
|
YourBetterAssistant/yourbetterassistant
|
commands/OWNER/restart.ts
|
<reponame>YourBetterAssistant/yourbetterassistant
import { Message } from "discord.js";
import { Client } from "discord.js";
("use strict");
import { reply } from "../../exports";
import { exec } from "child_process";
module.exports = {
name: "restart",
aliases: ["reboot"],
description: "restarts bot",
category: "OWNER",
memberpermissions: "VIEW_CHANNEL",
cooldown: 2,
usage: "restart",
run: async (client: Client, message: Message, args: string[]) => {
let ownerId = "827388013062389761";
if (message.author.id !== ownerId) {
message.channel.send("You cannot pull");
return;
}
await reply("Restarting", true, message);
await exec("pm2 restart 0");
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Information/neofetch.ts
|
import { Client, Message, MessageEmbed } from "discord.js";
import funcs from "../../handlers/functions";
const osInfo = require("@felipebutcher/node-os-info");
//@ts-check
module.exports = {
name: "neofetch",
description: "Shows Information About The Bot's Hardware",
category: "Information",
memberpermissions: ["VIEW_CHANNEL"],
cooldown: 5,
usage: "neofetch",
run: async (client: Client, message: Message, args: string[]) => {
const { delay, secondsToHMS } = funcs;
const getProperOS = () => {
const platform = process.platform;
if (platform === "aix") return "IBM AIX";
if (platform == "cygwin") return "Cygwin";
if (platform === "android") return "Andriod";
if (platform === "freebsd") return "FreeBSD";
if (platform === "darwin") return "MacOS";
if (platform === "haiku") return "Haiku";
if (platform === "linux") return "Linux";
if (platform === "netbsd") return "NetBSD";
if (platform === "openbsd") return "OpenBSD";
if (platform === "sunos") return "SunOS";
if (platform === "win32") return "Windows or Windows API";
else return "Unknown";
};
const embed = new MessageEmbed().addField(
"Operating System",
getProperOS()
);
osInfo.cpu(async (cpu: number) => {
await embed.addField("CPU-Load", `${Math.round(cpu * 100)}%`);
});
osInfo.mem(async (memory: number) => {
await embed.addField("Memory Used", `${Math.round(memory * 100)}%`);
});
osInfo.disk(async (disk: number) => {
embed.addField("Disk Used", `${Math.round(disk * 100)}%`);
});
let m = await message.channel.send("Retrieving Data...");
function bytesToSize(bytes: number) {
var sizes = ["Bytes", "KB", "MB", "GB", "TB"];
if (bytes == 0) return "0 Byte";
var i = Math.floor(Math.log(bytes) / Math.log(1024));
return Math.round(bytes / Math.pow(1024, i)) + " " + sizes[i];
}
await delay(4000);
embed
.setTitle("NeoFetch")
.setColor("DARK_RED")
.addField("Memory Usage", bytesToSize(process.memoryUsage().heapUsed))
.addField(
"Total memory Allocation",
bytesToSize(process.memoryUsage().heapTotal)
)
.addField(
"External Memory Usage",
bytesToSize(process.memoryUsage().external)
)
.addField(
"Array buffers",
bytesToSize(process.memoryUsage().arrayBuffers)
)
.addField("RSS", bytesToSize(process.memoryUsage().rss))
.addField(
"Raw Uptime",
secondsToHMS(Math.floor(process.uptime())).toString()
)
.setFooter(
"Requested By: " + message.author.tag,
message.author.displayAvatarURL({ dynamic: true })
)
.setTimestamp(new Date());
m.delete();
message.channel.send({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Information/ping.ts
|
<filename>commands/Information/ping.ts<gh_stars>0
"use strict";
import { Client, Message, MessageEmbed } from "discord.js";
import ee from "../../botconfig/embed.json";
module.exports = {
name: "ping",
category: "Information",
aliases: ["latency"],
cooldown: 2,
usage: "ping",
description: "Gives you information on how fast the Bot can respond to you",
run: async (client: Client, message: Message) => {
try {
let e = new MessageEmbed()
.setColor("BLUE")
.setFooter(ee.footertext, ee.footericon)
.setTitle(`🏓 Pinging....`);
message.channel.send({ embeds: [e] }).then((msg) => {
let em = new MessageEmbed()
.setColor("BLUE")
.setFooter(ee.footertext, ee.footericon)
.setTitle("Pong!")
.addField(
"Command Latency",
`🏓 Command Latency is \`${
Date.now() - message.createdTimestamp
}ms\``
)
.addField(
"API Latency",
`🏓 API Latency is \`${Math.round(client.ws.ping)}ms\``
);
msg.edit({ embeds: [em] });
});
} catch (e: any) {
let embed = new MessageEmbed()
.setColor("RED")
.setFooter(ee.footertext, ee.footericon)
.setTitle(`❌ ERROR | An error occurred`)
.setDescription(`\`\`\`${e.stack}\`\`\``);
return message.channel.send({ embeds: [embed] });
}
},
};
/** Template by Tomato#6966 | https://github.com/Tomato6966/Discord-Js-Handler-Template */
|
YourBetterAssistant/yourbetterassistant
|
slash/buttonRoles.ts
|
<filename>slash/buttonRoles.ts
import { Client, CommandInteraction, TextChannel } from "discord.js";
import { MessageEmbed, MessageActionRow, MessageButton } from "discord.js";
import rrSchema from "../Schemas/rrSchema";
module.exports = {
name: "buttonroles",
description: "Button Roles",
options: [
{
type: 7,
name: "channel",
description: "The Channel For The Message To Be Sent To",
channel_types: [0, 5, 6],
required: true,
},
{ type: 8, name: "role", description: "Role", required: true },
{ type: 8, name: "role2", description: "2nd Role" },
{ type: 3, name: "message", description: "Message" },
],
run: async (client: Client, interaction: CommandInteraction) => {
if (!interaction.memberPermissions?.has("MANAGE_ROLES")) {
return interaction.reply({
content: "Misisng Perms: `MANAGE_ROLES`",
ephemeral: true,
});
} else interaction.reply("Making The Message...");
const channel = interaction.options.getChannel("channel") as TextChannel;
const role1 = interaction.options.getRole("role");
const role2 = interaction.options?.getRole("role2");
const mes = interaction.options?.getString("message");
const embed = new MessageEmbed()
.setTitle("Get Your Roles!")
.addField("Role 1", `${role1} `)
.setColor("FUCHSIA");
role2 ? embed.addField("Role 2", `${role2}`) : null;
const row = new MessageActionRow();
mes ? embed.setDescription(mes) : null;
role2
? row.addComponents(
new MessageButton()
.setLabel(role1?.name!)
.setCustomId(role1?.name!)
.setStyle("PRIMARY"),
new MessageButton()
.setLabel(role2.name)
.setCustomId(role2.name)
.setStyle("PRIMARY")
)
: row.addComponents(
new MessageButton()
.setLabel(role1?.name!)
.setCustomId(role1?.name!)
.setStyle("PRIMARY")
);
const message = await channel?.send({ embeds: [embed], components: [row] });
role2
? await rrSchema.findOneAndUpdate(
{ guildId: interaction.guild?.id! },
{
guildId: interaction.guild?.id as string,
messageId: message.id as string,
role1: { name: role1?.name!, id: role1?.id! },
role2: { name: role2?.name!, id: role2?.id! },
},
{ upsert: true }
)
: await rrSchema.findOneAndUpdate(
{ guildId: interaction.guild?.id },
{
guildId: interaction.guild?.id as string,
role1: { name: role1?.name!, id: role1?.id! },
role2: undefined,
messageId: message.id!,
},
{ upsert: true }
);
},
};
|
YourBetterAssistant/yourbetterassistant
|
commands/Information/privacy.ts
|
import { Client, Message, MessageEmbed } from "discord.js";
module.exports = {
name: "privacy",
description: "Privacy Policy",
category: "Information",
memberpermissions: "VIEW_CHANNEL",
cooldown: 0,
usage: "privacy",
run: async (client: Client, message: Message) => {
const embed = new MessageEmbed()
.setTitle("Privacy Policy")
.addFields(
{
name: "What Data Do We Collect?",
value:
"The Data The Bot Collects is only your username and userid we don't collect any other data that includes you. Behind the scenes we also store all messages you send anonymously meaning that your username will not be shown with the message sent. ",
},
{
name: "Why Do You Need This Data?",
value:
"We require this data to defer your data from others and to also train out chatbot with conversations",
},
{
name: "How Do You Use This Data?",
value:
"We use it for certain commands like levels or richlist and also for training the chatbot which can be toggled on or off in the website, https://yourbetterassistant.me",
},
{
name: "Other then discord or the users of this bot who else do you share the data with?",
value:
"We don't share our data with anyone else besides the developers (me) or our end users (for certain commands)",
},
{
name: "How Can users contact you if they have concerns about your bot?",
value: " Feel free to dm <@827388013062389761> for any concerns",
},
{
name: "If you store data how can users have that data removed?",
value:
"To have data removed dm me I'll delete it no questions asked ",
}
)
.setFooter("Subject To Change VALID AS OF: 17/4/2022")
.setColor("GREYPLE");
message.channel.send({ embeds: [embed] });
},
};
|
YourBetterAssistant/yourbetterassistant
|
Schemas/economySchema.ts
|
<gh_stars>0
'use strict';
import mongoose from 'mongoose';
const economySchema=new mongoose.Schema({
userID: {
type: String,
required: true,
unique: true
},
coins: {
type: Number,
required: true
},
bank: {
type: Number,
required: true
},
bankSpace: {
type: Number,
required: true,
}
})
const EconomySchema=mongoose.model<Ischema>('economySchema', economySchema)
export default EconomySchema
interface Ischema extends mongoose.Document{
userID:string,
coins:number,
bank:number,
bankSpace:number
}
|
nsantos1999/course-api
|
src/section/entities/section.entity.ts
|
import { ApiProperty } from '@nestjs/swagger';
import { Course } from 'src/course/entities/course.entity';
import {
BaseEntity,
Column,
CreateDateColumn,
Entity,
ManyToOne,
PrimaryGeneratedColumn,
UpdateDateColumn,
} from 'typeorm';
@Entity({ name: 'sections' })
export class Section extends BaseEntity {
@ApiProperty()
@PrimaryGeneratedColumn()
id: number;
@ApiProperty()
@Column()
name: string;
@ApiProperty()
@Column()
number: number;
@ApiProperty()
@ManyToOne((type) => Course, (course) => course.sections)
course: Course;
@ApiProperty()
@CreateDateColumn()
createdAt: Date;
@ApiProperty()
@UpdateDateColumn()
updatedAt: Date;
}
|
nsantos1999/course-api
|
src/section/section.controller.ts
|
<reponame>nsantos1999/course-api<gh_stars>0
import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { SectionService } from './section.service';
import { CreateSectionDto } from './dto/create-section.dto';
import { UpdateSectionDto } from './dto/update-section.dto';
@Controller('section')
export class SectionController {
constructor(private readonly sectionService: SectionService) {}
@Post()
create(@Body() createSectionDto: CreateSectionDto) {
return this.sectionService.create(createSectionDto);
}
@Get()
findAll() {
return this.sectionService.findAll();
}
@Get(':id')
findOne(@Param('id') id: string) {
return this.sectionService.findOne(+id);
}
@Put(':id')
update(@Param('id') id: string, @Body() updateSectionDto: UpdateSectionDto) {
return this.sectionService.update(+id, updateSectionDto);
}
@Delete(':id')
remove(@Param('id') id: string) {
return this.sectionService.remove(+id);
}
}
|
nsantos1999/course-api
|
src/course/course.service.ts
|
<reponame>nsantos1999/course-api<gh_stars>0
import {
Injectable,
InternalServerErrorException,
NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { CourseRepository } from './course.repository';
import { AddCourseSectionDto } from './dto/add-course-section.dto';
import { CreateCourseDto } from './dto/create-course.dto';
import { UpdateCourseDto } from './dto/update-course.dto';
@Injectable()
export class CourseService {
constructor(
@InjectRepository(CourseRepository)
private courseRepository: CourseRepository,
) {}
async create(createCourseDto: CreateCourseDto) {
const userSaved = await this.courseRepository.saveCourse(createCourseDto);
if (!userSaved) {
throw new InternalServerErrorException(
'We had trouble saving the course',
);
}
return userSaved;
}
findAll() {
return this.courseRepository.find();
}
async findOne(id: number) {
const courseFounded = await this.courseRepository.findOne(id, {
relations: ['sections'],
});
if (!courseFounded) {
throw new NotFoundException(`Course with ID "${id}" not found`);
}
return courseFounded;
}
async update(id: number, updateCourseDto: UpdateCourseDto) {
const course = await this.findOne(id);
return this.courseRepository.saveCourse(updateCourseDto, course);
}
async remove(id: number) {
const result = await this.courseRepository.delete(id);
if (result.affected === 0) {
throw new NotFoundException(`Course with ID "${id}" not found`);
}
}
}
|
nsantos1999/course-api
|
src/language/entities/language.entity.ts
|
<filename>src/language/entities/language.entity.ts
import { ApiProperty } from '@nestjs/swagger';
import {
BaseEntity,
Column,
CreateDateColumn,
Entity,
PrimaryGeneratedColumn,
Unique,
UpdateDateColumn,
} from 'typeorm';
@Unique(['locale'])
@Entity({ name: 'languages' })
export class Language extends BaseEntity {
@ApiProperty()
@PrimaryGeneratedColumn()
id: number;
@ApiProperty()
@Column()
name: string;
@ApiProperty()
@Column()
locale: string;
@ApiProperty()
@CreateDateColumn()
createdAt: Date;
@ApiProperty()
@UpdateDateColumn()
updatedAt: Date;
}
|
nsantos1999/course-api
|
src/course/entities/course.entity.ts
|
import { ApiProperty } from '@nestjs/swagger';
import {
BaseEntity,
Column,
CreateDateColumn,
Entity,
OneToMany,
PrimaryGeneratedColumn,
UpdateDateColumn,
} from 'typeorm';
// import { CourseSection } from './course-module.entity';
import { Section } from 'src/section/entities/section.entity';
@Entity({ name: 'courses' })
export class Course extends BaseEntity {
@ApiProperty()
@PrimaryGeneratedColumn()
id: number;
@ApiProperty()
@Column()
name: string;
@ApiProperty()
@Column()
description: string;
@ApiProperty()
@Column('decimal', { precision: 5, scale: 2 })
price: number;
@ApiProperty()
@OneToMany((type) => Section, (courseSection) => courseSection.course, {
cascade: ['insert', 'update'],
})
sections: Section[];
@ApiProperty()
@CreateDateColumn()
createdAt: Date;
@ApiProperty()
@UpdateDateColumn()
updatedAt: Date;
}
|
nsantos1999/course-api
|
src/language/language.repository.ts
|
<filename>src/language/language.repository.ts
import { EntityRepository, Repository } from 'typeorm';
import { CreateLanguageDto } from './dto/create-language.dto';
import { Language } from './entities/language.entity';
@EntityRepository(Language)
export class LanguageRepository extends Repository<Language> {
async saveLanguage(
saveLanguageDto: CreateLanguageDto | CreateLanguageDto,
language = new Language(),
) {
const { name, locale } = saveLanguageDto;
language.name = name;
language.locale = locale;
await language.save();
return language;
}
}
|
nsantos1999/course-api
|
src/course/course.controller.ts
|
<reponame>nsantos1999/course-api
import {
Controller,
Get,
Post,
Body,
Put,
Param,
Delete,
UsePipes,
ValidationPipe,
} from '@nestjs/common';
import { ApiOkResponse, ApiResponse } from '@nestjs/swagger';
import { CourseService } from './course.service';
import { CreateCourseDto } from './dto/create-course.dto';
import { UpdateCourseDto } from './dto/update-course.dto';
import { Course } from './entities/course.entity';
@Controller('course')
export class CourseController {
constructor(private readonly courseService: CourseService) {}
@Post()
@UsePipes(ValidationPipe)
@ApiResponse({
status: 201,
type: Course,
description: 'Creates new course',
})
create(@Body() createCourseDto: CreateCourseDto) {
return this.courseService.create(createCourseDto);
}
@Get()
@ApiOkResponse({
type: Course,
isArray: true,
description: 'Find all courses',
})
findAll() {
return this.courseService.findAll();
}
@Get(':id')
@ApiOkResponse({
type: Course,
description: 'Find one course by id',
})
findOne(@Param('id') id: string) {
return this.courseService.findOne(+id);
}
@Put(':id')
@ApiOkResponse({
type: Course,
description: 'Update course by id',
})
update(@Param('id') id: string, @Body() updateCourseDto: UpdateCourseDto) {
return this.courseService.update(+id, updateCourseDto);
}
@Delete(':id')
@ApiOkResponse({
description: 'Delete course',
})
remove(@Param('id') id: string) {
return this.courseService.remove(+id);
}
}
|
nsantos1999/course-api
|
src/course/course.repository.ts
|
<gh_stars>0
import { EntityRepository, Repository } from 'typeorm';
import { CreateCourseDto } from './dto/create-course.dto';
import { Course } from './entities/course.entity';
@EntityRepository(Course)
export class CourseRepository extends Repository<Course> {
async saveCourse(
createCourseDto: CreateCourseDto,
course: Course = new Course(),
) {
course.name = createCourseDto.name;
course.description = createCourseDto.description;
course.price = createCourseDto.price;
await course.save();
return course;
}
}
|
nsantos1999/course-api
|
src/section/section.repository.ts
|
<filename>src/section/section.repository.ts
import { Inject } from '@nestjs/common';
import { CourseService } from 'src/course/course.service';
import { Course } from 'src/course/entities/course.entity';
import { EntityRepository, Repository } from 'typeorm';
import { CreateSectionDto } from './dto/create-section.dto';
import { UpdateSectionDto } from './dto/update-section.dto';
import { Section } from './entities/section.entity';
@EntityRepository(Section)
export class SectionRepository extends Repository<Section> {
async saveSection(
saveSectionDto: CreateSectionDto | UpdateSectionDto,
course: Course,
section = new Section(),
) {
const { name, number } = saveSectionDto;
section.name = name;
section.number = number;
section.course = course;
await section.save();
return section;
}
}
|
nsantos1999/course-api
|
src/course/course.service.spec.ts
|
<filename>src/course/course.service.spec.ts
import {
InternalServerErrorException,
NotFoundException,
} from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { CourseService } from './course.service';
import { Course } from './entities/course.entity';
const course = new Course();
course.id = 1;
course.name = 'Name Test';
course.description = 'Description Test';
course.createdAt = new Date();
course.updatedAt = new Date();
describe('CourseService', () => {
let service: CourseService;
const mockRepository = {
saveCourse: jest.fn(),
find: jest.fn(),
findOne: jest.fn(),
update: jest.fn(),
delete: jest.fn(),
};
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
CourseService,
{
provide: getRepositoryToken(Course),
useValue: mockRepository,
},
],
}).compile();
service = module.get<CourseService>(CourseService);
});
beforeEach(() => {
mockRepository.find.mockReset();
mockRepository.findOne.mockReset();
mockRepository.delete.mockReset();
mockRepository.saveCourse.mockReset();
mockRepository.update.mockReset();
});
it('should be defined', () => {
expect(service).toBeDefined();
});
describe('findAll', () => {
it('should be list all courses', async () => {
mockRepository.find.mockResolvedValue([course, course]);
const courses = await service.findAll();
expect(courses).toHaveLength(2);
expect(mockRepository.find).toHaveBeenCalled();
});
});
describe('findOne', () => {
it('should find a existing course', async () => {
mockRepository.findOne.mockResolvedValue(course);
const courseFound = await service.findOne(1);
expect(courseFound).toMatchObject({
name: course.name,
});
expect(mockRepository.findOne).toHaveBeenCalled();
});
it('should return a exception when does not to find a course', async () => {
mockRepository.findOne.mockResolvedValue(null);
expect(() => service.findOne(2)).rejects.toBeInstanceOf(
NotFoundException,
);
expect(mockRepository.findOne).toHaveBeenCalled();
});
});
describe('create', () => {
it('should create a course', async () => {
mockRepository.saveCourse.mockResolvedValue(course);
const courseSaved = await service.create(course);
expect(courseSaved).toBeInstanceOf(Course);
expect(courseSaved).toMatchObject(course);
expect(mockRepository.saveCourse).toHaveBeenCalled();
});
it('should return exception when does not to create a course', async () => {
expect(mockRepository.saveCourse).not.toHaveBeenCalled();
mockRepository.saveCourse.mockResolvedValue(null);
expect(() => service.create(course)).rejects.toBeInstanceOf(
InternalServerErrorException,
);
expect(mockRepository.saveCourse).toHaveBeenCalled();
});
});
describe('update', () => {
it('should update a course', async () => {
expect(mockRepository.saveCourse).not.toHaveBeenCalled();
const updateData = {
...course,
name: '<NAME> Test',
description: 'New Description Test',
price: 105.5,
};
mockRepository.findOne.mockResolvedValue(course);
mockRepository.saveCourse.mockResolvedValue(updateData);
const courseSaved = await service.update(1, updateData);
expect(courseSaved).toMatchObject(updateData);
expect(courseSaved).toMatchObject({ id: course.id });
expect(mockRepository.saveCourse).toHaveBeenCalled();
expect(mockRepository.findOne).toHaveBeenCalled();
});
});
describe('delete', () => {
it('should delete a course', async () => {
expect(mockRepository.delete).not.toHaveBeenCalled();
mockRepository.delete.mockResolvedValue({ affected: 1 });
await service.remove(1);
expect(mockRepository.delete).toHaveBeenCalled();
expect(mockRepository.delete).toHaveBeenCalledWith(1);
});
it('should return exception when does not to delete a course', async () => {
expect(mockRepository.delete).not.toHaveBeenCalled();
mockRepository.delete.mockResolvedValue({ affected: 0 });
expect(() => service.remove(1)).rejects.toBeInstanceOf(NotFoundException);
});
});
});
|
nsantos1999/course-api
|
src/section/section.service.ts
|
import { Inject, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { CourseService } from 'src/course/course.service';
import { CreateSectionDto } from './dto/create-section.dto';
import { UpdateSectionDto } from './dto/update-section.dto';
import { Section } from './entities/section.entity';
import { SectionRepository } from './section.repository';
@Injectable()
export class SectionService {
constructor(
@Inject(CourseService)
private courseService: CourseService,
@InjectRepository(SectionRepository)
private sectionRepository: SectionRepository,
) {}
async create(createSectionDto: CreateSectionDto): Promise<Section> {
const { courseId } = createSectionDto;
const course = await this.courseService.findOne(courseId);
const section = await this.sectionRepository.saveSection(
createSectionDto,
course,
);
return section;
}
findAll(): Promise<Section[]> {
return this.sectionRepository.find();
}
async findOne(id: number): Promise<Section> {
const section = await this.sectionRepository.findOne(id);
if (!section) {
throw new NotFoundException(`Section with ID "${id}" not found`);
}
return section;
}
async update(
id: number,
updateSectionDto: UpdateSectionDto,
): Promise<Section> {
const { courseId } = updateSectionDto;
const course = await this.courseService.findOne(courseId);
let section = await this.findOne(id);
section = await this.sectionRepository.saveSection(
updateSectionDto,
course,
section,
);
return section;
}
async remove(id: number): Promise<void> {
const { affected } = await this.sectionRepository.delete(id);
if (affected === 0) {
throw new NotFoundException(`Section with ID "${id}" not found`);
}
}
}
|
nsantos1999/course-api
|
src/language/dto/update-language.dto.ts
|
import { PartialType } from '@nestjs/mapped-types';
import { CreateLanguageDto } from './create-language.dto';
export class UpdateLanguageDto extends CreateLanguageDto {}
|
nsantos1999/course-api
|
src/section/dto/update-section.dto.ts
|
import { PartialType } from '@nestjs/mapped-types';
import { CreateSectionDto } from './create-section.dto';
export class UpdateSectionDto extends CreateSectionDto {}
|
nsantos1999/course-api
|
src/section/section.module.ts
|
import { Module } from '@nestjs/common';
import { SectionService } from './section.service';
import { SectionController } from './section.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { SectionRepository } from './section.repository';
import { CourseModule } from 'src/course/course.module';
@Module({
imports: [TypeOrmModule.forFeature([SectionRepository]), CourseModule],
controllers: [SectionController],
providers: [SectionService],
})
export class SectionModule {}
|
nsantos1999/course-api
|
src/language/language.service.ts
|
<gh_stars>0
import {
Injectable,
InternalServerErrorException,
NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { CreateLanguageDto } from './dto/create-language.dto';
import { UpdateLanguageDto } from './dto/update-language.dto';
import { Language } from './entities/language.entity';
import { LanguageRepository } from './language.repository';
@Injectable()
export class LanguageService {
constructor(
@InjectRepository(LanguageRepository)
private languageRepository: LanguageRepository,
) {}
async create(createLanguageDto: CreateLanguageDto): Promise<Language> {
const language = await this.languageRepository.saveLanguage(
createLanguageDto,
);
if (!language) {
throw new InternalServerErrorException(
`We had a problem saving the language`,
);
}
return language;
}
findAll(): Promise<Language[]> {
return this.languageRepository.find();
}
async findOne(id: number): Promise<Language> {
const language = await this.languageRepository.findOne(id);
if (!language) {
throw new NotFoundException(`Language with ID "${id}" not found`);
}
return language;
}
async update(
id: number,
updateLanguageDto: UpdateLanguageDto,
): Promise<Language> {
let language = await this.findOne(id);
language = await this.languageRepository.saveLanguage(
updateLanguageDto,
language,
);
return language;
}
async remove(id: number): Promise<void> {
const { affected } = await this.languageRepository.delete(id);
if (affected === 0) {
throw new NotFoundException(`Language with ID "${id}" not found`);
}
}
}
|
nsantos1999/course-api
|
src/app.module.ts
|
<filename>src/app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { CourseModule } from './course/course.module';
// Configs objects
import { envConfig } from './configs/env.config';
import { typeOrmConfig } from './configs/typeorm.config';
import { LanguageModule } from './language/language.module';
import { SectionModule } from './section/section.module';
@Module({
imports: [
ConfigModule.forRoot(envConfig),
TypeOrmModule.forRoot(typeOrmConfig()),
LanguageModule,
CourseModule,
SectionModule,
],
})
export class AppModule {}
|
nsantos1999/course-api
|
src/language/language.controller.ts
|
<filename>src/language/language.controller.ts
import {
Controller,
Get,
Post,
Body,
Put,
Param,
Delete,
UsePipes,
ValidationPipe,
} from '@nestjs/common';
import { LanguageService } from './language.service';
import { CreateLanguageDto } from './dto/create-language.dto';
import { UpdateLanguageDto } from './dto/update-language.dto';
import { ApiResponse } from '@nestjs/swagger';
import { Language } from './entities/language.entity';
@Controller('language')
export class LanguageController {
constructor(private readonly languageService: LanguageService) {}
@Post()
@UsePipes(ValidationPipe)
@ApiResponse({
status: 201,
type: Language,
description: 'Creates new language for the courses',
})
create(@Body() createLanguageDto: CreateLanguageDto) {
return this.languageService.create(createLanguageDto);
}
@Get()
@ApiResponse({
status: 200,
type: Language,
isArray: true,
description: 'List of availables languages',
})
findAll() {
return this.languageService.findAll();
}
@Get(':id')
@ApiResponse({
status: 200,
type: Language,
description: 'Instance of a available language',
})
findOne(@Param('id') id: string) {
return this.languageService.findOne(+id);
}
@Put(':id')
@UsePipes(ValidationPipe)
@ApiResponse({
status: 200,
type: Language,
description: 'Update a exist language',
})
update(
@Param('id') id: string,
@Body() updateLanguageDto: UpdateLanguageDto,
) {
return this.languageService.update(+id, updateLanguageDto);
}
@Delete(':id')
@ApiResponse({
status: 200,
description: 'Delete a exist language',
})
remove(@Param('id') id: string) {
return this.languageService.remove(+id);
}
}
|
nsantos1999/course-api
|
src/course/dto/update-course.dto.ts
|
import { CreateCourseDto } from './create-course.dto';
export class UpdateCourseDto extends CreateCourseDto {}
|
cjc7373/chrome-volume-manager
|
src/background.ts
|
<reponame>cjc7373/chrome-volume-manager
import 'chrome-extension-async'
import Message from './interfaces/Message'
// Handle messages from popup
chrome.runtime.onMessage.addListener(async (message: Message, sender, respond) => {
switch (message.name) {
case 'get-tab-volume':
respond(await getTabVolume(message.tabId))
break
case 'set-tab-volume':
respond(undefined) // Nothing to send here.
await setTabVolume(message.tabId, message.value)
break
default:
throw Error(`Unknown message received: ${message}`)
}
})
// Clean everything up once the tab is closed
chrome.tabs.onRemoved.addListener(disposeTab)
interface CapturedTab {
audioContext: AudioContext,
// While we will never use `streamSource` property in the code,
// it is necessary to keep a reference to it, or else
// it will get garbage-collected and the sound will be gone.
streamSource: MediaStreamAudioSourceNode,
gainNode: GainNode
}
// We use promises to fight race conditions.
const tabs: { [tabId: number]: Promise<CapturedTab> } = {}
/**
* Captures a tab's sound, allowing it to be programmatically modified.
* Puts a promise into the `tabs` object. We only need to call this function
* if the tab isn't yet in that object.
* @param tabId Tab ID
*/
function captureTab (tabId: number) {
tabs[tabId] = new Promise(async resolve => {
const stream = await chrome.tabCapture.capture({ audio: true, video: false })
const audioContext = new AudioContext()
const streamSource = audioContext.createMediaStreamSource(stream)
const gainNode = audioContext.createGain()
streamSource.connect(gainNode)
gainNode.connect(audioContext.destination)
resolve({ audioContext, streamSource, gainNode })
})
}
/**
* Returns a tab's volume, `1` if the tab isn't captured yet.
* @param tabId Tab ID
*/
async function getTabVolume (tabId: number) {
return tabId in tabs ? (await tabs[tabId]).gainNode.gain.value : 1
}
/**
* Sets a tab's volume. Captures the tab if it wasn't captured.
* @param tabId Tab ID
* @param value Volume. `1` means 100%, `0.5` is 50%, etc
*/
async function setTabVolume (tabId: number, value: number) {
if (!(tabId in tabs)) {
captureTab(tabId)
}
(await tabs[tabId]).gainNode.gain.value = value
updateBadge(tabId, value)
}
/**
* Updates the badge which represents current volume.
* @param tabId Tab ID
* @param value Volume. `1` will display 100, `0.5` - 50, etc
*/
async function updateBadge (tabId: number, value: number) {
if (tabId in tabs) {
const text = String(Math.round(value * 100)) // I love rounding errors!
chrome.browserAction.setBadgeText({ text, tabId })
}
}
/**
* Removes the tab from `tabs` object and closes its AudioContext.
* This function gets called when a tab is closed.
* @param tabId Tab ID
*/
async function disposeTab (tabId: number) {
if (tabId in tabs) {
(await tabs[tabId]).audioContext.close()
delete tabs[tabId]
}
}
|
cjc7373/chrome-volume-manager
|
src/popup.ts
|
import 'chrome-extension-async'
import Message from './interfaces/Message'
import { MDCSlider } from '@material/slider'
const slider: HTMLInputElement = document.querySelector('#volume-slider')
void (async () => {
// Hide the slider until we know the initial volume
slider.style.opacity = '0'
const initialValue: number = await getActiveTabVolume()
console.log(initialValue)
slider.value = String(initialValue * 100)
slider.style.opacity = '1'
})()
slider.addEventListener('input', () => {
const value = Number(slider.value) / 100
setActiveTabVolume(value)
})
async function getActiveTabVolume () {
const tabId = await getActiveTabId()
const message: Message = { name: 'get-tab-volume', tabId }
return chrome.runtime.sendMessage(message)
}
async function setActiveTabVolume (value: number) {
const tabId = await getActiveTabId()
const message: Message = { name: 'set-tab-volume', tabId, value }
return chrome.runtime.sendMessage(message)
}
async function getActiveTabId () {
const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true })
return activeTab.id
}
|
alerque/actions-tagger
|
tests/functions.test.ts
|
<gh_stars>0
beforeEach(() => jest.resetModules());
describe("getPreferredRef()", () => {
it("Should be heads", () => {
process.env.INPUT_PREFER_BRANCH_RELEASES = "true";
return import("src/functions").then(({ getPreferredRef }) =>
expect(getPreferredRef()).toBe("heads")
);
});
it("Should be tags", () => {
process.env.INPUT_PREFER_BRANCH_RELEASES = "false";
return import("src/functions").then(({ getPreferredRef }) =>
expect(getPreferredRef()).toBe("tags")
);
});
});
|
alerque/actions-tagger
|
tests/action.tests.ts
|
beforeEach(() => jest.resetModules());
|
alerque/actions-tagger
|
src/index.ts
|
<filename>src/index.ts<gh_stars>0
export interface TaggedRelease {
ref: string;
latest: boolean;
}
export interface LatestRelease {
repoLatest: string;
majorLatest: string;
}
export interface ActionPreferences {
readonly publishLatestTag: boolean;
readonly preferBranchRelease: boolean;
}
export const preferences: ActionPreferences = {
publishLatestTag:
(process.env.INPUT_PUBLISH_LATEST ?? process.env.INPUT_PUBLISH_LATEST_TAG).toLowerCase() === "true",
preferBranchRelease: process.env.INPUT_PREFER_BRANCH_RELEASES.toLowerCase() === "true",
};
export const queryAllRefs = `
query ($repoOwner: String!, $repoName: String!, $majorRef: String!, $pagination: String = "") {
repository(name: $repoName, owner: $repoOwner) {
refs(refPrefix: $majorRef, first: 100, after: $pagination, orderBy: {field: ALPHABETICAL, direction: DESC}) {
refsList: edges {
ref: node {
name
}
}
pageInfo {
endCursor
hasNextPage
}
totalCount
}
}
}`;
|
alerque/actions-tagger
|
src/functions.ts
|
<filename>src/functions.ts
import SemVer from "semver/classes/semver";
import * as core from "@actions/core";
import { context } from "@actions/github";
import { Octokit as GitHub } from "@octokit/core";
import coerce from "semver/functions/coerce";
import valid from "semver/functions/valid";
import major from "semver/functions/major";
import semverParse from "semver/functions/parse";
import semverGt from "semver/functions/gt";
import { preferences, LatestRelease, queryAllRefs, TaggedRelease } from ".";
/**
* Checks if the event that triggered this action was a release
* See: https://developer.github.com/v3/activity/events/types/#releaseevent
*/
function isRelease(): boolean {
return context.eventName === "release";
}
/**
* Is a release available to the public?
* A pre-release is usually considered "not ready" for public use
*/
function isPublicRelease(): boolean {
return isRelease() && !isPreRelease();
}
/**
* Check if the event that triggered this actions was as a result
* of a prerelease or not
*
* For some reason, it is not enough to check if the action is
* prereleased, because even prereleases have the action of "published"
* See: https://github.community/t5/GitHub-Actions/Release-Prerelease-action-triggers/m-p/42177#M4892
* See also: https://developer.github.com/v3/activity/events/types/#releaseevent
*/
function isPreRelease(): boolean {
return context.payload.release?.prerelease === true;
}
/**
* Get the actual tag version for this release. It also takes into account
* whether or not this is a prerelease
*
* @returns the tag for this release (if any)
*/
export function releaseTag(): SemVer {
let tagName: string | SemVer = context.payload.release?.tag_name;
if (isPreRelease()) {
tagName = coerce(tagName, { includePrerelease: true });
}
return semverParse(tagName);
}
/**
* Check if this release is publically available and has been published
*/
export function isPublishedRelease(): boolean {
return isPublicRelease() && context.payload.action === "published";
}
/**
* Check if this release is publically available and has been edited
*/
export function isEditedRelease(): boolean {
return isPublicRelease() && context.payload.action === "edited";
}
/**
* Checks if the tag version of the release is valid semantic version
*/
export function isSemVersionedRelease(): boolean {
return valid(releaseTag()) !== null;
}
/**
* Get the major number of the release tag
*/
export function majorVersion(): number {
return major(releaseTag());
}
/**
* Returns the appropriate ref depending on the input preferences
*/
export function getPreferredRef(): string {
if (preferences.preferBranchRelease) {
return "heads";
}
return "tags";
}
/**
* Finds the latest release in the repository as well as the latest release
* for this release major version. We do this to determine if we should proceed
* with promoting the major and latest refs.
*
* e.g. if this release is tagged v3.2.2, but the latest release is v4.0.3,
* a possible return value may be {repoLatest: "v4.0.3", majorLatest: "v3.3.0"}.
* In this case, this release should not trigger an update because the release is
* targetting a lower version than the latest v3 and we already have a latest version
* which is v4.0.3
*
* @param {GitHub} github The octokit client instance
*/
export async function findLatestReleases(github: GitHub): Promise<LatestRelease> {
const releaseVer = releaseTag();
let repoLatest = releaseVer;
let majorLatest = repoLatest;
const major = majorVersion();
if (core.isDebug()) {
core.debug("Found the following releases:");
}
for (let nextPage: string; true; ) {
const { repository } = await github.graphql(queryAllRefs, {
repoName: context.repo.repo,
repoOwner: context.repo.owner,
majorRef: `refs/${getPreferredRef()}/`,
pagination: nextPage,
});
for (const { ref } of repository.refs.refsList) {
const semverRef = semverParse(ref.name);
if (semverRef !== null) {
if (semverRef.major === major && semverGt(semverRef, majorLatest)) {
majorLatest = semverRef;
}
if (semverGt(semverRef, repoLatest)) {
repoLatest = semverRef;
}
}
}
if (repository.refs.pageInfo.hasNextPage) {
nextPage = repository.refs.pageInfo.endCursor;
} else {
break;
}
}
return { repoLatest: repoLatest.version, majorLatest: majorLatest.version };
}
/**
* Creates the tags required and optionally a 'latest' tag
*
* @param {GitHub} github The octokit client for making requests
* @param {Boolean} overridePublishLatest Flag used to force the publishing of the latest tag
*/
export async function createRequiredRefs(
github: GitHub,
overridePublishLatest?: boolean
): Promise<TaggedRelease> {
const mayor = majorVersion();
const ref = `${getPreferredRef()}/v${mayor}`;
await createRef(github, ref);
const publishLatest: boolean = overridePublishLatest ?? preferences.publishLatestTag;
if (publishLatest) {
await createRef(github, "tags/latest");
}
return { ref, latest: publishLatest };
}
/**
* Creates the given ref for this release
* refName must begin with tags/ or heads/
*
* @param github The github client
* @param refName The name of the ref to use. ex tags/latest, heads/v1, etc
*/
async function createRef(github: GitHub, refName: string) {
const { data: matchingRefs } = await github.git.listMatchingRefs({
...context.repo,
ref: refName,
});
const matchingRef = matchingRefs.find((refObj: { ref: string }) => {
return refObj.ref.endsWith(refName);
});
let upstreamRef: unknown;
if (matchingRef !== undefined) {
core.debug(`Updating ref: ${refName} to: ${process.env.GITHUB_SHA}`);
({ data: upstreamRef } = await github.git.updateRef({
...context.repo,
force: true,
ref: refName,
sha: process.env.GITHUB_SHA,
}));
} else {
core.debug(`Creating ref: refs/${refName} for: ${process.env.GITHUB_SHA}`);
({ data: upstreamRef } = await github.git.createRef({
...context.repo,
ref: `refs/${refName}`,
sha: process.env.GITHUB_SHA,
}));
}
if (core.isDebug()) {
core.debug(JSON.stringify(upstreamRef));
}
}
/**
* Sets the output of this action to indicate the version that was published/updated
* @param refName The tag version
*/
export function outputTagName(refName: string) {
core.setOutput("tag", refName);
// TODO: DEPRECATED: Will be removed in v3
core.setOutput("ref_name", refName);
}
/**
* Sets the output of this action to indicate if the latest tag was published
* @param isLatest
*/
export function outputLatest(isLatest: boolean) {
core.setOutput("latest", isLatest.toString());
}
|
alerque/actions-tagger
|
tests/test-setup.ts
|
<filename>tests/test-setup.ts
export default async () => {
process.env.INPUT_PUBLISH_LATEST_TAG = "false";
process.env.INPUT_PREFER_BRANCH_RELEASES = "false";
};
|
EdRamos12/Proffy
|
web/src/contexts/NotificationContext.tsx
|
<filename>web/src/contexts/NotificationContext.tsx
import React, { createContext, useReducer, useState } from 'react';
import { v4 } from 'uuid';
import NotificationComponent from '../components/Notification';
const NotificationContext = createContext({} as any);
export const NotificationProvider: React.FC = (props) => {
const [state, dispatch] = useReducer((state: any, action: { id?: any, type: any; payload: any; }) => {
switch (action.type) {
case 'ADD_NOTIFICATION':
return [...state, {...action.payload}];
case 'REMOVE_NOTIFICATION':
return state.filter((el: any) => el.id !== action.id);
default:
return state;
}
}, []);
// dispatch({
// type: "ADD_NOTIFICATION",
// payload: {
// type: 'SUCCESS',
// message: 'Testing3',
// title: 'Successful test!!!',
// id: v4(),
// }
// });
return (
<NotificationContext.Provider value={dispatch}>
<div className="notification-wrapper">
{state.map((note: any) => {
return <NotificationComponent dispatch={dispatch} key={note.id} {...note} />
})}
</div>
{props.children}
</NotificationContext.Provider>
)
};
export default NotificationContext;
|
EdRamos12/Proffy
|
server/src/controllers/ClassesController.ts
|
import { Request, Response } from 'express';
import db from '../db/connections';
import convertHoursToMinutes from '../utils/converHoursToMinutes';
interface ScheduleItem {
week_day: number;
from: string;
to: string;
}
export default class ClassesController {
async index(rq: Request, rsp: Response) {
//let initialSeconds = Date.now();
const filters = rq.query;
const [count] = await db('classes').count();
const { page = 1 } = rq.query;
const limit = 5;
const offset = (Number(page) - 1) * limit;
if (offset < 0) {
return rsp.json([]);
}
if (filters.user_id) {
const classes_items = await db('classes')
.join('users', 'classes.user_id', '=', 'users.id')
.join('profile', 'classes.user_id', '=', 'profile.user_id')
.orderBy('id', 'desc').limit(limit).offset(offset)
.where('classes.user_id', '=', Number(filters.user_id))
.select('classes.*', 'users.name', 'users.id as user_id', 'profile.avatar', 'profile.whatsapp', 'profile.bio');
let [total] = await db('classes').where('classes.user_id', '=', Number(filters.user_id)).count();
for (let i = 0; i < classes_items.length; i++) {
const scheduled_items = await db('class_schedule').where('class_id', '=', classes_items[i].id).select('class_schedule.class_id', 'class_schedule.from', 'class_schedule.to', 'class_schedule.week_day');
if (scheduled_items != undefined) {
classes_items[i].schedule = scheduled_items
}
}
rsp.header('X-Total-Count', String(total['count(*)']));
//console.log(`Responded in ${Date.now()-initialSeconds}ms!`);
return rsp.json(classes_items);
}
if (!filters.subject || !filters.week_day || !filters.time) {
const classes_items = await db('classes')
.join('users', 'classes.user_id', '=', 'users.id')
.join('profile', 'classes.user_id', '=', 'profile.user_id')
.orderBy('id', 'desc').limit(limit).offset(offset)
.select('classes.*', 'users.name', 'users.id as user_id', 'profile.avatar', 'profile.whatsapp', 'profile.bio');
for (let i = 0; i < classes_items.length; i++) {
// I GOT A BETTER SOLUTION SUCKEEEEEERS
const scheduled_items = await db('class_schedule').where('class_id', '=', classes_items[i].id).select('class_schedule.class_id', 'class_schedule.from', 'class_schedule.to', 'class_schedule.week_day');
if (scheduled_items != undefined) {
classes_items[i].schedule = scheduled_items
}
}
rsp.header('X-Total-Count', String(count['count(*)']));
//console.log(`Responded in ${Date.now()-initialSeconds}ms!`);
return rsp.json(classes_items);
}
const timeInMinutes = convertHoursToMinutes(filters.time as string);
const totalDefault = await db('classes')
.whereExists(function () {
this.select('class_schedule.*')
.from('class_schedule')
.whereRaw('`class_schedule`.`class_id` = `classes`.`id`')
.whereRaw('`class_schedule`.`week_day` = ??', [Number(filters.week_day as string)])
.whereRaw('`class_schedule`.`from` <= ??', [timeInMinutes])
.whereRaw('`class_schedule`.`to` > ??', [timeInMinutes])
})
.where('classes.subject', '=', filters.subject as string)
.join('users', 'classes.user_id', '=', 'users.id')
.join('profile', 'classes.user_id', '=', 'profile.user_id')
.count('* as total');
rsp.header('X-Total-Count', String(totalDefault[0].total));
const classes = await db('classes')
.whereExists(function () {
this.select('class_schedule.*')
.from('class_schedule')
.whereRaw('`class_schedule`.`class_id` = `classes`.`id`')
.whereRaw('`class_schedule`.`week_day` = ??', [Number(filters.week_day as string)])
.whereRaw('`class_schedule`.`from` <= ??', [timeInMinutes])
.whereRaw('`class_schedule`.`to` > ??', [timeInMinutes])
})
.where('classes.subject', '=', filters.subject as string)
.join('users', 'classes.user_id', '=', 'users.id')
.join('profile', 'classes.user_id', '=', 'profile.user_id')
.orderBy('id', 'desc').limit(limit).offset(offset)
.select('classes.*', 'users.name', 'users.id as user_id', 'profile.avatar', 'profile.whatsapp', 'profile.bio');
// made a better algorithm :)
for (let i = 0; i < classes.length; i++) {
const scheduled_items = await db('class_schedule').where('class_id', '=', classes[i].id);
if (scheduled_items != undefined) {
classes[i].schedule = scheduled_items
}
}
//console.log(`Responded in ${Date.now()-initialSeconds}ms!`);
return rsp.json(classes);
}
async create(rq: Request, rsp: Response) {
const { subject, cost, schedule } = rq.body;
const trx = await db.transaction();
try {
const user_id = rq.userId;
const insertedClassId = await trx('classes').insert({
subject,
cost,
user_id
});
const class_id = insertedClassId[0];
//console.log(class_id);
const classSchedule = schedule.map((scheduleItem: ScheduleItem) => {
return {
class_id,
week_day: scheduleItem.week_day,
from: convertHoursToMinutes(scheduleItem.from),
to: convertHoursToMinutes(scheduleItem.to),
}
});
await trx('class_schedule').insert(classSchedule);
await trx.commit();
return rsp.status(201).send();
} catch (err) {
await trx.rollback();
console.error(err);
return rsp.status(400).json({
message: err
});
}
}
async delete(rq: Request, rsp: Response) {
const { id } = rq.params;
if (!id)
return rsp.status(400).send({ message: 'Id not provided' });
const classes = await db('classes').where('id', '=', id);
if (classes.length == 0)
return rsp.status(400).send({ message: 'Invalid Id' });
if (classes[0].user_id != rq.userId)
return rsp.status(400).send({ message: 'Unauthorized' });
const trx = await db.transaction();
await trx('classes').where('id', '=', id).delete();
await trx.commit();
return rsp.send({ message: 'Class deleted.' })
}
async edit(rq: Request, rsp: Response) {
const { id } = rq.params;
const { subject, cost, schedule } = rq.body;
if (!id)
return rsp.status(400).send({ message: 'Id not provided' });
const classes = await db('classes').where('id', '=', id);
if (classes.length == 0)
return rsp.status(400).send({ message: 'Invalid Id' });
if (classes[0].user_id != rq.userId)
return rsp.status(400).send({ message: 'Unauthorized' });
const trx = await db.transaction();
try {
await trx('classes').where('id', '=', id).update({
subject,
cost,
user_id: rq.userId
});
const classSchedule = schedule.map((scheduleItem: ScheduleItem) => {
return {
class_id: id,
week_day: scheduleItem.week_day,
from: convertHoursToMinutes(scheduleItem.from),
to: convertHoursToMinutes(scheduleItem.to),
}
});
await trx('class_schedule').where('class_schedule.class_id', '=', id).delete();
await trx('class_schedule').insert(classSchedule);
await trx.commit();
return rsp.status(201).send();
} catch (err) {
await trx.rollback();
console.error(err);
return rsp.status(400).json({
message: err
});
}
}
async total(rq: Request, rsp: Response) {
const totalClasses = await db('classes').count('* as total');
const { total } = totalClasses[0];
return rsp.json({ total });
}
async total_from_user(rq: Request, rsp: Response) {
const { user_id } = rq.params;
const totalClasses = await db('classes').where('user_id', '=', user_id).count('* as total');
const { total } = totalClasses[0];
return rsp.json({ total });
}
async index_one(rq: Request, rsp: Response) {
const { id } = rq.params;
const classes = await db('classes')
.join('users', 'classes.user_id', '=', 'users.id')
.join('profile', 'classes.user_id', '=', 'profile.user_id')
.where('classes.id', '=', Number(id))
.select('classes.*', 'users.name', 'users.id as user_id', 'profile.avatar', 'profile.whatsapp', 'profile.bio');
const scheduled_items = await db('class_schedule').where('class_id', '=', classes[0].id);
if (scheduled_items != undefined) {
classes[0].schedule = scheduled_items
}
console.log(classes);
if (classes.length == 0)
return rsp.status(400).send({ message: 'Invalid Id' });
return rsp.json(classes);
}
}
|
EdRamos12/Proffy
|
web/src/contexts/PostStorage.tsx
|
import React, { createContext, useState } from 'react';
interface Schedule {
class_id: Number;
from: Number;
to: Number;
week_day: Number;
}
interface Post {
avatar: String;
bio: String;
cost: Number;
created_at: String;
id: Number;
name: String;
schedule: Schedule[];
subject: String;
user_id: Number;
whatsapp: String;
}
interface PostStorageData {
storedPosts: Post[] | null;
storedPage: number;
chunkInfo: (page: number, data: Post[]) => void;
storedProfilePosts: any;
chunkProfilePostsInfo: (page: number, data: Post[], id: number) => void;
}
declare global {
interface Window { stored_posts: any; }
}
const PostStorage = createContext<PostStorageData>({} as PostStorageData);
export const PostStorageProvider: React.FC = ({ children }) => {
// main page
const [storedPosts, setStoredPosts] = useState<Post[] | null>(null);
const [storedPage, setStoredPage] = useState(1);
//profile pages
const [storedProfilePosts, setStoredProfilePosts] = useState({}) as any;
function chunkInfo(page: number, teacher: Post[]) {
setStoredPosts(teacher);
setStoredPage(page);
}
function chunkProfilePostsInfo(page: number, teacher: Post[], user_id: number) {
setStoredProfilePosts((prev: any) => {
return {...prev, [user_id]: {page, teacher}};
});
window.stored_posts = {main: storedPosts, profiles: storedProfilePosts};
}
return <PostStorage.Provider value={{ storedPosts, storedPage, chunkInfo, storedProfilePosts, chunkProfilePostsInfo }} >
{children}
</PostStorage.Provider>
};
export default PostStorage;
|
EdRamos12/Proffy
|
web/src/App.tsx
|
import React from 'react';
import './assets/styles/global.css'
import Routes from './routes';
import { Router } from 'react-router-dom';
import { createBrowserHistory } from 'history';
import { AuthProvider } from './contexts/AuthContext';
import { PostStorageProvider } from './contexts/PostStorage';
import { NotificationProvider } from './contexts/NotificationContext';
const history = createBrowserHistory();
function App() {
return (
<Router history={history}>
<AuthProvider>
<PostStorageProvider>
<NotificationProvider>
<Routes />
</NotificationProvider>
</PostStorageProvider>
</AuthProvider>
</Router>
);
}
export default App;
|
EdRamos12/Proffy
|
server/src/server.ts
|
import express from 'express';
import cors from 'cors';
import routes from './routes';
import path from 'path';
import cookieParser from 'cookie-parser';
import {errors} from 'celebrate';
import rateLimit from 'express-rate-limit';
require('dotenv/config');
const app = express();
const apiLimiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minutes
max: 100,
handler: (_, rsp) => {
return rsp.status(429).send({ message: 'You are being rate limited. Please try again later.' })
}
});
let host = '';
if (process.env.WEB_HOST == '' || process.env.WEB_HOST == undefined) {
host += 'http://localhost';
} else {
host += process.env.WEB_HOST;
}
if (process.env.WEB_PORT != '' || process.env.WEB_PORT != undefined) {
host += ':'+process.env.WEB_PORT
}
app.use('/api/', apiLimiter);
app.use(cookieParser());
app.use(express.json());
app.use(cors({
credentials: true,
//origin: host,
exposedHeaders: ['X-Total-Count'],
}));
app.use('/api/v2', routes);
app.use(errors());
app.use('/uploads', express.static(path.resolve(__dirname, '..', 'uploads')))
app.listen(process.env.PORT || 3333);
|
EdRamos12/Proffy
|
server/src/@types/index.d.ts
|
declare module '*.json';
declare namespace Express {
interface Request {
customProperties: string[];
userId: number;
}
}
|
EdRamos12/Proffy
|
web/src/components/SuccessContainer/index.tsx
|
<reponame>EdRamos12/Proffy<gh_stars>1-10
import React from 'react';
import './styles.css';
import { Link } from 'react-router-dom';
import checkIcon from '../../assets/images/icons/feito.svg';
interface SuccessProps {
title: string;
button_text: string;
success?: boolean;
}
const SuccessContainer: React.FC<SuccessProps> = ({ title, button_text, success, children }) => {
console.log(success);
return (
<>
{success && <div id={'register-success'}>
<div id="success-content">
<img src={checkIcon} alt="Feito" />
<div>
<h1>{title}</h1>
<p>
{children}
</p>
</div>
<Link to="/">{button_text}</Link>
</div>
</div>}
</>
);
}
export default SuccessContainer;
|
EdRamos12/Proffy
|
server/src/utils/auth.ts
|
<filename>server/src/utils/auth.ts
import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
export default function authMiddleware (rq: Request, rsp: Response, next: NextFunction) {
const authHeader = rq.cookies.__bruh;
if (!authHeader) return rsp.status(401).send({ message: 'No token provided' });
const parts = authHeader.split(' ');
if (parts.length != 2) return rsp.status(401).send({ message: 'Token error' });
const [scheme, token] = parts;
if (!/^Proff$/i.test(scheme)) return rsp.status(401).send({ message: 'Error while formatting the token' });
jwt.verify(token, String(process.env.JWT_AUTH), (error: any, decoded: any) => {
if (error) return rsp.status(401).send({ error });
rq.userId = decoded.id;
return next();
});
}
|
EdRamos12/Proffy
|
web/src/pages/Register/index.tsx
|
import React, { useState, FormEvent, useEffect } from 'react';
import { Link } from 'react-router-dom';
import logoImg from '../../assets/images/logo.svg';
import backIcon from '../../assets/images/icons/back.svg'
import './styles.css';
import api from '../../services/api';
import SuccessContainer from '../../components/SuccessContainer';
export default function Register() {
const [firstName, setFirstName] = useState('');
const [lastName, setLastName] = useState('');
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [success, setSuccess] = useState(false);
const [error, setError] = useState('');
async function handleRegister(e: FormEvent) {
e.preventDefault();
setError('');
const name = `${firstName} ${lastName}`
try {
const info = await api.post('/register', {
name,
email,
password
}, { withCredentials: true });
if (Boolean(info)) {
setSuccess(true)
}
} catch (error) {
setError(error.response.data.message);
}
}
function handleDisabledButton() {
if (email.length !== 0 && password.length !== 0 && firstName.length !== 0 && lastName.length !== 0) {
return false;
}
return true;
}
useEffect(() => {
setError('');
}, [firstName, lastName, password, email])
return (
<div id="register-page">
<SuccessContainer title="Registered successfully" success={success} button_text="Sign in!">
Now, go check your e-mail to get be part of Proffy. <br />
Have a nice experience.
</SuccessContainer>
<div id="register-page-content">
<Link to='/' id="go-back">
<img src={backIcon} alt="go back" />
</Link>
<form onSubmit={handleRegister} id="register-form">
<fieldset>
<div id="register-form-header">
<h1>Register</h1>
<p id="description">
Fill in the details below <br /> to get started.
</p>
<span><strong>{error}</strong></span>
</div>
<div className="input-block" id="First-name">
<label htmlFor="First-name-input" id={Boolean(firstName) ? "active" : ""}>First name</label>
<input id="First-name-input" className={Boolean(error) ? "input-error" : ""} onChange={(e) => {setFirstName(e.target.value)}} />
</div>
<div className="input-block" id="Last-name">
<label htmlFor="Last-name-input" id={Boolean(lastName) ? "active" : ""}>Last name</label>
<input id="Last-name-input" className={Boolean(error) ? "input-error" : ""} onChange={(e) => {setLastName(e.target.value)}} />
</div>
<div className="input-block" id="Email">
<label htmlFor="Email-input" id={Boolean(email) ? "active" : ""}>Email</label>
<input type="email" id="Email-input" className={Boolean(error) ? "input-error" : ""} onChange={(e) => {setEmail(e.target.value)}} />
</div>
<div className="input-block" id="Password">
<label htmlFor="Password-input" id={Boolean(password) ? "active" : ""}>Password</label>
<input type="password" id="Password-input" className={Boolean(error) ? "input-error" : ""} onChange={(e) => {setPassword(e.target.value)}} />
</div>
<button type="submit" disabled={handleDisabledButton()}>
Complete registration!
</button>
</fieldset>
</form>
<div id="register-bg-container">
<div id="register-bg-items-container">
<div>
<img src={logoImg} alt="Proffy"/>
<h2>Your online platform <br /> to study.</h2>
</div>
</div>
</div>
</div>
</div>
);
}
|
EdRamos12/Proffy
|
web/src/components/PrivateRoute/index.tsx
|
<filename>web/src/components/PrivateRoute/index.tsx
import React, { useState, useEffect, useContext } from 'react';
import { Route, Redirect } from 'react-router-dom';
import PageHeader from '../PageHeader';
import AuthContext from '../../contexts/AuthContext';
const PrivateRoute: React.FC<any> = ({ component: Component, ...rest }) => {
const { authenticated, loading, verifyAuthentication } = useContext(AuthContext);
const [currentAuth, setCurrentAuth] = useState(authenticated);
const [currentLoad, setCurrentLoad] = useState(loading);
useEffect(() => {
const verify = () => {
if (currentLoad) if (!currentAuth) {
verifyAuthentication().then(bool => {
//console.log(Boolean(bool))
setCurrentAuth(Boolean(bool));// returns true/false
setCurrentLoad(false);
}).catch(err => {
setCurrentAuth(false);
setCurrentLoad(false);
});
}
}
let mounted = true;
if (mounted) {
verify();
}
return () => { mounted = false }
}, [currentAuth, currentLoad, verifyAuthentication]);
return (
<Route {...rest} render={(props) =>
currentAuth ? (
<Component {...props} />
) : currentLoad ? (
<div id="page-teacher-form" className="container"><PageHeader title=" " description=" " /></div>
) : (
<Redirect
to={{
pathname: '/',
state: { message: 'User not authorized' },
}}
/>
)}
/>
);
}
export { PrivateRoute };
|
EdRamos12/Proffy
|
web/src/components/Dropzone/index.tsx
|
import React, {useCallback, useState, useContext} from 'react';
import {useDropzone} from 'react-dropzone';
import './styles.css';
import AuthContext from '../../contexts/AuthContext';
import cameraIcon from '../../assets/images/icons/camera.svg';
import NotificationContext from '../../contexts/NotificationContext';
import { v4 } from 'uuid';
interface Props {
onFileUpload: (file: File) => void;
}
const Dropzone: React.FC<Props> = ({ onFileUpload }) => {
const [selectedFileUrl, setSelectedFileUrl] = useState('');
const { user } = useContext(AuthContext);
const dispatch = useContext(NotificationContext);
const onDrop = useCallback(acceptedFiles => {
console.log(acceptedFiles[0]);
if (acceptedFiles[0] === undefined) return;
if (acceptedFiles[0].size > 5 * 1000 * 1000) {
dispatch({
type: "ADD_NOTIFICATION",
payload: {
type: 'ERROR',
message: 'The image you tried to upload is too large (higher than 5mb)!',
title: 'File size too large.',
id: v4(),
}
});
return;
}
if (!/jpeg|jpg|png|jfif/.test(acceptedFiles[0].type)) {
dispatch({
type: "ADD_NOTIFICATION",
payload: {
type: 'ERROR',
message: 'Try uploading the image as: .jpeg, .jpg, .png or .jfif',
title: 'Invalid image type.',
id: v4(),
}
});
return;
}
const file = acceptedFiles[0];
setSelectedFileUrl(URL.createObjectURL(file));
onFileUpload(file);
}, [onFileUpload]);
const {getRootProps, getInputProps, isDragActive} = useDropzone({onDrop, accept: ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/jfif']});
return (
<div className="dropzone" {...getRootProps()}>
<input {...getInputProps()} accept=".jpeg,.jpg,.png,.gif,.jfif"/>
{
selectedFileUrl ?
(
<>
<img id="avatar" src={selectedFileUrl} alt="Avatar" />
<h1>
{
isDragActive ?
"+" :
""
}
</h1>
<span id="camera">
<img src={cameraIcon} alt="Edit" />
</span>
</>
) :
(
<>
<h1 style={{marginTop: "6.5rem"}}>
{
isDragActive ?
"+" :
""
}
</h1>
<img id="avatar" src={user?.avatar} alt="Avatar" />
<span id="camera">
<img src={cameraIcon} alt="Edit" />
</span>
</>
)
}
</div>
)
}
export default Dropzone;
|
EdRamos12/Proffy
|
web/src/routes.tsx
|
import React from 'react';
import { Route, Switch, Redirect } from 'react-router-dom';
import Landing from './pages/Landing';
import TeacherForm from './pages/TeacherForm';
import TeacherList from './pages/TeacherList';
import Login from './pages/Login';
import { PrivateRoute } from './components/PrivateRoute';
import Register from './pages/Register';
import { PublicRoute } from './components/PublicRoute';
import Profile from './pages/Profile';
import Forgot from './pages/Forgot';
import Confirm from './pages/Confirm';
import Reset from './pages/Reset';
import ClassPage from './pages/ClassPage';
export default function Routes() {
return (
<Switch>
<PrivateRoute path="/home" exact component={Landing} />
<PrivateRoute path="/study" exact component={TeacherList} />
<PrivateRoute path="/give-classes" exact component={TeacherForm} />
<PrivateRoute path="/profile/:id" component={Profile} />
<PrivateRoute path="/profile" component={Profile} />
<PrivateRoute path="/class/:id" component={ClassPage} />
<PublicRoute path="/register" exact component={Register} />
<PublicRoute path="/forgot-password" exact component={Forgot} />
<PublicRoute path="/confirm/:token" component={Confirm} />
<PublicRoute path="/reset-password/:token" component={Reset} />
<PublicRoute path="/" exact component={Login} />
<Route path="/class" component={() => (
<Redirect
to={{pathname: '/',}}
/>
)} />
<Route path="/confirm" component={() => (
<Redirect
to={{pathname: '/',}}
/>
)} />
<Route path="/reset-password" component={() => (
<Redirect
to={{pathname: '/',}}
/>
)} />
<Route component={() => (<div><h1 style={{ fontSize: '15vw' }}>404</h1><h1 style={{ textAlign: 'center' }}>Page not found.</h1></div>)} />
</Switch>
)
}
|
EdRamos12/Proffy
|
web/src/pages/Landing/index.tsx
|
import React, { useState, useEffect, useContext } from 'react';
import { Link } from 'react-router-dom'
import logoImg from '../../assets/images/logo.svg';
import landingImg from '../../assets/images/landing.svg';
import studyIcon from '../../assets/images/icons/study.svg';
import giveClassesIcon from '../../assets/images/icons/give-classes.svg';
import heartIcon from '../../assets/images/icons/purple-heart.svg';
import editIcon from '../../assets/images/icons/edit.svg';
import logOutIcon from '../../assets/images/icons/log-out.svg';
import './styles.css';
import api from '../../services/api';
import AuthContext from '../../contexts/AuthContext';
const Landing: React.FC = () => {
const {user, signOut} = useContext(AuthContext);
const [totalConnections, setTotalConnections] = useState('...');
useEffect(() => {
api.get('/connections', {withCredentials: true}).then(response => {
setTotalConnections(response.data.total);
}).catch(err => {
console.log(err);
signOut();
});
}, [signOut]);
return (
<div id="page-landing" className="container">
<div id="page-landing-content">
<div id="header">
<div id="user-info">
<img src={user?.avatar} alt="Avatar"/>
{user?.name}
<Link to={`/profile/${user?.id}`}><img src={editIcon} alt="Avatar"/></Link>
</div>
<button id="logout" onClick={signOut}>
<img src={logOutIcon} alt="Power off"/>
</button>
</div>
<div className="logo">
<div className="logo-container">
<img src={logoImg} alt="Proffy"/>
<h2>Your online platform to study.</h2>
</div>
<img src={landingImg} alt="Studying platform" className="hero-image" />
</div>
</div>
<footer>
<div className="text-container">
<p>Welcome.</p>
<b>What would you like to do?</b>
</div>
<span className="total-connections">
Total of {totalConnections} connections already made!
<img src={heartIcon} alt="Coração roxo"/>
</span>
<div className="buttons-container">
<Link to="/study" className="study">
<img src={studyIcon} alt="Estudar"/>
Study
</Link>
<Link to="/give-classes" className="give-classes">
<img src={giveClassesIcon} alt="Dar aulas"/>
Give classes
</Link>
</div>
</footer>
</div>
);
}
export default Landing;
|
EdRamos12/Proffy
|
web/src/components/PublicRoute/index.tsx
|
<filename>web/src/components/PublicRoute/index.tsx
import React, { useState, useEffect, useContext, useCallback } from 'react';
import { Route, Redirect } from 'react-router-dom';
import AuthContext from '../../contexts/AuthContext';
import NotificationContext from '../../contexts/NotificationContext';
import { v4 } from 'uuid';
import LoadingScreen from '../../pages/LoadingPublic';
const PublicRoute: React.FC<any> = ({ component: Component, ...rest }) => {
const { authenticated, loading, verifyAuthentication } = useContext(AuthContext);
const [currentAuth, setCurrentAuth] = useState(authenticated);
const [currentLoad, setCurrentLoad] = useState(loading);
const dispatch = useContext(NotificationContext);
const verify = useCallback(async () => {
if (currentLoad) if (!currentAuth) {
const result = await verifyAuthentication().then(bool => {
//console.log(Boolean(bool))
return Boolean(bool);// returns true/false
}).catch(error => {
if (error.response === undefined) {
dispatch({
type: "ADD_NOTIFICATION",
payload: {
type: 'ERROR',
message: "It appears that we can't connect to our server. Check if your internet connection is stable or check our social media to see any scheduled maintenance. ",
title: 'Something went wrong.',
id: v4(),
}
});
}
return false;
});
setCurrentLoad(false);
setCurrentAuth(result);
return result;
} else {
return currentAuth;
}
}, [verifyAuthentication, currentLoad, currentAuth]);
useEffect(() => {
let mounted = true;
if (mounted) verify();
return () => {mounted = false}
}, [verifyAuthentication, verify]);
return (
<Route {...rest} render={(props) =>
currentAuth ? (
<Redirect
to={{
pathname: '/home',
state: { message: 'User logged in' }
}}
/>
) : currentLoad ? (
LoadingScreen()
) : (
<Component {...props} />
)}
/>
);
}
export { PublicRoute };
|
EdRamos12/Proffy
|
web/src/pages/Profile/index.tsx
|
<filename>web/src/pages/Profile/index.tsx
import React, { useContext, useEffect, useMemo, useState } from 'react'
import { useParams } from 'react-router-dom'
import PageHeader from '../../components/PageHeader';
import profileBackground from '../../assets/images/profile-background.svg';
import './styles.css';
import AuthContext from '../../contexts/AuthContext';
import api from '../../services/api';
import Input from '../../components/Input';
import warningIcon from '../../assets/images/icons/warning.svg';
import Textarea from '../../components/Textarea';
import Dropzone from '../../components/Dropzone';
import NotificationContext from '../../contexts/NotificationContext';
import { v4 } from 'uuid';
import TeacherItem, { Teacher } from '../../components/TeacherItem';
import PostStorage from '../../contexts/PostStorage';
import Cleave from 'cleave.js/react';
import 'cleave.js/dist/addons/cleave-phone.br';
interface User {
avatar: string;
name: string;
bio: string;
whatsapp: string;
confirmed: number;
total_connections: number;
id: number;
email: string;
}
export default function Profile() {
const { user } = useContext(AuthContext);
const { id = user?.id } = useParams() as any;
const dispatch = useContext(NotificationContext);
const { storedProfilePosts, chunkProfilePostsInfo } = useContext(PostStorage);
const [userProfile, setUserProfile] = useState<User>({} as User);
const [canEdit, setCanEdit] = useState(false);
const [deleted, setDeleted] = useState(false);
const [uploadProgress, setUploadProgress] = useState(0);
const [firstName, setFirstName] = useState('');
const [lastName, setLastName] = useState('');
const [whatsapp, setWhatsapp] = useState('');
const [selectedFile, setSelectedFile] = useState<File>();
const [bio, setBio] = useState('');
// classes thingy
const [teachers, setTeachers] = useState([]); // posts
const [page, setPage] = useState(1);
const [total, setTotal] = useState(0);
const [loading, setLoading] = useState(false);
// no more posts to load
const [limitReached, setLimitReached] = useState(false);
// scroll value
const [bottomPageValue, setBottomPageValue] = useState(0);
function splitName(info: string) {
const name = String(info).split(' ');
setFirstName(name[0]);
name.shift();
setLastName(name.join(' '));
};
const checkChunkedPosts = useMemo(() => async function a() {
if (storedProfilePosts[id] !== undefined && storedProfilePosts[id].teacher !== teachers) {
setPage(storedProfilePosts[id].page + 1);
setTeachers(storedProfilePosts[id].teacher as never[]);
} else {
setLoading(true);
}
}, [storedProfilePosts, teachers]);
// loading actual profile
useEffect(() => {
let isMounted = true;
if (Number(user?.id) === Number(id)) {
setUserProfile(user as User);
splitName(String(user?.name));
setCanEdit(true);
} else {
api.get(`/profile/${id}`, { withCredentials: true }).then(profile => {
if (isMounted) {
setUserProfile(profile.data);
splitName(profile.data.name);
}
}).catch(err => {
setDeleted(true)
});
setCanEdit(false);
}
return () => { isMounted = false; }
}, [id, user]);
useEffect(() => {
setWhatsapp(String(userProfile.whatsapp));
setBio(String(userProfile.bio));
console.log(userProfile.whatsapp);
}, [userProfile]);
useEffect(() => {
// api.get(`/total_classes/user/${id}`, { withCredentials: true }).then((info) => {
// setTotalClasses(info.data.total);
// });
checkChunkedPosts();
function handleScroll() {
if (window.innerHeight + document.documentElement.scrollTop < document.documentElement.scrollHeight - 700) return;
if (bottomPageValue === document.documentElement.scrollHeight) return;
setBottomPageValue(document.documentElement.scrollHeight);
setLoading(true);
}
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, [bottomPageValue]);
const loadClasses = useMemo(() => async function a() {
console.log(page);
if (total > 0 && teachers.length === total) {
setLoading(false);
setLimitReached(true);
return;
}
if (limitReached) {
setLoading(false);
return;
}
let response = await api.get('/classes', {
params: {
page,
user_id: id
},
withCredentials: true
});
setTeachers([...teachers, ...response.data] as any);
if (response.data.length === 0) {
setLoading(false);
setLimitReached(true);
return;
}
setPage(page + 1);
setLoading(false);
setTotal(response.headers['x-total-count']);
chunkProfilePostsInfo(page, [...teachers, ...response.data], Number(id));
return;
}, [limitReached, page, teachers, total]);
useEffect(() => {
if (!loading) return;
loadClasses();
}, [loading]);
async function handleChangeProfile(e: React.FormEvent) {
e.preventDefault();
const name = `${firstName} ${lastName}`
const data = new FormData();
data.append('name', name);
data.append('bio', bio);
data.append('whatsapp', whatsapp.replaceAll(' ', ''));
if (selectedFile) {
data.append('avatar', selectedFile);
}
try {
await api.put('profile', data, {
withCredentials: true,
onUploadProgress: (event) => {
setUploadProgress(Math.round((100 * event.loaded) / event.total));
}
})
dispatch({
type: "ADD_NOTIFICATION",
payload: {
type: 'SUCCESS',
message: 'Your profile has been successfully updated.',
title: 'Profile updated!',
id: v4(),
}
});
setUploadProgress(0);
} catch (err) {
if (err.response.status === 429) {
setUploadProgress(0);
dispatch({
type: "ADD_NOTIFICATION",
payload: {
type: 'ERROR',
message: err.response.data.message,
title: 'Something went wrong.',
id: v4(),
}
});
}
}
}
function addSpaces(initial: any) {
console.log(initial)
return initial;
}
return (
<div id="profile-page" className="container">
<div id="percentage" style={{ width: uploadProgress + '%' }} />
{deleted && <div id="not-found"><h1 style={{ fontSize: '15vw' }}>404</h1><h1 style={{ textAlign: 'center' }}>Page not found.</h1></div>}
<PageHeader background={profileBackground} page={canEdit ? 'My profile' : userProfile.name}>
<div className="profile">
{canEdit ? <Dropzone onFileUpload={setSelectedFile} /> : <div id="image-container"><img id="avatar" src={userProfile.avatar} alt="Avatar" /></div>}
<h1>{firstName} {lastName}</h1>
<p>got {userProfile.total_connections} connections on total!</p>
</div>
</PageHeader>
<main>
<form onSubmit={handleChangeProfile}>
<fieldset>
<legend>About me</legend>
<div id="profile-name">
<Input onChange={(e) => { setFirstName(e.target.value) }} label="First name" name="first-name" defaultValue={firstName} readOnly={!canEdit} />
<Input onChange={(e) => { setLastName(e.target.value) }} label="Last name" name="last-name" defaultValue={lastName} readOnly={!canEdit} />
{!canEdit && <Input label="Whatsapp" readOnly name="whatsapp" defaultValue={whatsapp === 'null' ? '' : whatsapp === 'undefined' ? '' : whatsapp} onChange={addSpaces} />}
</div>
<div id={canEdit ? "profile-communication" : "not-show"}>
<Input label="E-mail" name="e-mail" type="email" readOnly defaultValue={userProfile.email} />
{/* <Input defaultValue={whatsapp === 'null' ? '' : whatsapp === 'undefined' ? '' : whatsapp} /> */}
<div className="input-block" id="Whatsapp">
<label htmlFor="whatsapp">Whatsapp</label>
<Cleave id="whatsapp"
value={whatsapp}
required
onChange={(e) => { setWhatsapp(e.target.value) }}
options={{ prefix: '+55', phone: true, phoneRegionCode: 'BR' }}
/>
</div>
</div>
<Textarea onChange={(e) => { setBio(e.target.value) }} label="Biography" readOnly={!canEdit} name="bio" desc={canEdit ? "(Max. 300 characters)" : ""} defaultValue={bio === 'null' ? '' : bio === 'undefined' ? '' : bio} />
</fieldset>
{canEdit &&
<footer>
<p><img src={warningIcon} alt="Important warning" />
Important <br />
Fill up all fields.</p>
<button type="submit">
Change profile!
</button>
</footer>
}
</form>
</main>
{canEdit ? <h1>Your published classes:</h1> : <h1>Classes from this user:</h1>}
<div id="class-posts">
{teachers.map((teacher: Teacher, index) => {
return <TeacherItem key={index} teacher={teacher} />;
})}
<span id="limit-message">
{limitReached && 'These are all the results'}
{loading && 'Loading...'} <br />
{total === 0 && limitReached ? 'No teacher Found.' : ''}
</span>
</div>
</div>
)
}
|
EdRamos12/Proffy
|
web/src/contexts/AuthContext.tsx
|
import React, { createContext, useState, useCallback, useContext } from 'react';
import api from '../services/api';
import { useHistory } from 'react-router-dom';
interface User {
id: Number;
name: string;
avatar: string;
whatsapp: string;
bio: string;
total_connections: Number;
email: string;
}
interface AuthContextData {
authenticated: Boolean;
loading: Boolean;
user: User | null;
signIn(email: string, password: string, rememberMe: boolean): Promise<boolean>;
signOut(): Promise<void>;
verifyAuthentication(): Promise<Boolean>;
}
const AuthContext = createContext<AuthContextData>({} as AuthContextData);
export const AuthProvider: React.FC = ({ children }) => {
const history = useHistory();
const [user, setUser] = useState<User | null>(null);
const [loading, setLoading] = useState(true);
async function signIn(email: string, password: string, rememberMe: boolean) {
try {
const info = await api.post('/authenticate', {
email,
password,
remember_me: rememberMe,
}, { withCredentials: true });
setUser(info.data);
return true;
} catch (error) {
return false;
}
}
const signOut = useCallback(
async () => {
try {
await api.get('/logout', { withCredentials: true });
setUser(null);
history.push('/');
} catch (error) {
console.error(error.response);
alert(`An error ocurred, check logs for details: ${error.response.data.message}`)
}
},
[history]
)
async function verifyAuthentication() {
const info = await api.get('/verify', { withCredentials: true });
try {
setLoading(false);
setUser(info.data);
return true;
} catch (err) {
if (err.response.status === 429) {
alert(err.response.data.message);
return true;
}
else {
console.log(err);
setUser(null);
}
return false;
}
}
return (
<AuthContext.Provider value={{ authenticated: Boolean(user), user, loading, signOut, signIn, verifyAuthentication }}>
{children}
</AuthContext.Provider>
);
}
export default AuthContext;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.