def get_categories():
"""
Returns the categories
:return:
"""
db = blizzard_db()
return DatabaseUtils.core_query(db.query(PostCategoryModel)).all()
def update_character_info(name: str, role=0):
data = BlizzardAPI.character(name)
if data is None:
return None
db = blizzard_db()
q = db.query(CharacterModel).filter(
CharacterModel.wow_id == data.wow_id)
if q.count() > 0:
q.update({
'name': data.name,
'level': data.level,
'gender': data.gender,
'faction': data.faction,
'role_index': role,
'character_race_id': data.character_race_id,
'character_class_id': data.character_class_id,
'character_spec_id': data.character_spec_id,
})
else:
db.add(
CharacterModel(
wow_id=data.wow_id,
name=data.name,
level=data.level,
gender=data.gender,
faction=data.faction,
role_index=role,
character_race_id=data.character_race_id,
character_class_id=data.character_class_id,
character_spec_id=data.character_spec_id,
realm_id=data.realm_id,
guild_id=data.guild_id,
))
db.commit()
return True
def update_info():
"""
Updates the main guild info
:return:
"""
db = blizzard_db()
data = blizzard_guild_info()
logger.info(f"Guild identifier: {data['id']}")
DataStore.set(db, "gid", data["id"])
logger.info(f"Guild name: {data['name']}")
DataStore.set(db, "guild_name", data["name"])
logger.info(f"Guild achievement points: {data['achievement_points']}")
DataStore.set(db, "achievement_points", data["achievement_points"])
logger.info(f"Guild faction: {data['faction']['name']}")
DataStore.set(db, "faction_name", data['faction']['name'])
DataStore.set(db, "faction_type", data['faction']['type'])
logger.info(f"Guild created timestamp: {data['created_timestamp']}")
DataStore.set(db, "created_timestamp", data['created_timestamp'])
logger.info(f"Guild players: {data['member_count']}")
DataStore.set(db, "players", data['member_count'])
logger.info(f"Guild crest: {data['crest']['emblem']['id']}")
crest_url = f'https://render-eu.worldofwarcraft.com/guild/tabards/emblem_{data["crest"]["emblem"]["id"]}.png'
background_color = data["crest"]["background"]["color"]["rgba"]
background_color = f"{background_color['r']}, {background_color['g']}, {background_color['b']}, {background_color['a']}"
DataStore.set(db, "crest_emblem_url", crest_url)
DataStore.set(db, "crest_background_color", background_color)
def get_full_user(blizzard_id: int, token: str):
BlizzardUsersUtils.id__safe(token)
WAccountUtils.eval_token(token)
db = blizzard_db()
return DatabaseUtils.core_query(
db.query(WAccountModel).filter(
WAccountModel.user_id == blizzard_id)).all()
def update_player(name):
db = blizzard_db()
ch = db.query(CharacterModel).filter(
CharacterModel.name == name).first()
team_races = db.query(MythicRaceMembersModel).filter(
MythicRaceMembersModel.name == ch.name).all()
print('Races found: ' + len(team_races).__str__())
points = 0
for team_race in team_races:
races = db.query(MythicRaceModel).filter(
MythicRaceModel.mythic_hash == team_race.mythic_hash).all()
for race in races:
print("+ -------------------------------------------+")
print(f"| {ch.name}")
print("+ -------------------------------------------+")
print(f"| -> {race.name} ({race.level})")
print(f"| Guild race: {race.guild_race} / 5")
level_for_race = race.level * race.guild_race
print(f"| This race score: {level_for_race}")
points = points + level_for_race
print("+ -------------------------------------------+")
print(f"| Mythic score: {points}")
# time counting
later_time = datetime.datetime.utcnow()
time_scores = floor(
((later_time - ch.created).total_seconds() / 60.0) / 10000)
points = points + time_scores
print(f"| Time score: {time_scores}")
print(f"| Total score: {points}")
db.query(CharacterModel).filter(CharacterModel.name == ch.name).update(
{'activity': points})
db.commit()
def prove_player(static_id, wow_id, blizzard_id):
db = blizzard_db()
q = db.qery(StaticMemberModel).filter(StaticMemberModel.static_id == static_id) \
.filter(StaticMemberModel.wow_id == wow_id).filter(StaticMemberModel.blizzard_id == blizzard_id)
if q.count() < 1:
raise HTTPException(404, 'Request is undefined!')
q.update({'request_state': 2})
db.commit()
return True
def get(blizzard_id):
"""
Returns the blizzard user by blizzard_id
:param blizzard_id:
:return:
"""
db = blizzard_db()
return DatabaseUtils.core_query(
db.query(BlizzardUserModel).filter(
BlizzardUserModel.blizzard_id == blizzard_id)).first()
def update_characters_mythic():
data = DatabaseUtils.core_query(
blizzard_db().query(CharacterModel)).all()
logger.info("Starting update characters mythic...")
logger.info(f"Total count: {len(data)}")
bar = Bar('Characters mythic updating', max=len(data), fill='█')
for member in data:
name = member.name
MythicUpdater.update_mythic_character(name)
bar.next()
print("")
def update_characters_images(path=default_characters_images_path):
"""
Downloads the characters images
Characters are getting from the database
:param path:
:return:
"""
MediaDownloader.download_characters_images(
DatabaseUtils.core_query(
blizzard_db().query(CharacterModel)).all(), path)
def update_meta(name: str, meta: str):
"""
Updates player meta
:param name:
:param meta:
:return:
"""
db = blizzard_db()
db.query(CharacterModel).filter(CharacterModel.name == name).update(
{'meta_text': meta})
db.commit()
def get_posts_limit(offset: int = 0, limit: int = 100):
"""
Returns the posts by limit
:param offset:
:param limit:
:return:
"""
db = blizzard_db()
return DatabaseUtils.limited_results_query(
db.query(PostModel).order_by(PostModel.id.desc()),
offset=offset,
limit=limit)
def update_guild_role(name: str, role: int):
"""
Updates player guild role
:param name:
:param role:
:return:
"""
db = blizzard_db()
db.query(CharacterModel).filter(CharacterModel.name == name).update(
{'guild_role': role})
db.commit()
def remove_like(user_id: int, post_id: int):
"""
Removes like
:param user_id:
:param post_id:
:return:
"""
db = blizzard_db()
db.query(PostLikeModel) \
.filter(PostLikeModel.user_id == user_id) \
.filter(PostLikeModel.post_id == post_id).delete()
db.commit()
return db
def add_post(user_id: int, category_id: int, title: str, content: str,
image: str, tags: str):
db = blizzard_db()
return DatabaseUtils.insert(
db,
PostModel(
user_id=user_id,
category_id=category_id,
title=title,
content=content,
tags=tags,
image=image,
))
def update_items_images(path=default_items_images_path):
"""
Downloads the items images
Items are getting from the database
:param path: - saving path
:return:
"""
MediaDownloader.download_items_images(
blizzard_db().query(CharacterEquipmentModel).all(),
path,
connector=connector)
def add_player(static_id, wow_id, role_id, comment, blizzard_id):
db = blizzard_db()
q = db.query(StaticMemberModel).filter(StaticMemberModel.static_id == static_id) \
.filter(StaticMemberModel.wow_id == wow_id).filter(StaticMemberModel.blizzard_id == blizzard_id)
if q.count() > 0:
raise HTTPException(429, "You have already sent the request")
return DatabaseUtils.insert(
db,
StaticMemberModel(static_id=static_id,
wow_id=wow_id,
role_id=role_id,
request_state=1,
request_comment=comment,
blizzard_id=blizzard_id))
def add_player(body: StaticMemberCreate):
blizzard_id = BlizzardUsersUtils.id__safe(body.token)
db = blizzard_db()
q = DatabaseUtils.core_query(
db.query(WAccountModel).filter(
WAccountModel.user_id == blizzard_id).filter(
WAccountModel.wow_id == body.wow_id))
if q.count() < 1:
raise HTTPException(404, 'You have not got this player')
return StaticUtils.add_player(static_id=body.static_id,
wow_id=body.wow_id,
role_id=body.role_id,
comment=body.request_comment,
blizzard_id=blizzard_id)
def fix_missed(blizzard_characters: List):
db = blizzard_db()
q = DatabaseUtils.core_query(db.query(CharacterModel)).all()
for character in q:
found = False
for b_ch in blizzard_characters:
if b_ch['character']['name'] == character.name:
found = True
if not found:
logger.warn(character.name + " escape guild")
db.query(CharacterModel).filter(
CharacterModel.wow_id == character.wow_id).update(
{'state': 0})
db.commit()
def add_category(user_id, title, url):
"""
Adds the comment
:param user_id:
:param title:
:param url:
:return:
"""
db = blizzard_db()
return DatabaseUtils.insert(
db, PostCategoryModel(
title=title,
user_id=user_id,
url=url,
))
def create_static(title, description, image, owner_blizzard_id):
"""
Creates the static
:param owner_blizzard_id:
:param title:
:param description:
:param image:
:return:
"""
db = blizzard_db()
return DatabaseUtils.insert(
db,
StaticIndexModel(title=title,
description=description,
image=image,
owner_blizzard_id=owner_blizzard_id))
def get_posts_by_blizzard_id(blizzard_id: int,
offset: int = 0,
limit: int = 100):
"""
Returns the posts by blizzard id
:param blizzard_id:
:param offset:
:param limit:
:return:
"""
db = blizzard_db()
return DatabaseUtils.limited_results_query(db.query(PostModel).filter(
PostModel.user_id == blizzard_id).order_by(desc(PostModel.id)),
offset=offset,
limit=limit)
def add_player(body: AcceptCreate):
blizzard_id = BlizzardUsersUtils.id__safe(body.token)
db = blizzard_db()
qs = DatabaseUtils.core_query(db.query(StaticIndexModel)) \
.filter(StaticIndexModel.owner_blizzard_id == blizzard_id)
if qs.count() < 1:
raise HTTPException(503, 'You cant accept player to not your static')
q = DatabaseUtils.core_query(db.query(StaticMemberModel)) \
.filter(StaticMemberModel.id == body.member_id)
if q.count() < 1:
raise HTTPException(404, 'You have not got this player')
q.update({'request_state': 2})
db.commit()
return True
def add(
blizzard_id: int,
wow_id: int,
name: str,
realm_id: int,
realm_title: str,
level: int,
faction: str
):
"""
Adds the character
:param realm_title:
:param blizzard_id:
:param wow_id:
:param name:
:param realm_id:
:param level:
:param faction:
:return:
"""
db = blizzard_db()
q = DatabaseUtils.core_query(db.query(WAccountModel)) \
.filter(WAccountModel.user_id == blizzard_id) \
.filter(WAccountModel.wow_id == wow_id)
if q.count() > 0:
logger.info(f'Updates: {name}')
q.update({
'name': name,
'realm_id': realm_id,
'realm_title': realm_title,
'level': level,
'faction': faction,
})
else:
logger.info(f'Creates: {name}')
db.add(WAccountModel(
user_id=blizzard_id,
wow_id=wow_id,
name=name,
realm_id=realm_id,
realm_title=realm_title,
level=level,
faction=faction
))
db.commit()
def add(blizzard_id: int, blizzard_name: str):
"""
Adds the blizzard user
:param blizzard_id:
:param blizzard_name:
:return:
"""
db = blizzard_db()
q = db.query(BlizzardUserModel).filter(
BlizzardUserModel.blizzard_id == blizzard_id)
count = q.count()
if count == 0:
return DatabaseUtils.insert(
db,
BlizzardUserModel(blizzard_id=blizzard_id,
blizzard_name=blizzard_name))
else:
return q.first()
def add_comment(user_id,
post_id: int,
text: str,
reply_id: Optional[int] = None):
"""
adds the comment
:param user_id:
:param post_id:
:param text:
:param reply_id:
:return:
"""
db = blizzard_db()
return DatabaseUtils.insert(
db,
PostCommentsModel(user_id=user_id,
post_id=post_id,
reply_id=reply_id if reply_id is not None else 0,
text=text))
def add_like(user_id: int, post_id: int):
"""
Adds like
:param user_id:
:param post_id:
:return:
"""
db = blizzard_db()
val = db.query(PostLikeModel) \
.filter(PostLikeModel.user_id == user_id) \
.filter(PostLikeModel.post_id == post_id).count()
if val == 0:
DatabaseUtils.insert(
db, PostLikeModel(
post_id=post_id,
user_id=user_id,
))
return True
else:
return False
def update_equipment(name: str):
data = BlizzardAPI.character_equipment(name)
db = blizzard_db()
# print("")
# logger.info("Starting update character equipment " + name)
# logger.info(f"Total count: {len(data)}")
bar = Bar('Equipment ' + name, max=len(data), fill='█')
db.query(CharacterEquipmentModel) \
.filter(CharacterEquipmentModel.character_id == data[0].character_id).delete()
k = 0
ks = 0
for item in data:
if item.slot in CharacterCountableSlots:
k += item.level
ks = ks + 1
db.add(
CharacterEquipmentModel(
title=item.title,
wow_id=item.wow_id,
character_id=item.character_id,
slot=item.slot,
inventory_type=item.inventory_type,
level=item.level,
quantity=item.quantity,
quality=item.quality,
item_class_id=item.item_class_id,
item_subclass_id=item.item_subclass_id,
stats=item.stats,
))
bar.next()
time.sleep(1 / 1000)
gear = round(k / ks)
db.query(CharacterModel).filter(CharacterModel.name == name).update(
{'gear': gear})
db.commit()
def update_mythic_character(name):
data = MythicUtils.get_profile_mythic(name)
db = blizzard_db()
print("")
logger.info("Starting update character mythic " + name)
bar = Bar('Mythic updating', max=len(data), fill='█')
for item in data:
g_race = 0
for member in item['members']:
ex_m = db.query(MythicRaceMembersModel) \
.filter(MythicRaceMembersModel.mythic_hash == item['hashes']['mythic']) \
.filter(MythicRaceMembersModel.wow_id == member['wow_id']).count()
from_g = db.query(CharacterModel).filter(
CharacterModel.wow_id == member['wow_id']).count() > 0
if from_g:
g_race = g_race + 1
if ex_m == 0:
db.add(
MythicRaceMembersModel(
mythic_hash=item['hashes']['mythic'],
wow_id=member['wow_id'],
name=member['name'],
spec_id=member['spec']['wow_id'],
from_guild=from_g))
db.commit()
ex = db.query(MythicRaceModel).filter(
MythicRaceModel.mythic_hash == item['hashes']
['mythic']).count()
if ex == 0:
db.add(
MythicRaceModel(team_hash=item['hashes']['team'],
affixes_hash=item['hashes']['affixes'],
mythic_hash=item['hashes']['mythic'],
wow_dung_id=item['wow_dung_id'],
name=item['name'],
completed=item['completed'],
duration=item['duration']['time'],
duration_string=item['duration']['format'],
done_in_time=item['done_in_time'],
guild_race=g_race,
level=item['keystone_level']))
db.commit()
# Adding an affixes
for affix in item['keystone_affixes']:
ex_a = db.query(MythicRaceAffixesModel) \
.filter(MythicRaceAffixesModel.mythic_hash == item['hashes']['mythic']) \
.filter(MythicRaceAffixesModel.wow_id == affix['wow_id']).count()
if ex_a == 0:
db.add(
MythicRaceAffixesModel(
mythic_hash=item['hashes']['mythic'],
wow_id=affix['wow_id'],
name=affix['name'],
))
db.commit()
bar.next()
print("")
def connector(wow_id, image_id):
db = blizzard_db()
db.query(CharacterEquipmentModel).filter(
CharacterEquipmentModel.wow_id == wow_id).update(
{'image_id': image_id})
db.commit()
def get_static_list():
db = blizzard_db()
return DatabaseUtils.core_query(db.query(StaticIndexModel)).all()
