├── config.json
├── package.json
├── models
    └── rolBackup.js
├── README.md
└── main.js


/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 | "WhiteList":["WhitelistMember","WhitelistRole"],
 3 | "Bots":["WhitelistBots"],
 4 | "ServerID":"ServerID",
 5 | "GuardActivity":"Status ❤️",
 6 | "DatabaseLogName":"database-log",
 7 | "mongourl":"MongoURL",
 8 | "Dagıtıcılar": [
 9 |     "DatabaseBots",
10 |     "DatabaseBots"
11 | ],
12 | "DatabaseToken":"DatabaseBot",
13 | "botPrefix":"Prefix",
14 | "BotOwner":"Owner"
15 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "angels",
 3 |   "version": "1.0.0",
 4 |   "description": "Discord Banker Guard/Backup Bot",
 5 |   "main": "main.js",
 6 |   "scripts": {
 7 |     "test": "node main.js"
 8 |   },
 9 |   "keywords": [
10 |     "Banker"
11 |   ],
12 |   "author": "Banker",
13 |   "license": "MIT",
14 |   "dependencies": {
15 |     "discord.js": "^12.5.3",
16 |     "moment": "^2.29.2",
17 |     "mongoose": "^6.2.10"
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/models/rolBackup.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose');
 2 | 
 3 | const role = mongoose.Schema({
 4 |   _id: mongoose.Schema.Types.ObjectId,
 5 |   guildID: String,
 6 |   roleID: String,
 7 |   name: String,
 8 |   color: String,
 9 |   hoist: Boolean,
10 |   position: Number,
11 |   permissions: Number,
12 |   mentionable: Boolean,
13 |   time: Number,
14 |   members: Array,
15 |   channelOverwrites: Array
16 | });
17 | 
18 | module.exports = mongoose.model("rolBackup", role);


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Diğer Botlarım
 2 | https://github.com/Bankerr/discord-usertoken-backup
 3 | 
 4 | https://github.com/Bankerr/discord-banker-guardbot Bakmaya ne dersin
 5 | 
 6 | # Bot Nasıl Çalışır
 7 | 
 8 | config dolduruyon
 9 | 
10 | npm i yapiyon modülleri indiriyon sonra node . yaziyon baslatiyon
11 | 
12 | **Yardım isteyenler için discord.gg/serendia gelebilirsiniz**
13 | # Botun Özellikleri
14 | 
15 | ❯ Sunucuda Rol Silince Rolü Geri Açıp Senin Belirttiğin Bot'lar İle Roller'i Dağıtıyor Ve Kanal İzinlerini Ayarlıyor!
16 | 
17 | ❯ Piyasadaki Birçok Backup Botundan Daha Hızlı Rol Dağıtır 
18 | 
19 | (Çok Özellik Yok Gibi Gözükebilir Ama Bu RoleBackup Botu Guard Bot Değil Bu)
20 | 
21 | <img src="https://komarev.com/ghpvc/?username=discord-roleguard-backup-main&label=Ziyaretçi%20Sayısı&color=da004e" alt="Bankerr/discord-roleguard-backup/edit/main/" /> <p>
22 | 


--------------------------------------------------------------------------------
/main.js:
--------------------------------------------------------------------------------
  1 | const { MessageEmbed } = require('discord.js');
  2 | const moment = require('moment');
  3 | moment.locale('tr');
  4 | const whitelist = require('./config.json');
  5 | const config = require('./config.json');
  6 | const backup = require("./models/rolBackup.js");
  7 | const mongoose = require("mongoose");
  8 | const Bots = global.Bots = [];
  9 | const { Client } = require("discord.js");
 10 | const client = new Client();    
 11 | 
 12 | 
 13 | client.on("ready", async () => {
 14 |   setRoleBackup();
 15 |   setInterval(() => {
 16 |     setRoleBackup();
 17 |   }, 1000*60*60*1);
 18 | });
 19 | 
 20 | mongoose.connect(config.mongourl, { useNewUrlParser: true, useUnifiedTopology: true }).catch(err =>  console.log('[Banker] Database bağlanamadı!!'));
 21 | 
 22 |   let Tokens = config.Dagıtıcılar;
 23 |   
 24 |   Tokens.forEach(token => {
 25 |       let bot = new Client();
 26 |   
 27 | bot.on("ready", () => {
 28 | bot.user.setPresence({ activity: { name: `${config.GuardActivity}` }, status: "dnd" });
 29 |   console.log(`[Banker] ${bot.user.tag} ~ Dağıtıcı Aktif!`);
 30 |   bot.Busy = false;
 31 |   bot.Uj = 0;
 32 |   Bots.push(bot);
 33 | 
 34 | 
 35 |       })
 36 | bot.login(token).then(e => {
 37 | }).catch(e => {
 38 |   console.error(`[Banker] ${token.substring(Math.floor(token.length / 2))} giriş yapamadı.`);
 39 |       });
 40 |   });
 41 |   client.on("ready", () => {
 42 |     client.user.setPresence({ activity: { name: `${config.GuardActivity}` }, status: "dnd" });
 43 |   });
 44 | client.on("message", async message => {
 45 |     let embed = new MessageEmbed().setColor("BLACK").setTimestamp().setFooter(config.GuardActivity)
 46 |     if (message.author.bot || !message.guild || !message.content.toLowerCase().startsWith(config.botPrefix)) return;
 47 |     if (message.author.id !== config.BotOwner) return;
 48 |     let args = message.content.split(' ').slice(1);
 49 |     let command = message.content.split(' ')[0].slice(config.botPrefix.length);
 50 |       
 51 |     if(command === "rolkur" && message.author.id === config.BotOwner) {
 52 |       if (!args[0] || isNaN(args[0])) return message.channel.send("Geçerli bir rol ID'si belirtmelisin!");
 53 | 
 54 | backup.findOne({guildID: config.ServerID, roleID: args[0]}, async (err, roleData) => {
 55 | if(!roleData) return message.channel.send(`Belirtiğiniz ID li rolü veri tabanımda bulamadım!`)
 56 | const newRole = await message.guild.roles.create({
 57 | name: roleData.name,
 58 | color: roleData.color,
 59 | hoist: roleData.hoist,
 60 | mentionable: roleData.mentionable,
 61 | permissions: roleData.permissions,
 62 | position: roleData.rawPosition
 63 | })
 64 | await message.channel.send(embed.addField(`Başarılı bir Şekilde \`${newRole.name}\` Rolünü Kurdum : `,`Dağıtım İçin:  \`\`\`${config.botPrefix}backup ${args[0]} <@&${newRole.id}>\`\`\``));
 65 |       })
 66 |     }
 67 |     if(command === "backup" && message.author.id === config.BotOwner) {
 68 |       let rol = message.mentions.roles.first();
 69 |       if (!args[0] || isNaN(args[0])) return message.channel.send("Geçerli bir rol ID'si belirtmelisin!");
 70 |       let data = await backup.findOne({guildID: config.ServerID, roleID: args[0]})
 71 |       if(!data) return message.channel.send(`Kurmaya çalıştığınız Rol ID bulunamadı.`)
 72 | 
 73 |       setTimeout(async() => {
 74 | let kanalPermVeri = data.channelOverwrites;
 75 | if (kanalPermVeri) kanalPermVeri.forEach(async(perm, index) => {
 76 |   let kanal = message.guild.channels.cache.get(perm.id);
 77 |   if (!kanal) return;
 78 |   setTimeout(async() => {
 79 | let yeniKanalPermVeri = {};
 80 | perm.allow.forEach(async(p) => {
 81 | yeniKanalPermVeri[p] = true;
 82 | });
 83 | perm.deny.forEach(async(p) => {
 84 | yeniKanalPermVeri[p] = false;
 85 | });
 86 | await kanal.createOverwrite(rol, yeniKanalPermVeri).catch(err => console.log(`Kanal İzinleri Ayarlarken Bir Hata Oluştu Hata: ${err}`));
 87 |   }, index*500);
 88 | });
 89 |       }, 500);
 90 | let length = data.members.length;
 91 | if(length <= 0) return console.log(`[Backup] [${rol.name} ${rol.id}] Olayında kayıtlı üye olmadığından dolayı rol dağıtımı gerçekleştirmedim. `);
 92 | let availableBots = Bots.filter(e => !e.Busy);
 93 | if(availableBots.length <= 0) availableBots = Bots.sort((x,y) => y.Uj - x.Uj).slice(0, Math.round(length / Bots.length));
 94 | let perAnyBotMembers = Math.floor(length / availableBots.length);
 95 | if(perAnyBotMembers < 1) perAnyBotMembers = 1;
 96 | for (let index = 0; index < availableBots.length; index++) {
 97 | const bot = availableBots[index];
 98 | let ids = data.members.slice(index * perAnyBotMembers, (index + 1) * perAnyBotMembers);
 99 | if(ids.length <= 0) {processBot(bot, false, -perAnyBotMembers); break;}
100 | let guild = bot.guilds.cache.get(config.ServerID);
101 |    await message.channel.send(`[Backup] - Başarılı bir şekilde kurulum başladı roller dağıtılıp odalara ekleniyor.`)
102 | ids.every(async id => {
103 | let member = guild.member(id);
104 | if(!member){
105 |   return true;
106 | }
107 | setTimeout(async() => {
108 | if(rol.delete) return console.log(`[Backup] (${rol.id} - ${rol.name}) Olayında Rol Silinindiği İçin Dağıtımı Durdurdum!`);
109 | if(member.roles.cache.has(rol.id)) return;
110 | await member.roles.add(rol.id).catch(err => console.log(`Rol dağıtımda rol vermede hata oluştu.`))
111 | }, index*100);
112 | });
113 | processBot(bot, false, -perAnyBotMembers);
114 | }}
115 | if(command === "yedekle") {
116 |       backup.findOne({guildID: config.ServerID, roleID: role.id}, async (err, savedRole) => {
117 |         if (!savedRole) {
118 |           let newRoleSchema = new backup({
119 |             _id: new mongoose.Types.ObjectId(),
120 |             guildID: config.ServerID,
121 |             roleID: role.id,
122 |             name: role.name,
123 |             color: role.hexColor,
124 |             hoist: role.hoist,
125 |             position: role.rawPosition,
126 |             permissions: role.permissions,
127 |             mentionable: role.mentionable,
128 |             time: Date.now(),
129 |             members: role.members.map(m => m.id),
130 |             channelOverwrites: roleChannelOverwrites
131 |           });
132 |           newRoleSchema.save();
133 |         } else {
134 |           savedRole.name = role.name;
135 |           savedRole.color = role.hexColor;
136 |           savedRole.hoist = role.hoist;
137 |           savedRole.position = role.rawPosition;
138 |           savedRole.permissions = role.permissions;
139 |           savedRole.mentionable = role.mentionable;
140 |           savedRole.time = Date.now();
141 |           savedRole.members = role.members.map(m => m.id);
142 |           savedRole.channelOverwrites = roleChannelOverwrites;
143 |           savedRole.save();
144 |         };
145 |       });
146 | 
147 | await message.channel.send("Rol veri tabanı kayıt edildi.")
148 | console.log("Rol verileri başarı ile kayıt edildi.")
149 | };
150 | });
151 |   
152 | client.on("roleDelete", async (role) => {
153 |     let logs = await role.guild.fetchAuditLogs({limit: 5,type:"ROLE_DELETE"}).then(e => e.entries.sort((x, y) => y.createdTimestamp - x.createdTimestamp));
154 |     let log = logs.find(e => ((Date.now() - e.createdTimestamp) / (1000)) < 5);
155 |     if(!log || (log && safe(log.executor.id))) return;
156 |     danger = true;
157 | let newRole = await role.guild.roles.create({   
158 |  data:{
159 | name: role.name,
160 | color: role.color,
161 | hoist: role.hoist,
162 | mentionable: role.mentionable,
163 | permissions: role.permissions,
164 | position: role.rawPosition
165 | }
166 |     }).catch();
167 |     let data = await backup.findOne({guildID: config.ServerID, roleID: role.id})
168 |     let rolkanal = client.channels.cache.find(e => e.name === config.DatabaseLogName)
169 |      await rolkanal.send(`${role.name} \`${role.id}\` Rolü Silindi Rolde Kayıtlı Veri Olmadığı İçin Dağıtım Yapamadım!`)
170 |       if(!data) return console.log(`[Banker] [${role.id}] olayında kayıtlı veri olmadığı için dağıtımı yapamadım`)
171 |     
172 | setTimeout(() => {
173 | let kanalPermVeri = data.channelOverwrites;
174 | if (kanalPermVeri) kanalPermVeri.forEach(async (perm, index) => {
175 |   let guild = client.guilds.cache.get(config.ServerID)
176 |   let kanal = guild.channels.cache.get(perm.id);
177 |   if (!kanal) return;
178 |   setTimeout(async () => {
179 | let yeniKanalPermVeri = {};
180 | perm.allow.forEach(async (p) => {
181 | yeniKanalPermVeri[p] = true;
182 | });
183 | perm.deny.forEach(async (p) => {
184 | yeniKanalPermVeri[p] = false;
185 | });
186 |    await kanal.createOverwrite(newRole, yeniKanalPermVeri).catch(console.error);
187 |   }, index*1000);
188 | });
189 |       }, 1000);
190 | let length = data.members.length;
191 | if(length <= 0) return console.log(`[Banker] [${role.id}] Olayında kayıtlı üye olmadığından dolayı rol dağıtımı gerçekleştirmedim. `);
192 | let availableBots = Bots.filter(e => !e.Busy);
193 | if(availableBots.length <= 0) availableBots = Bots.sort((x,y) => y.Uj - x.Uj).slice(0, Math.round(length / Bots.length));
194 | let perAnyBotMembers = Math.floor(length / availableBots.length);
195 | if(perAnyBotMembers < 1) perAnyBotMembers = 1;
196 | for (let index = 0; index < availableBots.length; index++) {
197 | const bot = availableBots[index];
198 | let ids = data.members.slice(index * perAnyBotMembers, (index + 1) * perAnyBotMembers);
199 | if(ids.length <= 0) {processBot(bot, false, -perAnyBotMembers); break;}
200 | console.log(`[Banker] [${role.id}] olayından sonra - Başarılı bir şekilde kurulum başladı roller dağıtılıp odalara ekleniyor.`)
201 | let guild = bot.guilds.cache.get(config.ServerID);
202 | ids.every(async id => {
203 | let member = guild.member(id);
204 | if(!member){
205 |   return true;
206 | }
207 | setTimeout(async() => {
208 | if(member.roles.cache.has(newRole.id)) return;
209 | await member.roles.add(newRole.id).catch(err => console.log(`[Banker] ${member} (${member.id}) Adlı kullanıcıya rol veremedim.`))
210 | }, index*500);
211 | 
212 | });
213 | processBot(bot, false, -perAnyBotMembers);
214 |   
215 |   }
216 |   let sa = client.channels.cache.find(e => e.name === config.DatabaseLogName)
217 |    await sa.send(`${log.executor} \`(${log.executor.id})\` Tarafından **${role.name}** \`(${role.id})\` Rol Silindi Rol Üyelerine Dağıtılıp Kanal İzinlerine Ekliyorum!`);   
218 | }
219 | )
220 | function processBot(bot, busy, job, equal = false){
221 |     bot.Busy = busy;
222 |     if(equal) bot.Uj = job;
223 |     else bot.Uj += job;
224 | 
225 |     let index = Bots.findIndex(e => e.user.id == bot.user.id);
226 |     Bots[index] = bot;
227 | }
228 | 
229 | function safe(id){
230 |     if(id == client.user.id || Bots.some(e => e.user.id == id) || whitelist.WhiteList.includes(id)|| config.BotOwner.includes(id) ||config.Bots.includes(id)) return true;
231 |     return false;
232 | }
233 | 
234 | 
235 | function setRoleBackup() {
236 |   let guild = client.guilds.cache.get(config.ServerID);
237 |   if (guild) {
238 |     guild.roles.cache.filter(r => r.name !== "@everyone" && !r.managed).forEach(role => {
239 |       let roleChannelOverwrites = [];
240 |       guild.channels.cache.filter(c => c.permissionOverwrites.has(role.id)).forEach(c => {
241 | let channelPerm = c.permissionOverwrites.get(role.id);
242 | let pushlanacak = { id: c.id, allow: channelPerm.allow.toArray(), deny: channelPerm.deny.toArray() };
243 | roleChannelOverwrites.push(pushlanacak);
244 |       });
245 | 
246 |       backup.findOne({guildID: config.ServerID, roleID: role.id}, async (err, savedRole) => {
247 | if (!savedRole) {
248 |   let newRoleSchema = new backup({
249 | _id: new mongoose.Types.ObjectId(),
250 | guildID: config.ServerID,
251 | roleID: role.id,
252 | name: role.name,
253 | color: role.hexColor,
254 | hoist: role.hoist,
255 | position: role.rawPosition,
256 | permissions: role.permissions,
257 | mentionable: role.mentionable,
258 | time: Date.now(),
259 | members: role.members.map(m => m.id),
260 | channelOverwrites: roleChannelOverwrites
261 |   });
262 |   newRoleSchema.save();
263 | } else {
264 |   savedRole.name = role.name;
265 |   savedRole.color = role.hexColor;
266 |   savedRole.hoist = role.hoist;
267 |   savedRole.position = role.rawPosition;
268 |   savedRole.permissions = role.permissions;
269 |   savedRole.mentionable = role.mentionable;
270 |   savedRole.time = Date.now();
271 |   savedRole.members = role.members.map(m => m.id);
272 |   savedRole.channelOverwrites = roleChannelOverwrites;
273 |   savedRole.save();
274 | };
275 |       });
276 |     });
277 | 
278 |     backup.find({guildID: config.ServerID}).sort().exec((err, roles) => {
279 |       roles.filter(r => !guild.roles.cache.has(r.roleID) && Date.now()-r.time > 1000*60*60*24*3).forEach(r => {
280 | backup.findOneAndDelete({roleID: r.roleID});
281 |       });
282 |     });
283 |     console.log(`[Banker] Rol veri tabanı düzenlendi! [${moment(Date.now()).format("HH:mm DD MM YYYY")}]`);
284 |   };
285 | };
286 |   
287 | client.login(config.DatabaseToken).catch(err => console.log(`[Banker] Backup Ana Bot aktif olamadı!`))
288 | 


--------------------------------------------------------------------------------