imdfgdfgdfgdfg

import os
import dupe

from discord import Intents

intents = discord.Intents.all()

bot = discord.Bot(Intents=intents)

TOKEN = 'MTIzODc0MDI5ODU4NzQ0MzIyMA.GVxPIf.6GqL4gl5pmnNfV7jWC7yqR0qGX2P23dbYQpMeI'

@bot.event
async def on_ready():
activity = discord.Game(name="/login")
await bot.change_presence(status=discord.Status.online, activity=activity)
print("Bot is online!")

class Emoji:
DENY = "<a:deny:1066326613014364160>"
CHECKMARK = "<a:checkmark:1066327424536686663>"
WINDOWS = "<:windows:1072644001661976656>"
LOADING = "<a:loading:1125550892859527309>"
WARN = "<:warning:1126156805106565190>"

class Color:
BLUE = 0x44a8fa
RED = 0xfa4459
YELLOW = 0xe8c800

DATABASE_CLUSTER = AsyncIOMotorClient("mongodb://localhost:27017")
db = DATABASE_CLUSTER["Gorb0"]
user_data = db["test"]

import aiohttp

###################################################### UTILS

async def FetchAvatarUser(user_id):

Account_Check = await user_data.find_one({"UserId": user_id})

token_ref = Account_Check['AccessToken']
accountid = Account_Check['AccountId']

headers = {"Authorization": f"Bearer {token_ref}"}

url = f"https://avatar-service-prod.identity.live.on.epicgames.com/v1/avatar/
fortnite/ids?accountIds={accountid}"
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=headers) as response:
 data = await response.json()
idavatar = data[0]['avatarId']
idavatar = idavatar.replace('ATHENACHARACTER:', '')

return
f"https://fortnite-api.com/images/cosmetics/br/{idavatar}/icon.png"

async def UpdateInfoAccount(user_id):

Account_Check = await user_data.find_one({"UserId": user_id})

accountid = Account_Check['AccountId']
deviceId = Account_Check['DeviceId']
secret = Account_Check['Secret']

session = aiohttp.ClientSession()

async with session.post("https://account-public-service-prod.ol.epicgames.com/

account/api/oauth/token",
data=f"grant_type=device_auth&account_id={accountid}&device_id={deviceId}&secret={s
ecret}",headers={'Content-Type': 'application/x-www-form-
urlencoded','Authorization': f'basic
MzQ0NmNkNzI2OTRjNGE0NDg1ZDgxYjc3YWRiYjIxNDE6OTIwOWQ0YTVlMjVhNDU3ZmI5YjA3NDg5ZDMxM2I
0MWE='}) as r:
if r.status == 200:
data = await r.json()
access_code, display_name, account_id = data['access_token'],
data['displayName'], data['account_id']

DataInsert = {
"UserId": user_id,
"AccessToken": access_code,
"AccountId": account_id,
"DisplayName": display_name,
"DeviceId": deviceId,
"Secret": secret
}

await user_data.update_one({"UserId": user_id}, {"$set": DataInsert})

await session.close()

def convert_seconds(seconds):
minutes = seconds // 60
remaining_seconds = seconds % 60
return minutes, remaining_seconds

###################################################################################
#############################################

#Embed Error(s)

UnknownError = discord.Embed(title=f"`❌ Authorization Error ❌`",description="New

authorization code needed. Logout and log back in with a new auth.",colour=
discord.Colour.brand_red())
NotLoggedIn = discord.Embed(description="**`❌ Not Logged In, Try /login
❌`**",colour=discord.Colour.brand_red())
YouCannotDoThis = discord.Embed(title= "`❌ Access Denied ❌`", description= "You
cannot do this command here for an unspecified
reason.",colour=discord.Colour.brand_red())
YouAreNotWhitelisted = discord.Embed(title= "`❌ Access Denied ❌`", description=
"**You Are not Whitelisted.**",colour=discord.Colour.brand_red())

#Reload

@bot.slash_command(name = "reload", description = "Reloads all commands.")

async def reload(ctx):
if ctx.author.id == 1199748817948512257:
embed1 = discord.Embed(title="Reloading...", color=0x0091ff)
embed2 = discord.Embed(title="Reloaded!", color=0x0091ff)
embed3 = discord.Embed(title=f"<a:yes:1082644643944091718> Reload complete,
{bot.user}!", color=0x0091ff)
await ctx.respond(embed=embed1)
bot.reload_extension
embed2 = discord.Embed(title=f"Reloaded!", color=0x0091ff)
await ctx.edit(embed=embed2)
await ctx.edit(embed=embed3)

else:
await ctx.respond("You are not a dev.", ephemeral=True)

#Login

class Login(discord.ui.Modal):
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)

self.add_item(discord.ui.InputText(label="Authorization Code."))

async def callback(self, interaction: discord.Interaction):

Data_Check = await user_data.find_one({"UserId": interaction.user.id})
if Data_Check is None:
try:

HeaderData = {
"Content-Type": f"application/x-www-form-urlencoded",
"Authorization": f"basic
MzQ0NmNkNzI2OTRjNGE0NDg1ZDgxYjc3YWRiYjIxNDE6OTIwOWQ0YTVlMjVhNDU3ZmI5YjA3NDg5ZDMxM2I
0MWE="
}
LoginData =
f"grant_type=authorization_code&code={self.children[0].value}"
LoginRequest = requests.post("https://account-public-service-
prod.ol.epicgames.com/account/api/oauth/token",headers=HeaderData,data=LoginData)

display_name = LoginRequest.json()['displayName']
accountId = LoginRequest.json()['account_id']
access_code = LoginRequest.json()['access_token']

headers = {'Authorization': f'Bearer {access_code}'}

response = requests.post(url=f'https://account-public-service-
prod.ol.epicgames.com/account/api/public/account/{accountId}/deviceAuth',
headers=headers)
device_id, secret = response.json()['deviceId'], response.json()
['secret']
 DataInsert = {
"UserId": interaction.user.id,
"AccessToken": access_code,
"AccountId": accountId,
"DisplayName": display_name,
"DeviceId": device_id,
"Secret": secret
}

await user_data.insert_one(DataInsert)

avatar = await FetchAvatarUser(interaction.user.id)

embed = discord.Embed(
title=f"You are now logged in as, `{display_name}`",
description="You have been added to our databases",
colour= discord.Colour.brand_green()
)
embed.set_thumbnail(url=avatar)

await interaction.response.send_message(embeds=[embed])

except:
await interaction.respond.send_message("Authorization Code
Expired.")

else:
embed = discord.Embed(title="Logged In Already",description=f"You are
already logged in as, `{Data_Check['DisplayName']}`",colour=discord.Colour.green())
await interaction.response.send_message(embeds=[embed])

class LoginGUI(discord.ui.View): # Create a class called MyView that subclasses

discord.ui.View

@discord.ui.button(label="Submit", style=discord.ButtonStyle.green)
async def button_callback(self, button, interaction: discord.Interaction):
modal = Login(title="Authorization Code")
await interaction.response.send_modal(modal)

@bot.slash_command(description="Login to your fortnite account.")

@commands.cooldown(1, 60, commands.BucketType.user)
async def login(ctx):
GUI = LoginGUI()
Add_Component = GUI.add_item(discord.ui.Button(label="Authorization Code",
style=discord.ButtonStyle.link, url="https://www.epicgames.com/id/api/redirect?
clientId=3446cd72694c4a4485d81b77adbb2141&responseType=code"))
embed = discord.Embed(
title="**`Login Process.`**",
description="To login follow these steps to login :\n\n`1.` Click The
Button Named Authorization Code\n\n`2.` Copy Your Authorization Code\n\n`3.` Paste
Your Authorization Code in Submit\n\nWrong Account or authorizationCode shows null
try [this](https://www.epicgames.com/id/login?redirectUrl=https%3A%2F
%2Fwww.epicgames.com%2Fid%2Fapi%2Fredirect%3FclientId
%3D3446cd72694c4a4485d81b77adbb2141%26responseType%3Dcode)",
 colour = discord.Colour.brand_green(),
)
await ctx.respond(embed=embed, view=GUI)

#Logout Command

@bot.slash_command(description="Log out of your fortnite account.")

@commands.cooldown(1, 60, commands.BucketType.user)
async def logout(ctx):
Data_Check = await user_data.find_one({"UserId": ctx.author.id})
if Data_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
await user_data.delete_one({"UserId": ctx.author.id})
embed = discord.Embed(title="Logged Out.",description=f"You are now logged
out!",colour=discord.Colour.green())
await ctx.respond(embed=embed)
await ctx.send("logout is good")
await ctx.send("dev by jdk")

@bot.slash_command(description="Leaves the party.")

@commands.cooldown(1, 60, commands.BucketType.user)
async def leave(ctx):
await ctx.defer()

Account_Check = await user_data.find_one({"UserId": ctx.author.id})

if Account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
token_ref = Account_Check['AccessToken']
accountid = Account_Check['AccountId']

display_name = Account_Check['DisplayName']

avatar = await FetchAvatarUser(ctx.author.id)

headers = {"Authorization": f"Bearer {token_ref}"}

url = f"https://party-service-prod.ol.epicgames.com/party/api/v1/Fortnite/
user/{accountid}"
response = requests.get(url, headers=headers)

party = response.json()['current']

if party == []:
embed = discord.Embed(title="Error", description="You are not in a
party.", color=discord.Color.red())
 await ctx.respond(embed=embed)
else:
party_id = party[0]['id']

url =
f"https://party-service-prod.ol.epicgames.com/party/api/v1/Fortnite/parties/
{party_id}/members/{accountid}"
response = requests.delete(url, headers=headers)

left = discord.Embed(title="Successfully Left!",

colour=discord.Colour.green())
left.set_thumbnail(url=avatar)
await ctx.respond(embed=left)

await ctx.response.send_message(embeds=[left], ephemeral=True)

@bot.slash_command(name = "premiumsurvivor" , description = "is magique")

async def imjdk(ctx):

# Charger le fichier JSON

file_path = 'eclair.json'

# Envoyer le fichier JSON

await ctx.send(file=discord.File(file_path))
await ctx.send("dev by jdk")

@bot.slash_command(name="mission", description="MISSION FILE")

async def jdkbot(ctx):
await ctx.defer()
account_Check = await user_data.find_one({"UserId": ctx.author.id})
if account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
await UpdateInfoAccount(ctx.author.id)

token_ref = account_Check['AccessToken']

headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token_ref,
"Accept-Language": "en"
}

info_url =
"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/world/info"
async with aiohttp.ClientSession() as session:
async with session.get(info_url, headers=headers) as info_response:
if info_response.status == 200:
data = await info_response.json()

replacements = [
{"searchText": "Blasted Badlands Venture Zone",
"replacementText": "Bot for mission fille dev by jdk"},

updated_data = replace_text(data, replacements)

current_datetime = datetime.now().strftime("%Y-%m-%d_
%H-%M-%S")
try:
with open(f'mission{current_datetime}.json', 'w',
encoding='utf-8') as file:
json.dump(updated_data, file,
ensure_ascii=False, indent=2)

await
ctx.respond(file=discord.File(f'mission{current_datetime}.json'))
except Exception as e:
await ctx.send(f"Erreur lors de l'écriture du
fichier : {str(e)}")
else:
await ctx.send("Voici le fichier JSON modifié :",
file=discord.File("modified_data.json"))

@bot.slash_command(name="friendcode", description="freid code")

async def friendcode(ctx, codetype):
await ctx.defer()
account_Check = await user_data.find_one({"UserId": ctx.author.id})
if account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
await UpdateInfoAccount(ctx.author.id)
token_ref = account_Check['AccessToken']
accountid = account_Check['AccountId']
display_name = account_Check['DisplayName']

url = f"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/
friendcodes/:{accountid}/{codetype}:"

headers = {'Authorization': f'Bearer '}

async with aiohttp.ClientSession() as session:
async with session.get(url, headers=headers) as response:
if response.status == 200:
json_data = await response.json()
with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp:
json.dump(json_data, temp)
file = discord.File(temp.name, filename='response.json')
await ctx.send(file=file)
else:
await ctx.sendf(f"La requête n'a pas abouti. Statut :
{response.status_code}")
print("eror")
def replace_text(json_object, replacements):
json_string = json.dumps(json_object)
for replacement in replacements:
search_text = replacement['searchText']
replacement_text = replacement['replacementText']
json_string = re.sub(search_text, replacement_text, json_string,
flags=re.IGNORECASE)
return json.loads(json_string)

def replace_text(json_object, replacements):

json_string = json.dumps(json_object)
 for replacement in replacements:
search_text = replacement['searchText']
replacement_text = replacement['replacementText']
json_string = re.sub(search_text, replacement_text, json_string,
flags=re.IGNORECASE)
return json.loads(json_string)

@bot.slash_command(name="devmission", description="devmission is crazzy")

async def jdkbot(ctx):
await ctx.defer()
account_Check = await user_data.find_one({"UserId": ctx.author.id})
if account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
await UpdateInfoAccount(ctx.author.id)

token_ref = account_Check['AccessToken']

headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token_ref,
"Accept-Language": "en"
}

info_url =
"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/world/info"
async with aiohttp.ClientSession() as session:
async with session.get(info_url, headers=headers) as info_response:
if info_response.status == 200:
data = await info_response.json()

replacements = [
{"searchText": "EventFlag", "replacementText":
"NotEventFlag"},
{"searchText": "activeQuestDefinitions",
"replacementText": "NotactiveQuestDefinitions"},
{"searchText": "requirements", "replacementText":
"Notrequirements"},
{"searchText":
"/Script/Engine.DataTable'/Game/Balance/DataTables/GameDifficultyGrowthBounds.GameD
ifficultyGrowthBounds'", "replacementText": "powerlevel"},
{"searchText": '"theaterType"\\s*:\\s*"Tutorial"',
"replacementText": '"theaterType": "Standard"'},
{"searchText": '"bHideLikeTestTheater":\\s*true',
"replacementText": '"bHideLikeTestTheater": false'},
{"searchText": '"missionGenerator"\\s*:\\s*"None"',
"replacementText": '"missionGenerator":
"/SaveTheWorld/World/MissionGens/MissionGen_T1_HT_EvacuateTheSurvivors.MissionGen_T
1_HT_EvacuateTheSurvivors_C"'},
{"searchText": '"Theater_Phoenix_Zone02"',
"replacementText": '"Theater_Start_Zone2"'},
{"searchText": '"Theater_Phoenix_Zone03"',
"replacementText": '"Theater_Start_Zone3"'},
{"searchText": '"Theater_Phoenix_Group_Zone03"',
"replacementText": '"Theater_Start_Group_Zone3"'},
{"searchText": '"Theater_Phoenix_Zone05"',
"replacementText": '"Theater_Start_Zone5"'},
{"searchText": '"Theater_Phoenix_Group_Zone05"',
"replacementText": '"Theater_Start_Group_Zone5"'},
{"searchText": '"Theater_Phoenix_Zone07"',
"replacementText": '"Theater_Normal_Zone2"'},
{"searchText": '"Theater_Phoenix_Group_Zone07"',
"replacementText": '"Theater_Normal_Group_Zone2"'},
{"searchText": '"Theater_Phoenix_Zone09"',
"replacementText": '"Theater_Normal_Zone4"'},
{"searchText": '"Theater_Phoenix_Group_Zone09"',
"replacementText": '"Theater_Normal_Group_Zone4"'},
{"searchText": '"Theater_Phoenix_Zone11"',
"replacementText": '"Theater_Hard_Zone1"'},
{"searchText": '"Theater_Phoenix_Group_Zone11"',
"replacementText": '"Theater_Hard_Group_Zone1"'},
{"searchText": '"Theater_Phoenix_Zone13"',
"replacementText": '"Theater_Hard_Zone3"'},
{"searchText": '"Theater_Phoenix_Group_Zone13"',
"replacementText": '"Theater_Hard_Group_Zone3"'},
{"searchText": '"Theater_Phoenix_Zone15"',
"replacementText": '"Theater_Hard_Zone5"'},
{"searchText": '"Theater_Phoenix_Group_Zone15"',
"replacementText": '"Theater_Hard_Group_Zone5"'},
{"searchText": '"Theater_Phoenix_Zone17"',
"replacementText": '"Theater_Nightmare_Zone2"'},
{"searchText": '"Theater_Phoenix_Group_Zone17"',
"replacementText": '"Theater_Nightmare_Group_Zone2"'},
{"searchText": '"Theater_Phoenix_Zone19"',
"replacementText": '"Theater_Nightmare_Zone4"'},
{"searchText": '"Theater_Phoenix_Group_Zone19"',
"replacementText": '"Theater_Nightmare_Group_Zone4"'},
{"searchText": '"Theater_Phoenix_Zone21"',
"replacementText": '"Theater_Endgame_Zone1"'},
{"searchText": '"Theater_Phoenix_Group_Zone21"',
"replacementText": '"Theater_Endgame_Group_Zone1"'},
{"searchText": '"Theater_Phoenix_Zone23"',
"replacementText": '"Theater_Endgame_Zone3"'},
{"searchText": '"Theater_Phoenix_Group_Zone23"',
"replacementText": '"Theater_Endgame_Group_Zone3"'},
{"searchText": '"Theater_Phoenix_Zone25"',
"replacementText": '"Theater_Endgame_Zone5"'},
{"searchText": '"Theater_Phoenix_Group_Zone25"',
"replacementText": '"Theater_Endgame_Group_Zone5"'},
{"searchText": '"theaterSlot"\\s*:\\s*2',
"replacementText": '"theaterSlot": 0'},
{"searchText": "HV3_01", "replacementText":
"Start_Zone4"},
{"searchText": "HV3_02", "replacementText":
"Start_Zone5"},
{"searchText": "HV3_03", "replacementText":
"Normal_Zone2"},
{"searchText": "HV3_04", "replacementText":
"Normal_Zone4"},
{"searchText": "HV3_05", "replacementText":
"Hard_Zone1"},
{"searchText": "HV3_06", "replacementText":
"Hard_Zone3"},
{"searchText": "HV3_07", "replacementText":
"Hard_Zone5"},
{"searchText": "HV3_08", "replacementText":
"Nightmare_Zone2"},
 {"searchText": "HV3_09", "replacementText":
"Nightmare_Zone4"},
{"searchText": "HV3_10", "replacementText":
"Endgame_Zone1"},
{"searchText": "HV3_11", "replacementText":
"Endgame_Zone3"},
{"searchText": "HV3_12", "replacementText":
"Endgame_Zone5"},
{"searchText": "_Starlight_Start_Zone2",
"replacementText": "_Start_Zone3"},
{"searchText": "_StarlightTimed_Start_Zone2",
"replacementText": "_Start_Zone3"},
{"searchText": "Theater_Starlight_",
"replacementText": "Theater_"},
{"searchText": "_StarlightTimed_",
"replacementText": "_"},
{"searchText": "Theater_Endless_",
"replacementText": "Theater_"},
{"searchText": "Theater_Mayday_Start_Zone5",
"replacementText": "Theater_Start_Zone5"},
{"searchText": "Theater_Mayday_Normal_Zone3",
"replacementText": "Theater_Normal_Zone3"},
{"searchText": "Theater_Mayday_Normal_Zone5",
"replacementText": "Theater_Normal_Zone5"},
{"searchText": "Theater_Mayday_Hard_Zone3",
"replacementText": "Theater_Hard_Zone3"},
{"searchText": "Theater_Mayday_Hard_Zone5",
"replacementText": "Theater_Hard_Zone5"},
{"searchText": "Theater_Mayday_Nightmare_Zone3",
"replacementText": "Theater_Nightmare_Zone3"},
{"searchText": "Theater_Mayday_Nightmare_Zone5",
"replacementText": "Theater_Nightmare_Zone5"},
{"searchText": "Theater_Mayday_Endgame_Zone5",
"replacementText": "Theater_Endgame_Zone5"},
]

updated_data = replace_text(data, replacements)

try:
with open('devmission.json', 'w', encoding='utf-8')
as file:
json.dump(updated_data, file,
ensure_ascii=False, indent=2)

await
ctx.respond(file=discord.File('devmission.json'))
except Exception as e:
await ctx.send(f"Erreur lors de l'écriture du
fichier : {str(e)}")
else:
await ctx.send("Voici le fichier JSON modifié :",
file=discord.File("modified_data.json"))

@bot.slash_command(name = "composemcp" , description = "compose your mcp

operation")
async def jdk (ctx,rout, operation,profile , jsonloadeur):
 await ctx.defer()
auth = await user_data.find_one({"UserId": ctx.author.id})
account_Check = await user_data.find_one({"UserId": ctx.author.id})
if account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:

await UpdateInfoAccount(ctx.author.id)

account_id = auth['AccountId']
token_ref = auth['AccessToken']
display_name = auth['DisplayName']

avatar = await FetchAvatarUser(ctx.author.id)

print("v")
headers = {
'Authorization': 'Bearer {0}'.format(token_ref),
'Content-Type': 'application/json'
}
url = f"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/
profile/{account_id}/{rout}/{operation}?profileId={profile}&rvm=-1"
payload = {
{jsonloadeur}
}
r = requests.post(url, data=json.dumps(payload), headers=headers)
print("v")

if r.status_code == 200:
embed = discord.Embed(description="You can drop an item now and pick it
up.", color=discord.Color.green())
embed.set_author(name=display_name, icon_url=avatar)
await ctx.respond(embed=embed)
data = r.json

current_datetime = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
try:
with open(f'cmpoperation{current_datetime}{display_name}.json', 'w',
encoding='utf-8') as file:
json.dump(data, file, ensure_ascii=False,
indent=2)

await ctx.respond(file=discord.File(f'cmpoperation{current_datetime}
{display_name}.json'))
except Exception as e:
await ctx.send(f"Erreur lors de l'écriture du
fichier : {str(e)}")

else:
await ctx.respond(f'Failed!\n{r.json()['errorMessage']}')
@bot.slash_command(name = "setupdupe", description = "dupe file")
async def couroubot(ctx):
await ctx.defer()
account_Check = await user_data.find_one({"UserId": ctx.author.id})
if account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
await UpdateInfoAccount(ctx.author.id)

token_ref = account_Check['AccessToken']

headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token_ref,
"Accept-Language": "en"
}

info_url =
"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/world/info"
async with aiohttp.ClientSession() as session:
async with session.get(info_url, headers=headers) as info_response:
if info_response.status == 200:
data = await info_response.json()

for item in data:

if "tileType" in item and item["tileType"] ==
"Outpost":
item["tileType"] = "AlwaysActive"

current_datetime = datetime.now().strftime("%Y-%m-%d_
%H-%M-%S")
with open(f'dupfile{current_datetime}.json', 'w') as
file:
json.dump(data, file, indent=4)

await
ctx.respond(file=discord.File(f'dupfile{current_datetime}.json'))

@bot.slash_command(name="ghost-equip", description="Ghost equip")

@commands.cooldown(1, 60, commands.BucketType.user)
async def ghostequip(ctx, skin):
await ctx.defer()
account_Check = await user_data.find_one({"UserId": ctx.author.id})

if account_Check is None:
await ctx.respond(embed=NotLoggedIn)

else:
await UpdateInfoAccount(ctx.author.id)

token_ref = account_Check['AccessToken']
accountid = account_Check['AccountId']
display_name = account_Check['DisplayName']

url = f'https://fortnite-api.com/v2/cosmetics/br/search?name={skin}'
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
if response.status != 200:

embed = discord.Embed(description=f'The {skin} skin does not

exist try again!', color=discord.Color.red())
embed.set_author(name=display_name, icon_url=ctx.author.avatar)
await ctx.respond(embed=embed)

else:

data = await response.json()

id_item = data['data']['id']
name_item = data['data']['name']

headers = {
"Authorization": f"Bearer {token_ref}"
}
url =
f"https://party-service-prod.ol.epicgames.com/party/api/v1/Fortnite/user/
{accountid}"

async with aiohttp.ClientSession() as session:

async with session.get(url, headers=headers) as response:
if response.status == 200:

data = await response.json()

currrent = data['current']

if currrent == []:
embed = discord.Embed(description='You are not
in a game.', color=discord.Color.red())
embed.set_author(name=display_name,
icon_url=ctx.author.avatar)
await ctx.respond(embed=embed)

else:
partyId = data['current'][0]['id']

data = {
"Default:AthenaCosmeticLoadout_j":
json.dumps({
"AthenaCosmeticLoadout": {
 "characterDef":
f"/Game/Athena/Items/Cosmetics/Characters/{id_item}.{id_item}"
}})}

body = {
'delete': [],
'revision': 1,
'update': data
}

url = f"https://party-service-
prod.ol.epicgames.com/party/api/v1/Fortnite/parties/{partyId}/members/{accountid}/
meta"

try:

response = requests.patch(url=url,
headers=headers, json=body)
if response.status_code == 200:
embed = discord.Embed(title="Ghost
Equip", description=f"Succesfully equipped **{name_item}**",
color=discord.Color.green())

embed.set_thumbnail(url=f'https://fortnite-api.com/images/cosmetics/br/
{name_item}/icon.png')
await ctx.respond(embed=embed)
else:

titolo = response.json()['errorCode']
if titolo ==
'errors.com.epicgames.social.party.stale_revision':

mexvars = response.json()
['messageVars']
revision = max(mexvars)

body = {
'delete': [],
'revision': revision,
'update': data
}

url = f"https://party-service-
prod.ol.epicgames.com/party/api/v1/Fortnite/parties/{partyId}/members/{accountid}/
meta"
response = requests.patch(url=url,
headers=headers, json=body)
embed = discord.Embed(title="Ghost
Equip", description=f"Succesfully equipped **{name_item}**",
color=discord.Color.green())

embed.set_thumbnail(url=f'https://fortnite-api.com/images/cosmetics/br/{id_item}/
icon.png')

await ctx.respond(embed=embed)

except requests.exceptions.JSONDecodeError:
 embed = discord.Embed(title="Ghost Equip",
description=f"Succesfully equipped **{name_item}**", color=discord.Color.green())
embed.set_thumbnail(url=f'https://fortnite-
api.com/images/cosmetics/br/{id_item}/icon.png')
await ctx.respond(embed=embed)

#Friends menu

class Panel2(discord.ui.View):

@discord.ui.button(label="Clear All", style=discord.ButtonStyle.primary)

async def button_callback2(self, button, interaction: discord.Interaction):

await interaction.response.defer(ephemeral=True)

Account_Check = await user_data.find_one({"UserId": interaction.user.id})

await UpdateInfoAccount(interaction.user.id)

token_ref = Account_Check['AccessToken']
accountid = Account_Check['AccountId']
display_name = Account_Check['DisplayName']

avatar = await FetchAvatarUser(interaction.user.id)

headers = {
"Authorization": f"Bearer {token_ref}"
}
requests.delete(f"https://friends-public-service-prod.ol.epicgames.com/
friends/api/v1/{accountid}/friends", headers=headers)

cembed = discord.Embed(
title="Successful!",
description=f"Cleared All Friends of {display_name}",
colour=discord.Color.green()
)
await interaction.followup.send(embeds=[cembed])
cembed.set_thumbnail(url=avatar)

@discord.ui.button(label="Unblock All", style=discord.ButtonStyle.primary)

async def button_callback3(self, button, interaction: discord.Interaction):
Account_Check = await user_data.find_one({"UserId": interaction.user.id})
await UpdateInfoAccount(interaction.user.id)

token_ref = Account_Check['AccessToken']
accountid = Account_Check['AccountId']
display_name = Account_Check['DisplayName']

avatar = await FetchAvatarUser(interaction.user.id)

headers = {
"Authorization": f"Bearer {token_ref}"
}
 deletereq = requests.delete(f"https://friends-public-service-
prod.ol.epicgames.com/friends/api/public/blocklist/{accountid}", headers=headers)

bembed = discord.Embed(
title="Successful!",
description=f"Unblocked All Blocked Users from {display_name}!",
colour=discord.Color.green()
)
await interaction.response.send_message(embeds=[bembed], ephemeral=True)
bembed.set_thumbnail(url=avatar)

@bot.slash_command(description="Displays the friends menu.")

@commands.cooldown(1, 60, commands.BucketType.user)
async def friends(ctx):
await ctx.defer()

Account_Check = await user_data.find_one({"UserId": ctx.author.id})

if Account_Check is None:
await ctx.respond(embed=NotLoggedIn)
else:
GUI = Panel2()
embed = discord.Embed(
title="Friends List",
description="Click Whichever Button You Want to Do Certain Actions on
the Account Logged in!\n\n[Join Our Support Server For Help]()",
colour=discord.Colour.blue(),
)
await ctx.respond(embed=embed, view=GUI, ephemeral=False)

@bot.slash_command(name="premiumbase",description="crazy glitche")
async def premiumbase(ctx):
await ctx.send(f"PATCH")

from dateutil import parser

@commands.cooldown(1, 60, commands.BucketType.user)

async def info(ctx):
await ctx.defer()

auth = await user_data.find_one({"UserId": ctx.author.id})

if auth is None:
embed = discord.Embed(title=f"Failed", description="You are not logged into
the bot!\nTo log in, run the /login")
embed.set_author(name=ctx.author.name, icon_url=ctx.author.avatar)
embed.set_footer(text="Bot by JDK ")
await ctx.respond(embed=embed)

else:
await UpdateInfoAccount(ctx.author.id)
 accountId = auth['AccountId']
accessToken = auth['AccessToken']

url = f"https://account-public-service-prod.ol.epicgames.com/account/api/
public/account/{accountId}"
headers = {
"Authorization": f"Bearer {accessToken}"
}

response = requests.get(url, headers=headers)

data = response.json()

accountId = data['id']
displayName = data['displayName']
email = data['email']
country = data['country']
tfaEnabled = data['tfaEnabled']
failedLoginAttempts = data['failedLoginAttempts']
emailVerified = data['emailVerified']
canUpdateDisplayName = data['canUpdateDisplayName']
lastDisplayNameChange = data['lastDisplayNameChange']
numberOfDisplayNameChanges = data['numberOfDisplayNameChanges']
lastLogin = data['lastLogin']
preferredLanguage = data['preferredLanguage']

lastDisplayNameChange = parser.parse(lastDisplayNameChange).strftime("%Y-
%m-%d %H:%M:%S")
lastLogin = parser.parse(lastLogin).strftime("%Y-%m-%d %H:%M:%S")

embed = discord.Embed(color=Color.YELLOW)
embed.add_field(name="Account Externals:", value=f">>> :id: `{accountId}`\
n`{displayName}`", inline=True)
embed.add_field(name="Email:", value=f"> {email} {Emoji.CHECKMARK if
emailVerified == True else Emoji.DENY}", inline=False)
embed.add_field(name="Display Name:", value=f">>> Current: {displayName}\
nLast changed: {lastDisplayNameChange}\nChanges: {numberOfDisplayNameChanges}\
nUpdatable: {Emoji.CHECKMARK if canUpdateDisplayName == True else Emoji.DENY}",
inline=False)
embed.add_field(name="Login:", value=f">>> Failed Login Attempts:
{failedLoginAttempts}\nLast Login: {lastLogin}\nTwo Factor Authentication:
{Emoji.CHECKMARK if tfaEnabled == True else Emoji.DENY}", inline=True)
embed.add_field(name="Country:", value=f"> {country}", inline=False)
embed.add_field(name="Preferred Language:", value=f"> {preferredLanguage}",
inline=False)
embed.set_footer(text="Bot by pepe")
await ctx.respond(embed=embed)

async def FindPlayer(accountId, accessToken):

url = f"https://fortnite-public-service-prod11.ol.epicgames.com/fortnite/api/
matchmaking/session/findPlayer/{accountId}"
headers = {
"Authorization": "Bearer " + accessToken,
"Content-Type": "application/json"
}
 async with aiohttp.ClientSession() as session:
async with session.get(url, headers=headers) as response:

data = await response.json()

if data == []:
return None
return data

@bot.slash_command(
name="dupe",
description="Magic..."
)
async def dupe(ctx):

await ctx.defer()

auth = await user_data.find_one({"UserId": ctx.author.id})

if auth is None:
embed = discord.Embed(title=f"Failed", description="You are not logged into
the bot!\nTo log in, run the /login")
embed.set_author(name=ctx.author.name, icon_url=ctx.author.avatar)
embed.set_footer(text="Bot by JDK ")
await ctx.respond(embed=embed)

else:
await UpdateInfoAccount(ctx.author.id)

account_id = auth['AccountId']
token_ref = auth['AccessToken']
display_name = auth['DisplayName']

avatar = await FetchAvatarUser(ctx.author.id)

match = await FindPlayer(account_id, token_ref)

if not match:
embed = discord.Embed(description="You must be inside a storm shield.",
color=Color.RED)
return await ctx.respond(embed=embed)
print("v")
headers = {
'Authorization': 'Bearer {0}'.format(token_ref),
'Content-Type': 'application/json'
}
url = f"https://fngw-mcp-gc-livefn.ol.epicgames.com/fortnite/api/game/v2/
profile/{account_id}/client/ModifyQuickbar?profileId=theater0&rvm=-1"
payload = {
"primaryQuickbarChoices": ["", "", ""],
"secondaryQuickbarChoice": ""
}

r = requests.post(url, data=json.dumps(payload), headers=headers)

print("v")
 if r.status_code == 200:
embed = discord.Embed(description="You can drop an item now and pick it
up.", color=discord.Color.green())
embed.set_author(name=display_name, icon_url=avatar)
await ctx.respond(embed=embed)

else:
await ctx.respond(f'Failed!\n{r.json()['errorMessage']}')

@bot.event
async def on_application_command_error(ctx, error):
if isinstance(error, commands.CommandOnCooldown):
seconds = convert_seconds(error.retry_after)
embed = discord.Embed(title="⛔ Error ⛔", description=f"You are on cooldown
for `{round(seconds, 1)}` seconds.",color=discord.Color.brand_red())
await ctx.respond(embed=embed)
else:
pass

bot.run(TOKEN)