Mobile versionIch erstelle einen Bot für meinen Discord-Kanal, aber nach einiger Zeit schalte replit alles aus ;/
Es muss rund um die Uhr eingeschaltet sein – wie kann ich es bekommen?
Mein Code:
Code: Select all
from keep_alive import keep_alive
import discord
from discord.ext import commands
import asyncio
import os
import firebase_admin
from firebase_admin import credentials, firestore
# Firebase configuration
cred = credentials.Certificate("serviceAccountKey.json")
firebase_admin.initialize_app(cred)
db = firestore.client()
def save_user_points(discord_id, points):
try:
user_ref = db.collection("users").document(discord_id)
user_ref.set({"points": points}, merge=True)
print(f"✅ Points saved for user {discord_id}: {points}")
except Exception as e:
print(f"❌ Error saving points for user {discord_id}: {e}")
def get_user_points(discord_id):
try:
user_ref = db.collection("users").document(discord_id)
doc = user_ref.get()
if doc.exists:
return doc.to_dict().get("points", 0)
except Exception as e:
print(f"❌ Error getting points for user {discord_id}: {e}")
return 0
keep_alive()
intents = discord.Intents.default()
intents.members = True
intents.message_content = True
bot = commands.Bot(command_prefix="!", intents=intents)
class BotState:
def __init__(self):
self.groups = [] # List of already formed groups (current session).
self.queue = [] # Queue for users who want to be in the next review group.
self.category_name = "Feedback and Reviews"
# Structure: pending_reviews[channel_id] = {
# (reviewer_id, reviewee_id): {
# "reviewer_done": bool,
# "reviewee_confirmed": bool,
# "mod_confirmed": bool,
# "points_given": bool
# },
# ...
# }
self.pending_reviews = {}
state = BotState()
@bot.event
async def on_ready():
print(f"Bot is ready and logged in as {bot.user}")
@bot.event
async def on_message(message):
try:
if message.author == bot.user:
return
print(f"Message content: '{message.content}' | Message type: {message.type}")
if message.content.strip() == '':
print(f"⚠ Empty message from {message.author}. Forcing command processing.")
await bot.process_commands(message)
return
await bot.process_commands(message)
except Exception as e:
print(f"Error in on_message: {e}")
@bot.command()
async def test_firebase(ctx):
try:
test_ref = db.collection("test").document("test_doc")
test_ref.set({"message": "Hello from Discord bot!"})
await ctx.send("✅ Firebase is working correctly! Check Firestore console.")
except Exception as e:
await ctx.send(f"❌ Firebase error: {e}")
@bot.command()
async def test_points(ctx):
discord_id = str(ctx.author.id)
current_points = get_user_points(discord_id)
await ctx.send(f"Your current points: {current_points}")
new_points = current_points + 10
save_user_points(discord_id, new_points)
await ctx.send(f"10 points added! Your new total: {new_points}")
@bot.command()
async def join(ctx):
"""
Adds a user to the queue. Can only be used in #apply-to-next-review-pool channel.
"""
try:
allowed_channel_name = "apply-to-next-review-pool"
allowed_channel = discord.utils.get(ctx.guild.channels, name=allowed_channel_name)
if ctx.channel.name != allowed_channel_name:
await ctx.message.delete()
try:
if allowed_channel:
link = f"https://discord.com/channels/{ctx.guild.id}/{allowed_channel.id}"
await ctx.author.send(
f"⚠ You can only use the !join command in the [#{allowed_channel_name}]({link}) channel."
)
else:
await ctx.author.send(
f"⚠ The required channel #{allowed_channel_name} does not exist. Please contact the server admin."
)
except discord.Forbidden:
print(f"Could not send DM to {ctx.author}. They might have DMs disabled.")
return
user = ctx.author
if user not in state.queue:
state.queue.append(user)
await ctx.send(f"{user.mention} joined the queue!")
print(f"User {user} added to the queue. Current queue: {state.queue}")
else:
await ctx.send(f"⚠ {user.mention}, you are already in the queue!")
print(f"User {user} attempted to rejoin.")
except Exception as e:
print(f"Error in command '!join': {e}")
@bot.command()
@commands.has_any_role("Moderator", "Admin")
async def start_roll(ctx):
"""
Creates groups of 3 from the queue, ensuring:
- These 3 people (A, B, C) have never been a trio,
- AND no pair among them (A,B), (B,C), (A,C) has been in any past group.
Leftover users (1-2) are sent to #missing-people channel.
"""
if len(state.queue) < 3:
await ctx.send("⚠ Not enough users in the queue (minimum 3).")
return
# 1. Zbiór istniejących trójek (jak dotychczas) -> existing_groups
existing_groups = set()
# 2. Dodatkowo: zbiór istniejących par (pairs_set)
pairs_set = set()
# Pobieramy wszystkie dokumenty z kolekcji "past_groups"
past_groups = db.collection("past_groups").stream()
for doc in past_groups:
data = doc.to_dict()
members = data["members"] # np. ["111111", "222222", "333333"] (posortowane)
tuple_key = tuple(members)
existing_groups.add(tuple_key)
# Tworzymy pary z danej trójki i dodajemy je do pairs_set
# Pamiętajmy, że "members" ma 3 elementy, np. [m1, m2, m3]
# Dodajemy: (m1,m2), (m2,m3), (m1,m3) w formie posortowanej
m1, m2, m3 = members
pairs_set.add((m1, m2)) # już posortowane
pairs_set.add((m1, m3))
pairs_set.add((m2, m3))
formed_any_group = False
iteration_count = 0
max_iterations = 3 * len(state.queue) # Safety limit to prevent infinite loops
while len(state.queue) >= 3:
iteration_count += 1
if iteration_count > max_iterations:
await ctx.send("⚠ Could not form a new group. Possibly all combinations have been used.")
break
# Potencjalna trójka
potential_group = [state.queue[0], state.queue[1], state.queue[2]]
# Sortujemy ID:
sorted_ids = sorted([str(m.id) for m in potential_group])
tuple_key = tuple(sorted_ids)
# --- Sprawdzamy czy ten zestaw 3 -> (A, B, C) istniał kiedykolwiek
if tuple_key in existing_groups:
# Już byli razem
state.queue.append(state.queue.pop(0)) # rotate
continue
# --- Sprawdzamy czy któraś para nie istniała w parze w poprzednich grupach
# bierzemy (sorted_ids[0], sorted_ids[1]) itp.
a, b, c = sorted_ids
if ((a, b) in pairs_set) or ((b, c) in pairs_set) or ((a, c) in pairs_set):
# Któraś para już istniała
state.queue.append(state.queue.pop(0)) # rotate
continue
# Jeśli dotarliśmy tutaj, to znaczy, że:
# - ta trójka nie istniała,
# - żadna para z tych 3 osób nie występowała wcześniej.
# Możemy tworzyć grupę
formed_any_group = True
# Wyciągamy z kolejki
a_user = state.queue.pop(0)
b_user = state.queue.pop(0)
c_user = state.queue.pop(0)
# Zapis do Firestore
doc_id = "-".join(sorted_ids) # np. "111111-222222-333333"
db.collection("past_groups").document(doc_id).set({
"members": sorted_ids,
"timestamp": firestore.SERVER_TIMESTAMP
})
# Dodajemy pary do pairs_set
pairs_set.add((a, b))
pairs_set.add((b, c))
pairs_set.add((a, c))
# Zachowujemy informację o stworzonej grupie
state.groups.append([a_user, b_user, c_user])
# Tworzenie kanału
guild = ctx.guild
category = discord.utils.get(guild.categories, name=state.category_name)
if not category:
category = await guild.create_category(state.category_name)
channel_name = f"room-{len(state.groups)}"
overwrites = {
guild.default_role: discord.PermissionOverwrite(read_messages=False),
}
for member in [a_user, b_user, c_user]:
overwrites[member] = discord.PermissionOverwrite(read_messages=True, send_messages=True)
channel = await guild.create_text_channel(channel_name, category=category, overwrites=overwrites)
# A->B, B->C, C->A
reviewer_1, reviewee_1 = a_user, b_user
reviewer_2, reviewee_2 = b_user, c_user
reviewer_3, reviewee_3 = c_user, a_user
state.pending_reviews[channel.id] = {
(reviewer_1.id, reviewee_1.id): {
"reviewer_done": False,
"reviewee_confirmed": False,
"mod_confirmed": False,
"points_given": False
},
(reviewer_2.id, reviewee_2.id): {
"reviewer_done": False,
"reviewee_confirmed": False,
"mod_confirmed": False,
"points_given": False
},
(reviewer_3.id, reviewee_3.id): {
"reviewer_done": False,
"reviewee_confirmed": False,
"mod_confirmed": False,
"points_given": False
},
}
mentions = [m.mention for m in [a_user, b_user, c_user]]
instructions_text = (
f"🎨 Welcome to your review group!\n\n"
f"{', '.join(mentions)}, here are your tasks:\n"
f"1. Introduce yourself and share how long you've been creating coloring books.\n"
f"2. Upload a sample of your coloring book (PDF if possible, exactly how you upload it on Amazon).\n"
f"3. Share the Amazon link to your coloring book so others can leave a review.\n"
f"4. Once you finish **your** review, use the `!done` command in this channel.\n"
f"5. You have 48h to complete your review. If you don't finish, you will be removed from future rounds for 30 days.\n"
f"6. If you have any questions, please ask here.\n\n"
f"💡 Review assignments:\n"
f" - {a_user.mention} -> {b_user.mention}\n"
f" - {b_user.mention} -> {c_user.mention}\n"
f" - {c_user.mention} -> {a_user.mention}\n\n"
f"💡 Remember to be polite and provide constructive feedback!"
)
await channel.send(instructions_text)
if not formed_any_group:
await ctx.send("⚠ Could not form any new group. Possibly all combinations have been used.")
# Jeśli zostają 1 lub 2 osoby
leftover_count = len(state.queue)
if 1
Ich benutze Flask und halte ein Intervall von 1 min am Leben. Ich upgrade optimal time auf bezahlten plan, da in Free 5 min ist. Ich habe über Repuit gelesen, das ausschaltet, wann nicht aktiv ist. < /P>
Code: < /p>
from flask import Flask
from threading import Thread
app = Flask('')
@app.route('/')
def home():
return "Bot is running!"
def run():
app.run(host='0.0.0.0', port=8080)
def keep_alive():
thread = Thread(target=run)
thread.start()