nyx

The first CODM discrod bot -- cath.exe Template
git clone https://codeberg.org/night0721/nyx
Log | Files | Refs | LICENSE

mongoose.js (9201B)

      1 const mongoose = require("mongoose");
      2 const { GooseCache } = require("goosecache");
      3 const cachegoose = new GooseCache(mongoose, {
      4   engine: "memory",
      5 });
      6 mongoose.set("useFindAndModify", false);
      7 const u = require("../../models/users");
      8 const g = require("../../models/guilds");
      9 module.exports = {
     10   /**
     11    * @param {String} URI - Mongo Connection URI
     12    */
     13   async connect(URI) {
     14     if (!URI) throw new Error("Please provide a Mongoose URI");
     15     return mongoose.connect(URI, {
     16       useNewUrlParser: true,
     17       useUnifiedTopology: true,
     18     });
     19   },
     20   /**
     21    * @param {String} ID - Guild ID
     22    */
     23   async getGuild(ID) {
     24     if (!ID) throw new Error("Guild ID?");
     25     const guild = await g.findOne({ Guild: ID }).lean().cache(120);
     26     if (!guild) {
     27       const gg = new g({ Guild: ID });
     28       const { Guild, Prefix, Premium, Category, Commands, Tips } = gg;
     29       await gg.save().catch(error => console.log(error));
     30       return {
     31         Guild,
     32         Prefix,
     33         Premium,
     34         Category,
     35         Commands,
     36         Tips,
     37       };
     38     } else {
     39       const Guild = guild.Guild;
     40       const Prefix = guild.Prefix;
     41       const Premium = guild.Premium;
     42       const Category = guild.Category;
     43       const Commands = guild.Commands;
     44       const Tips = guild.Tips;
     45       return {
     46         Guild,
     47         Prefix,
     48         Premium,
     49         Category,
     50         Commands,
     51         Tips,
     52       };
     53     }
     54   },
     55   /**
     56    * @param {String} ID - User ID
     57    */
     58   async getUser(ID) {
     59     if (!ID) throw new Error("User ID?");
     60     const user = await u.findOne({ User: ID }).lean().cache(120);
     61     if (!user) {
     62       const ss = new u({ User: ID });
     63       const {
     64         User,
     65         Tier,
     66         Premium,
     67         Blacklist,
     68         Blacklist_Reason,
     69         PremiumServers,
     70       } = ss;
     71       await ss.save().catch(error => console.log(error));
     72       return {
     73         User,
     74         Tier,
     75         Premium,
     76         Blacklist,
     77         Blacklist_Reason,
     78         PremiumServers,
     79       };
     80     } else {
     81       const User = user.User;
     82       const Tier = user.Tier;
     83       const Premium = user.Premium;
     84       const Blacklist = user.Blacklist;
     85       const Blacklist_Reason = user.Blacklist_Reason;
     86       const PremiumServers = user.PremiumServers;
     87       return {
     88         User,
     89         Tier,
     90         Premium,
     91         Blacklist,
     92         Blacklist_Reason,
     93         PremiumServers,
     94       };
     95     }
     96   },
     97   /**
     98    * @param {String} ID - ID of the User
     99    * @param {String} Toggle - Blacklist Toggle(true/false)
    100    * @param {String} Reason - Blacklist Reason
    101    */
    102   async BK(ID, Toggle, Reason) {
    103     if (!ID) throw new Error("User ID?");
    104     // if (!Toggle) throw new Error("Blacklist Toggle?");
    105     if (!Reason) throw new Error("Blacklist Feason?");
    106     const user = await u.findOne({ User: ID });
    107     if (!user) {
    108       const sus = new u({ User: ID });
    109       if (Toggle == true) {
    110         user.Blacklist = true;
    111         user.Blacklist_Reason = Reason;
    112       } else {
    113         user.Blacklist = false;
    114         user.Blacklist_Reason = null;
    115       }
    116       await sus.save().catch(error => console.log(error));
    117       cachegoose.clearCache();
    118       return { Reason };
    119     } else {
    120       if (Toggle == true) {
    121         user.Blacklist = true;
    122         user.Blacklist_Reason = Reason;
    123       } else {
    124         user.Blacklist = false;
    125         user.Blacklist_Reason = null;
    126       }
    127       await user.save().catch(error => console.log(error));
    128       cachegoose.clearCache();
    129       return { Reason };
    130     }
    131   },
    132   /**
    133    * @param {String} ID - ID of the User
    134    * @param {Boolean} Toggle - Premium Toggle(true/false)
    135    * @param {Number} Tier - Tier
    136    */
    137   async Premium(ID, Toggle, Tier) {
    138     if (!ID) throw new Error("User ID?");
    139     if (!Toggle) throw new Error("Premium Toggle?");
    140     if (!Tier) throw new Error("Premium Feason?");
    141     const user = await u.findOne({ User: ID });
    142     if (!user) {
    143       const sus = new u({ User: ID });
    144       if (Toggle == "true") {
    145         user.Premium = true;
    146         user.Tier = Tier;
    147       } else {
    148         user.Premium = false;
    149         user.Tier = 0;
    150       }
    151       await sus.save().catch(error => console.log(error));
    152       cachegoose.clearCache();
    153       return { Tier };
    154     } else {
    155       if (Toggle == "true") {
    156         user.Premium = true;
    157         user.Tier = Tier;
    158       } else {
    159         user.Premium = false;
    160         user.Tier = 0;
    161       }
    162       await user.save().catch(error => console.log(error));
    163       cachegoose.clearCache();
    164       return { Tier };
    165     }
    166   },
    167   /**
    168    * @param {String} ID
    169    */
    170   async CreateGuild(ID) {
    171     await new g({ Guild: ID });
    172     return;
    173   },
    174   /**
    175    * @param {String} ID
    176    */
    177   async CreateBot(ID) {
    178     await new m({ Guild: ID });
    179     return;
    180   },
    181   /**
    182    * @param {String} ID - Guild ID
    183    */
    184   async DelGuild(ID) {
    185     await g.deleteMany({ Guild: ID });
    186     return;
    187   },
    188   /**
    189    * @param {String} ID - Guild ID
    190    * @param {String} Toggle - premium Toggle
    191    */
    192   async setPremium(ID, Toggle) {
    193     if (!ID) throw new Error("Please Provide a Guild ID");
    194     if (!Toggle) throw new Error("Please Provide a Toggle!");
    195     const guild = await g.findOne({ Guild: ID });
    196     if (!guild) {
    197       const newU = new g({ Guild: ID });
    198       if (Toggle == "true") {
    199         guild.Premium = true;
    200       } else {
    201         guild.Premium = false;
    202       }
    203       await newU.save().catch(error => console.log(error));
    204       return;
    205     } else if (Toggle == "true") {
    206       guild.Premium = true;
    207     } else {
    208       guild.Premium = false;
    209     }
    210     await guild.save().catch(error => console.log(error));
    211     cachegoose.clearCache();
    212     return;
    213   },
    214   /**
    215    * @param {String} User - User ID
    216    * @param {String} ID - Guild ID
    217    * @param {String} Method - Method
    218    */
    219   async pushGuild(User, ID, method) {
    220     if (!method) return new Error("Method?");
    221     u.findOne({ User: User }, async (err, data) => {
    222       if (err) throw err;
    223       if (!data) return new Error("User not found");
    224       if (method === "push") {
    225         await data.PremiumServers.push(ID);
    226         await data.save().catch(error => console.log(error));
    227         data.save();
    228       }
    229       if (method === "splice") {
    230         const index = data.PremiumServers.indexOf(ID);
    231         data.PremiumServers.splice(index, 1);
    232         data.save();
    233       }
    234       cachegoose.clearCache();
    235       return { User };
    236     });
    237   },
    238   /**
    239    * @param {String} ID - Guild ID
    240    * @param {String} Type - Type
    241    * @param {String} Name - Name
    242    */
    243   async disable(ID, Type, Name) {
    244     if (!Name) throw new Error("Name?");
    245     if (!Type) throw new Error("Type?");
    246     if (!ID) throw new Error("Guild ID?");
    247     if (Type === "category") {
    248       const db = await g.findOne({ Guild: ID });
    249       if (!db) {
    250         const newdoc = await new g({ Guild: ID });
    251         await newdoc.save().catch(error => console.log(error));
    252       }
    253       await db.Category.push(Name);
    254       await db.save().catch(e => console.log(e));
    255     }
    256     if (Type === "command") {
    257       const db = await g.findOne({ Guild: ID });
    258       if (!db) {
    259         const newdoc = await new g({ Guild: ID });
    260         await newdoc.save().catch(error => console.log(error));
    261       }
    262       await db.Commands.push(Name);
    263       await db.save().catch(e => console.log(e));
    264     }
    265     cachegoose.clearCache();
    266     return { Name };
    267   },
    268   /**
    269    * @param {String} ID - Guild ID
    270    * @param {String} Type - Type
    271    * @param {String} Name - Name
    272    */
    273   async enable(ID, Type, Name) {
    274     if (!ID) throw new Error("Guild ID?");
    275     if (!Name) throw new Error("Name?");
    276     if (!Type) throw new Error("Type?");
    277     if (Type === "category") {
    278       const db = await g.findOne({ Guild: ID });
    279       if (!db) {
    280         return false;
    281       }
    282       const index = db.Category.indexOf(Name.toLowerCase());
    283       await db.Category.splice(index, 1);
    284       await db.save().catch(e => console.log(e));
    285     }
    286     if (Type === "command") {
    287       const db = await g.findOne({ Guild: ID });
    288       if (!db) {
    289         return false;
    290       }
    291       const index = db.Commands.indexOf(Name);
    292       await db.Commands.splice(index, 1);
    293       await db.save().catch(e => console.log(e));
    294     }
    295     cachegoose.clearCache();
    296     return true;
    297   },
    298   /**
    299    * @param {String} ID - Guild ID
    300    * @param {String} Toggle - Level Toggle
    301    */
    302   async setTips(ID, Toggle) {
    303     if (!ID) throw new Error("Please Provide a Guild ID");
    304     if (!Toggle) throw new Error("Please Provide a Toggle!");
    305     const guild = await g.findOne({ Guild: ID });
    306     if (!guild) {
    307       const newU = new g({ Guild: ID });
    308       if (Toggle == "true") {
    309         guild.Tips = true;
    310       } else {
    311         guild.Tips = false;
    312       }
    313       await newU.save().catch(error => console.log(error));
    314       return;
    315     } else if (Toggle == "true") {
    316       guild.Tips = true;
    317     } else {
    318       guild.Tips = false;
    319     }
    320     await guild.save().catch(error => console.log(error));
    321     cachegoose.clearCache();
    322     return;
    323   },
    324 };