def get_user_color(self, guild_id, user_id):
color = None
member = redisqueue.get_guild_member(guild_id, user_id)
if not member:
return None
guild_roles = redisqueue.get_guild(guild_id)["roles"]
guildroles_filtered = {}
for role in guild_roles:
time.sleep(0)
guildroles_filtered[role["id"]] = role
member_roleids = member["roles"]
member_roles = []
for roleid in member_roleids:
time.sleep(0)
role = guildroles_filtered.get(str(roleid))
if not role:
continue
member_roles.append(role)
member_roles = sorted(member_roles, key=lambda k: k['position'])
for role in member_roles:
time.sleep(0)
if role["color"] != 0:
color = '{0:02x}'.format(role["color"])
while len(color) < 6:
time.sleep(0)
color = "0" + color
return color
def user_info(guild_id, user_id):
usr = {
"id": None,
"username": None,
"nickname": None,
"discriminator": None,
"avatar": None,
"avatar_url": None,
"roles": [],
"badges": [],
}
member = redisqueue.get_guild_member(guild_id, user_id)
if member:
usr["id"] = str(member["id"])
usr["username"] = member["username"]
usr["nickname"] = member["nick"]
usr["discriminator"] = member["discriminator"]
usr["avatar"] = member["avatar"]
usr["avatar_url"] = generate_avatar_url(usr["id"], usr["avatar"],
usr["discriminator"], True)
roles = get_member_roles(guild_id, user_id)
guild_roles = redisqueue.get_guild(guild_id)["roles"]
for r in roles:
for gr in guild_roles:
if gr["id"] == r:
usr["roles"].append(gr)
usr["badges"] = get_badges(user_id)
if redis_store.get("DiscordBotsOrgVoted/" + str(member["id"])):
usr["badges"].append("discordbotsorgvoted")
return jsonify(usr)
def get_online_embed_users(guild_id):
usrs = get_online_embed_user_keys(guild_id)
unauths = db.session.query(UnauthenticatedUsers).filter(
UnauthenticatedUsers.user_key.in_(usrs["UnauthenticatedUsers"]),
UnauthenticatedUsers.revoked == False, UnauthenticatedUsers.guild_id
== guild_id).all() if usrs["UnauthenticatedUsers"] else []
auths = db.session.query(AuthenticatedUsers).filter(
AuthenticatedUsers.client_id.in_(
usrs["AuthenticatedUsers"]), AuthenticatedUsers.guild_id
== guild_id).all() if usrs["AuthenticatedUsers"] else []
users = {'unauthenticated': [], 'authenticated': []}
for user in unauths:
meta = {
'username': user.username,
'discriminator': user.discriminator,
}
users['unauthenticated'].append(meta)
for user in auths:
client_id = user.client_id
usrdb = redisqueue.get_guild_member(guild_id, client_id)
meta = {
'id': str(usrdb["id"]),
'username': usrdb["username"],
'nickname': usrdb["nick"],
'discriminator': usrdb["discriminator"],
'avatar_url': generate_avatar_url(usrdb["id"], usrdb["avatar"]),
}
users['authenticated'].append(meta)
return users
def on_identify(self, data):
authorization = data.get("session", None)
if authorization:
try:
data = serializer.loads(authorization)
session.update(data)
except:
pass
guild_id = data["guild_id"]
if not guild_accepts_visitors(guild_id) and not check_user_in_guild(
guild_id):
disconnect()
self.teardown_db_session()
return
session["socket_guild_id"] = guild_id
channels = []
forced_role = get_forced_role(guild_id)
if guild_accepts_visitors(
guild_id) and not check_user_in_guild(guild_id):
channels = get_guild_channels(guild_id,
force_everyone=True,
forced_role=forced_role)
else:
channels = get_guild_channels(guild_id, forced_role=forced_role)
join_room("GUILD_" + guild_id)
for chan in channels:
if chan["read"]:
join_room("CHANNEL_" + chan["channel"]["id"])
if session.get("unauthenticated", True) and guild_id in session.get(
"user_keys", {}):
join_room("IP_" + get_client_ipaddr())
elif not session.get("unauthenticated", True):
join_room("USER_" + str(session["user_id"]))
visitor_mode = data["visitor_mode"]
if not visitor_mode:
if session["unauthenticated"]:
emit("embed_user_connect", {
"unauthenticated": True,
"username": session["username"],
"discriminator": session["user_id"]
},
room="GUILD_" + guild_id)
else:
nickname = redisqueue.get_guild_member(
guild_id, session["user_id"]).get("nickname")
emit("embed_user_connect", {
"unauthenticated": False,
"id": str(session["user_id"]),
"nickname": nickname,
"username": session["username"],
"discriminator": session["discriminator"],
"avatar_url": session["avatar"]
},
room="GUILD_" + guild_id)
emit("identified")
self.teardown_db_session()
def on_current_user_info(self, data):
if "socket_guild_id" not in session:
disconnect()
return
guild_id = data["guild_id"]
if "user_keys" in session and not session["unauthenticated"]:
dbMember = redisqueue.get_guild_member(guild_id,
session["user_id"])
usr = {
'avatar': session["avatar"],
'username': dbMember.get("username"),
'nickname': dbMember.get("nickname"),
'discriminator': dbMember.get("discriminator"),
'user_id': str(session['user_id']),
}
emit("current_user_info", usr)
self.teardown_db_session()
def post():
guild_id = request.form.get("guild_id")
channel_id = request.form.get('channel_id')
content = request.form.get('content', "")
file = None
if "file" in request.files:
file = request.files["file"]
if file and file.filename == "":
file = None
rich_embed = request.form.get("richembed", None)
if rich_embed:
rich_embed = json.loads(rich_embed)
if "user_id" in session:
dbUser = redisqueue.get_guild_member(guild_id, session["user_id"])
else:
dbUser = None
if user_unauthenticated():
key = session['user_keys'][guild_id]
else:
key = None
content, illegal_post, illegal_reasons = format_post_content(
guild_id, channel_id, content, dbUser)
status = update_user_status(guild_id, session['username'], key)
message = {}
if illegal_post:
status_code = 417
if status['banned'] or status['revoked']:
status_code = 401
else:
chan = filter_guild_channel(guild_id, channel_id)
if not chan.get("write") or chan["channel"]["type"] != "text":
status_code = 401
elif (file and not chan.get("attach_files")) or (
rich_embed and not chan.get("embed_links")):
status_code = 406
elif not illegal_post:
userid = session["user_id"]
content = format_everyone_mention(chan, content)
webhook = get_channel_webhook_url(guild_id, channel_id)
# if userid in get_administrators_list():
# content = "(Titan Dev) " + content
if webhook:
if (session['unauthenticated']):
username = session["username"]
if len(username) > 25:
username = username[:25]
username = username + "#" + str(session["user_id"])
avatar = url_for('static',
filename='img/titanembeds_square.png',
_external=True)
dbguild = db.session.query(Guilds).filter(
Guilds.guild_id == guild_id).first()
if dbguild:
icon = dbguild.guest_icon
if icon:
avatar = icon
else:
username = session["username"]
if dbUser:
if dbUser["nick"]:
username = dbUser["nick"]
# if content.startswith("(Titan Dev) "):
# content = content[12:]
# username = "******" + username
if len(username) > 25:
username = username[:25]
username = username + "#" + str(session['discriminator'])
avatar = session['avatar']
message = discord_api.execute_webhook(webhook.get("id"),
webhook.get("token"),
username, avatar,
content, file,
rich_embed)
delete_webhook_if_too_much(webhook)
else:
message = discord_api.create_message(channel_id, content, file,
rich_embed)
status_code = message['code']
db.session.commit()
response = jsonify(message=message.get('content', message),
status=status,
illegal_reasons=illegal_reasons)
response.status_code = status_code
return response
