def creature_effect_add(creatureid,effectmetaid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
if not request.is_json:
msg = f'Missing JSON in request'
logger.warn(msg)
return jsonify({"msg": msg, "success": False, "payload": None}), 400
duration = request.json.get('duration')
sourceid = request.json.get('sourceid')
if not isinstance(duration, int):
return jsonify({"success": False,
"msg": f'Duration should be an INT (duration:{duration})',
"payload": None}), 200
if not isinstance(sourceid, int):
return jsonify({"success": False,
"msg": f'Source ID should be an INT (sourceid:{sourceid})',
"payload": None}), 200
# Pre-flight checks
creature = fn_creature_get(None,creatureid)[3]
if creature is None:
return jsonify({"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None}), 200
source = fn_creature_get(None,sourceid)[3]
if source is None:
return jsonify({"success": False,
"msg": f'Creature unknown (sourceid:{sourceid})',
"payload": None}), 200
# Effect add
try:
creature_effect = add_effect(creature,duration,effectmetaid,source)
creature_effects = get_effects(creature)
except Exception as e:
msg = f'Effect Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
if creature_effect and creature_effects:
msg = f'Effect add OK (creatureid:{creature.id})'
logger.debug(msg)
return jsonify({"success": True,
"msg": msg,
"payload": {"effects": creature_effects,
"creature": creature}}), 200
else:
msg = f'Effect add KO (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
def pa_get(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{username})',
"payload": None
}), 409
try:
payload = RedisPa(pc).get()
except Exception as e:
msg = f'PA Query KO (pcid:{pc.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
return jsonify({
"success": True,
"msg": f'PA Query OK (pcid:{pc.id})',
"payload": payload
}), 200
def creature_pa_get(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None,creatureid)[3]
if creature is None:
return jsonify({"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None}), 200
try:
creature_pa = RedisPa(creature).get()
except Exception as e:
msg = f'PA Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
if creature_pa:
msg = f'PA Query OK (creatureid:{creature.id})'
logger.debug(msg)
return jsonify({"success": True,
"msg": msg,
"payload": {"pa": creature_pa,
"creature": creature}}), 200
else:
msg = f'PA Query KO (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
def creature_stats(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
try:
creature = fn_creature_get(None, creatureid)[3]
except Exception as e:
msg = f'Creature Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if not creature:
msg = f'Creature Query KO - Not Found (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
try:
# We check if we have the data in redis
cached_stats = RedisStats(creature).as_dict()
if cached_stats:
# Data was in Redis, so we return it
creature_stats = cached_stats
else:
# Data was not in Redis, so we compute it
generated_stats = RedisStats(creature).refresh().dict
if generated_stats:
# Data was computed, so we return it
creature_stats = generated_stats
else:
msg = f'Stats computation KO (pcid:{pc.id})'
logger.error(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
except Exception as e:
msg = f'Stats Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
return jsonify({
"success": True,
"msg": f'Stats Query OK (creatureid:{creature.id})',
"payload": {
"stats": creature_stats,
"creature": creature
}
}), 200
def creature_pa_consume(creatureid,redpa,bluepa):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None,creatureid)[3]
if creature is None:
return jsonify({"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None}), 200
if redpa > 16 or bluepa > 8:
msg = f'Cannot consume more than max PA (creatureid:{creature.id},redpa:{redpa},bluepa:{bluepa})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
if redpa < 0 or bluepa < 0:
msg = f'Cannot consume PA < 0 (creatureid:{creature.id},redpa:{redpa},bluepa:{bluepa})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
if redpa > RedisPa(creature).get()['red']['pa'] or bluepa > RedisPa(creature).get()['blue']['pa']:
msg = f'Cannot consume that amount of PA (creatureid:{creature.id},redpa:{redpa},bluepa:{bluepa})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
try:
ret = RedisPa(creature).set(redpa,bluepa)
creature_pa = RedisPa(creature).get()
except Exception as e:
msg = f'PA Query KO - Failed (creatureid:{creatureid},redpa:{redpa},bluepa:{bluepa})'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
if ret:
msg = f'PA Query OK (creatureid:{creatureid},redpa:{redpa},bluepa:{bluepa})'
logger.debug(msg)
return jsonify({"success": True,
"msg": msg,
"payload": {"pa": creature_pa,
"creature": creature}}), 200
else:
msg = f'PA Query KO (creatureid:{creatureid},redpa:{redpa},bluepa:{bluepa})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
def instance_get(pcid, instanceid):
creature = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None
}), 200
if creature.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (creatureid:{creature.id},username:{user.name})',
"payload": None
}), 409
if creature.instance is None:
return jsonify({
"success": False,
"msg": f'Creature not in an instance (creatureid:{creature.id})',
"payload": None
}), 200
if creature.instance != instanceid:
return jsonify({
"success": False,
"msg":
f'PC is not in this instance (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
# Check if the instance exists
try:
instance = instances.get_instance(instanceid)
except Exception as e:
msg = f'Instance Query KO (creatureid:{creature.id},instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if instance is False:
return jsonify({
"success": False,
"msg":
f'Instance not found (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
else:
return jsonify({
"success": True,
"msg":
f"Instance found (creatureid:{creature.id},instanceid:{instance['id']})",
"payload": instance
}), 200
def korp_get_one(pcid, korpid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
if pc.korp != korpid:
return jsonify({
"success": False,
"msg":
f'Korp request outside of your scope (pcid:{pc.id},korpid:{korpid})',
"payload": None
}), 200
try:
korp = fn_korp_get_one(korpid)
except Exception as e:
msg = f'Korp Query KO (pcid:{pc.id},korpid:{korpid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if korp:
return jsonify({
"success": True,
"msg": f'Korp Query OK (pcid:{pc.id},korpid:{korpid})',
"payload": korp
}), 200
elif korp is False:
return jsonify({
"success": False,
"msg":
f'Korp Query KO - Not Found (pcid:{pc.id},korpid:{korpid})',
"payload": None
}), 200
else:
return jsonify({
"success": False,
"msg":
f'Korp Query KO - Failed (pcid:{pc.id},korpid:{korpid})',
"payload": None
}), 200
def creature_status_del(creatureid, statusmetaid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None, creatureid)[3]
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None
}), 200
# Status del
try:
creature_status = del_status(creature, statusmetaid)
creature_statuses = get_statuses(creature)
except Exception as e:
msg = f'Status Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if creature_status > 0:
msg = f'Status del OK (creatureid:{creature.id},statusmetaid:{statusmetaid})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"statuses": creature_statuses,
"creature": creature
}
}), 200
elif creature_status == 0:
msg = f'Status del KO - Status Not Found (creatureid:{creature.id},statusmetaid:{statusmetaid})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
else:
msg = f'Status del KO - Failed (creatureid:{creature.id},statusmetaid:{statusmetaid})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
def discord_creature_get_one():
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
if not request.is_json:
msg = f'Missing JSON in request'
logger.warn(msg)
return jsonify({"msg": msg, "success": False, "payload": None}), 400
discordname = request.json.get('discordname')
creatureid = request.json.get('creatureid')
if not isinstance(discordname, str):
return (200, False,
f'Discordname should be a STR (discordname:{discordname})',
None)
if not isinstance(creatureid, int):
return (200, False,
f'Creature ID should be an INT (creatureid:{creatureid})',
None)
# Pre-flight checks
creature = fn_creature_get(None, creatureid)[3]
if creature is None:
msg = f'Query KO - Not Found (creatureid:{creatureid})'
logger.warning(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
user = fn_user_get_from_discord(discordname)
if user is None:
msg = f'Query KO - Not Found (discordname:{discordname})'
logger.warning(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
if creature.account == user.id:
# The Discord user owns the Creature
msg = f'Query OK (discordname:{discordname},creatureid:{creatureid})'
logger.trace(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"user": user,
"creature": creature
}
}), 200
else:
# The Discord user do NOT own the Creature
msg = f'Query KO - Not Yours (discordname:{discordname},creatureid:{creatureid})'
logger.warning(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
def creature_cd_get_one(creatureid, skillmetaid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None, creatureid)[3]
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None
}), 200
# CD get
try:
creature_cd = get_cd(creature, skillmetaid)
except Exception as e:
msg = f'CD Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if creature_cd is False:
msg = f'CD get KO - CD Not Found (creatureid:{creature.id},skillmetaid:{skillmetaid})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
elif creature_cd:
msg = f'CD get OK (creatureid:{creature.id},skillmetaid:{skillmetaid})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"cd": creature_cd,
"creature": creature
}
}), 200
else:
msg = f'CD get KO - Failed (creatureid:{creature.id},skillmetaid:{skillmetaid})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
def creature_equipment(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None, creatureid)[3]
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None
}), 200
try:
slots = fn_slots_get_one(creature)
except Exception as e:
msg = f'Slots Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
try:
equipment = {
"feet": fn_item_get_one(slots.feet),
"hands": fn_item_get_one(slots.hands),
"head": fn_item_get_one(slots.head),
"holster": fn_item_get_one(slots.holster),
"lefthand": fn_item_get_one(slots.lefthand),
"righthand": fn_item_get_one(slots.righthand),
"shoulders": fn_item_get_one(slots.shoulders),
"torso": fn_item_get_one(slots.torso),
"legs": fn_item_get_one(slots.legs)
}
except Exception as e:
msg = f'Equipment Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
msg = f'Equipment Query OK (creatureid:{creature.id})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"equipment": equipment,
"creature": creature
}
}), 200
def mp_add(pcid):
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
pcsrcid = request.json.get('src', None)
dsts = request.json.get('dst', None)
subject = request.json.get('subject', None)
body = request.json.get('body', None)
pcsrc = fn_creature_get(None, pcsrcid)[3]
if pcsrc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcsrc})',
"payload": None
}), 200
if pcsrc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pcsrc.id},username:{user.name})',
"payload": None
}), 409
try:
success = fn_mp_add(pcsrc, pcsrcid, dsts, subject, body)
except Exception as e:
msg = f'MP creation KO (srcid:{pcsrc.id},dstid:{dsts}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if success:
return jsonify({
"success": True,
"msg": f'MP creation OK (pcid:{pcsrc.id})',
"payload": None
}), 201
else:
return jsonify({
"success": True,
"msg": f'MP creation KO (pcid:{pcsrc.id})',
"payload": None
}), 200
def creature_wallet(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
try:
creature = fn_creature_get(None, creatureid)[3]
except Exception as e:
msg = f'Creature Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if not creature:
msg = f'Creature Query KO - Not Found (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
try:
wallet = fn_wallet_get(creature)
except Exception as e:
msg = f'Wallet Query KO - Failed (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if wallet:
return jsonify({
"success": True,
"msg": f'Wallet Query OK (pcid:{creature.id})',
"payload": {
"wallet": wallet,
"creature": creature
}
}), 200
else:
return jsonify({
"success": True,
"msg": f'Wallet Query KO - Not Found (pcid:{creature.id})',
"payload": None
}), 200
def stats_get(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{username})',
"payload": None
}), 409
try:
# We check if we have the data in redis
cached_stats = RedisStats(pc).as_dict()
if cached_stats:
# Data was in Redis, so we return it
pc_stats = cached_stats
else:
# Data was not in Redis, so we compute it
generated_stats = RedisStats(pc).refresh().dict
if generated_stats:
# Data was computed, so we return it
pc_stats = generated_stats
else:
msg = f'Stats computation KO (pcid:{pc.id})'
logger.error(msg)
return (200, False, msg, None)
except Exception as e:
msg = f'Stats Query KO (pcid:{pc.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
return jsonify({
"success": True,
"msg": f'Stats Query OK (pcid:{pc.id})',
"payload": pc_stats
}), 200
def item_get(pcid):
creature = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None
}), 200
if creature.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (creatureid:{creature.id},username:{username})',
"payload": None
}), 409
try:
all_items_sql = fn_item_get_all(creature)
all_items_json = json.loads(jsonify(all_items_sql).get_data())
armor = [x for x in all_items_json if x['metatype'] == 'armor']
slots = fn_slots_get_all(creature)
cosmetic = fn_cosmetics_get_all(creature)
wallet = [fn_wallet_get(creature)]
weapon = [x for x in all_items_json if x['metatype'] == 'weapon']
except Exception as e:
msg = f'Items Query KO (pcid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
return jsonify({
"success": True,
"msg": f'Equipment query successed (pcid:{creature.id})',
"payload": {
"weapon": weapon,
"armor": armor,
"equipment": slots,
"cosmetic": cosmetic,
"wallet": wallet
}
}), 200
def addressbook_get(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
try:
addressbook = fn_mp_addressbook_get(pc)
except Exception as e:
msg = f'Addressbook query failed (pcid:{pc.id})'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if addressbook:
return jsonify({
"success":
True,
"msg":
f'Addressbook Query OK (pcid:{pc.id})',
"payload": [{
"id": row[0],
"name": row[1]
} for row in addressbook]
}), 200
else:
return jsonify({
"success": False,
"msg": f'Addressbook Query KO (pcid:{pc.id})',
"payload": None
}), 200
def creature_cd_get_all(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
# Pre-flight checks
creature = fn_creature_get(None, creatureid)[3]
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature unknown (creatureid:{creatureid})',
"payload": None
}), 200
# CDs get
try:
creature_cds = get_cds(creature)
except Exception as e:
msg = f'CDs Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if isinstance(creature_cds, list):
msg = f'CDs get OK (creatureid:{creature.id})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"cds": creature_cds,
"creature": creature
}
}), 200
else:
msg = f'CDs get KO - Failed (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
def view_get(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if user is None:
return jsonify({
"success": False,
"msg": f'User not found (user:{user})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{username})',
"payload": None
}), 409
try:
if pc.squad is None:
# PC is solo / not in a squad
view_final = fn_creature_view_get(pc)
else:
# PC is in a squad
view_final = fn_creature_squad_view_get(pc)
except Exception as e:
msg = f'View Query KO (pcid:{pc.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
return jsonify({
"success": True,
"msg": f'View Query OK (pcid:{pc.id})',
"payload": view_final
}), 200
def creature_get_one(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
try:
creature = fn_creature_get(None,creatureid)[3]
except Exception as e:
msg = f'Creature Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
msg = f'Creature Query OK'
logger.debug(msg)
return jsonify({"success": True,
"msg": msg,
"payload": creature}), 200
def pc_event_get_all(creatureid):
creature = fn_creature_get(None,creatureid)[3]
# Pre-flight checks
if creature is None:
return jsonify({"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None}), 200
try:
creature_events = RedisEvent(creature).get()
except Exception as e:
msg = f'Event Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
return jsonify({"success": True,
"msg": f'Event Query OK (creatureid:{creature.id})',
"payload": creature_events}), 200
def mp_del(pcid, mpid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
try:
success = fn_mp_del_one(pc, mpid)
except Exception as e:
msg = f'MP deletion KO (pcid:{pc.id},mpid:{mpid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if success:
return jsonify({
"success": True,
"msg": f'MP deletion OK (pcid:{pc.id})',
"payload": None
}), 200
else:
return jsonify({
"success": True,
"msg": f'MP deletion KO (pcid:{pc.id})',
"payload": None
}), 200
def fn_mp_add(creature, pcsrcid, dsts, subject, body):
session = Session()
try:
for pcdstid in dsts:
pcdst = fn_creature_get(None, pcdstid)[3]
if pcdst:
mp = MP(src_id=creature.id,
src=creature.name,
dst_id=pcdst.id,
dst=pcdst.name,
subject=subject,
body=body)
session.add(mp)
session.commit()
except Exception as e:
session.rollback()
logger.error(f'MPs Query KO [{e}]')
return None
else:
logger.trace(f'MPs Query OK')
return True
finally:
session.close()
def creature_del(creatureid):
if request.headers.get('Authorization') != f'Bearer {API_INTERNAL_TOKEN}':
msg = f'Token not authorized'
logger.warn(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 403
try:
creature = fn_creature_get(None,creatureid)[3]
except Exception as e:
msg = f'Creature Query KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
if not creature:
msg = f'Creature Query KO - Not Found (creatureid:{creature.id})'
logger.warning(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
try:
# Now we can delete tue PC itself
if fn_creature_del(creature):
logger.debug('PC delete OK')
except Exception as e:
msg = f'Creature delete KO (creatureid:{creature.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
return jsonify({"success": True,
"msg": f'Creature delete OK (creatureid:{creature.id})',
"payload": None}), 200
def instance_leave(pcid, instanceid):
creature = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None
}), 200
if creature.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (creatureid:{creature.id},username:{user.name})',
"payload": None
}), 409
if creature.instance is None:
return jsonify({
"success": False,
"msg":
f'Creature not in an instance (creatureid:{creature.id},instanceid:{creature.instance})',
"payload": None
}), 200
if creature.instance != instanceid:
return jsonify({
"success": False,
"msg":
f'PC is not in this instance (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
# Check if the instance exists
try:
instance = instances.get_instance(instanceid)
except Exception as e:
msg = f'Instance Query KO (creatureid:{creature.id},instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if instance is False:
return jsonify({
"success": False,
"msg":
f'Instance not found (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
# Check if PC is the last inside the instance
try:
pcs = fn_creatures_in_instance(instanceid)
except Exception as e:
msg = f'PCs query failed (instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
if len(pcs) == 1:
# The PC is the last inside: we delete the instance
# SQL modifications
try:
# Start with Redis deletion
count = instances.del_instance(instanceid)
if count is None or count == 0:
# Delete keys failes, or keys not found
return jsonify({
"success": False,
"msg":
f'Instance cleaning KO (instanceid:{instanceid}) [{e}]',
"payload": None
}), 200
# SQL data deletion
ret = fn_creature_instance_set(creature, None)
if ret is None:
return jsonify({
"success": False,
"msg": f"Instance leave KO (creatureid:{creature.id})",
"payload": None
}), 200
except Exception as e:
msg = f'Instance cleaning KO (instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
else:
# Everything went well, deletion DONE
# We put the info in queue for Discord
scopes = []
if ret.korp is not None: scopes.append(f'Korp-{ret.korp}')
if ret.squad is not None: scopes.append(f'Squad-{ret.squad}')
for scope in scopes:
qmsg = {
"ciphered": False,
"payload":
f':map: **[{ret.id}] {ret.name}** closed an Instance ({instanceid})',
"embed": None,
"scope": scope
}
try:
queue.yqueue_put('yarqueue:discord', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:discord,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:discord,qmsg:{qmsg})')
# We put the info in queue for IA to clean the instance
try:
qmsg = {"action": 'delete', "instance": instance}
queue.yqueue_put('yarqueue:instances', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:instances,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:instances,qmsg:{qmsg})')
# Finally everything is done
return jsonify({
"success": True,
"msg":
f"Instance leave OK (creatureid:{creature.id},instanceid:{instanceid})",
"payload": ret
}), 200
else:
# Other players are still in the instance
try:
ret = fn_creature_instance_set(creature, None)
if ret is None:
return jsonify({
"success": False,
"msg": f"Instance leave KO (creatureid:{creature.id})",
"payload": None
}), 200
except Exception as e:
msg = f'Instance cleaning KO (instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
else:
# We put the info in queue for Discord
scopes = []
if ret.korp is not None: scopes.append(f'Korp-{ret.korp}')
if ret.squad is not None: scopes.append(f'Squad-{ret.squad}')
for scope in scopes:
qmsg = {
"ciphered": False,
"payload":
f':map: **[{ret.id}] {ret.name}** left an Instance ({instanceid})',
"embed": None,
"scope": scope
}
try:
queue.yqueue_put('yarqueue:discord', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:discord,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:discord,qmsg:{qmsg})')
return jsonify({
"success": True,
"msg":
f"Instance leave OK (creatureid:{creature.id},instanceid:{instanceid})",
"payload": ret
}), 200
def instance_join(pcid, instanceid):
creature = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None
}), 200
if creature.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (creatureid:{creature.id},username:{user.name})',
"payload": None
}), 409
if creature.instance is not None:
return jsonify({
"success": False,
"msg":
f'Creature in an instance (creatureid:{creature.id},instanceid:{creature.instance})',
"payload": None
}), 200
# Check if the instance exists
try:
instance = instances.get_instance(instanceid)
except Exception as e:
msg = f'Instance Query KO (creatureid:{creature.id},instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if instance is False:
return jsonify({
"success": False,
"msg":
f'Instance not found (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
if instance['public'] is False:
return jsonify({
"success": False,
"msg":
f'Instance not public (creatureid:{creature.id},instanceid:{instanceid})',
"payload": None
}), 200
# We add the Creature into the instance
try:
ret = fn_creature_instance_set(creature, instance['id'])
if ret is None:
return jsonify({
"success": False,
"msg":
f"Instance join KO (creatureid:{creature.id},instanceid:{instance['id']})",
"payload": None
}), 200
except Exception as e:
msg = f'Instance Query KO (creatureid:{creature.id},instanceid:{instanceid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
# We put the info in queue for Discord
scopes = []
if ret.korp is not None: scopes.append(f'Korp-{ret.korp}')
if ret.squad is not None: scopes.append(f'Squad-{ret.squad}')
for scope in scopes:
qmsg = {
"ciphered": False,
"payload":
f':map: **[{ret.id}] {ret.name}** joined an Instance ({instanceid})',
"embed": None,
"scope": scope
}
try:
queue.yqueue_put('yarqueue:discord', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:discord,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:discord,qmsg:{qmsg})')
return jsonify({
"success": True,
"msg":
f"Instance join OK (creatureid:{creature.id},instanceid:{instance['id']})",
"payload": ret
}), 200
def instance_add(pcid):
creature = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
if not request.is_json:
return jsonify({
"success": False,
"msg": "Missing JSON in request",
"payload": None
}), 400
hardcore = request.json.get('hardcore', None)
fast = request.json.get('fast', None)
mapid = request.json.get('mapid', None)
public = request.json.get('public', None)
# Pre-flight checks
if creature is None:
return jsonify({
"success": False,
"msg": f'Creature not found (creatureid:{creatureid})',
"payload": None
}), 200
if creature.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (creatureid:{creature.id},username:{user.name})',
"payload": None
}), 409
if creature.instance is not None:
return jsonify({
"success": False,
"msg": f'Creature in an instance (creatureid:{creature.id})',
"payload": None
}), 200
if not isinstance(mapid, int):
return jsonify({
"success": False,
"msg": f'Map ID should be an integer (mapid:{mapid})',
"payload": None
}), 200
if not isinstance(hardcore, bool):
return jsonify({
"success": False,
"msg": f'Hardcore param should be a boolean (hardcore:{hardcore})',
"payload": None
}), 200
if not isinstance(fast, bool):
return jsonify({
"success": False,
"msg": f'Fast param should be a boolean (fast:{fast})',
"payload": None
}), 200
if not isinstance(public, bool):
return jsonify({
"success": False,
"msg": f'Public param should be a boolean (public:{public})',
"payload": None
}), 200
# Check if map related to mapid exists
try:
map = maps.get_map(mapid)
except Exception as e:
msg = f'Map Query KO (mapid:{mapid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
# Create the new instance
try:
instance = instances.add_instance(creature, fast, hardcore, mapid,
public)
except Exception as e:
msg = f"Instance Query KO (creatureid:{creature.id},instanceid:{instance['id']}) [{e}]"
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if instance:
# Everything went well so far
try:
# Assign the PC into the instance
ret = fn_creature_instance_set(creature, instance['id'])
except Exception as e:
msg = f"Instance Query KO (creatureid:{creature.id},instanceid:{instance['id']}) [{e}]"
logger.error(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
if ret is None:
return jsonify({
"success": False,
"msg":
f"Instance create KO (creatureid:{creature.id},instanceid:{instance['id']})",
"payload": None
}), 200
# Everything went well, creation DONE
# We put the info in queue for Discord
scopes = []
if ret.korp is not None: scopes.append(f'Korp-{ret.korp}')
if ret.squad is not None: scopes.append(f'Squad-{ret.squad}')
for scope in scopes:
qmsg = {
"ciphered": False,
"payload":
f':map: **[{ret.id}] {ret.name}** opened an Instance ({instanceid})',
"embed": None,
"scope": scope
}
try:
queue.yqueue_put('yarqueue:discord', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:discord,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:discord,qmsg:{qmsg})')
# We put the info in queue for IA to populate the instance
try:
qmsg = {"action": 'create', "instance": instance}
queue.yqueue_put('yarqueue:instances', qmsg)
except Exception as e:
msg = f'Queue Query KO (Queue:yarqueue:instances,qmsg:{qmsg}) [{e}]'
logger.error(msg)
else:
logger.debug(
f'Queue Query OK (Queue:yarqueue:instances,qmsg:{qmsg})')
# Finally everything is done
return jsonify({
"success": True,
"msg": f"Instance create OK (creatureid:{ret.id})",
"payload": instance
}), 201
else:
return jsonify({
"success": False,
"msg": f'Instance create KO (creatureid:{ret.id})',
"payload": None
}), 200
def korp_create(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
korpname = request.json.get('name', None)
if korpname is None:
return jsonify({
"success": False,
"msg": f'Korpname not found (korpname:{korpname})',
"payload": None
}), 200
# Pre-flight checks
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
if pc.korp is not None:
return jsonify({
"success": False,
"msg": f'PC already in a Korp (pcid:{pc.id},korpid:{pc.korp})',
"payload": None
}), 200
# Remove everything, except alphanumeric, space, squote
korpname = ''.join([c for c in korpname if c.isalnum() or c in [" ", "'"]])
# Size check
if len(korpname) > 16:
return jsonify({
"success": False,
"msg": f'Korp name too long (korpname:{korpname})',
"payload": None
}), 200
# Unicity test
if fn_korp_get_one_by_name(korpname):
msg = f'Korp already exists (korpname:{korpname})'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 409
try:
newkorp = fn_korp_add_one(pc, korpname)
except Exception as e:
msg = f'Korp Query KO (pcid:{pcid},korpname:{korpname}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
# Korp created, let's assign the team creator in the korp
try:
pc = fn_korp_set_rank(pc, newkorp.id, 'Leader')
except Exception as e:
msg = f'Korp Query KO (pcid:{pcid},korpname:{korpname}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
try:
korp = fn_korp_get_one(newkorp.id)
except Exception as e:
msg = f'Korp Query KO (korpid:{newkorp.id}) [{e}]'
logger.error(msg)
return jsonify({
"success": False,
"msg": msg,
"payload": None
}), 200
else:
# We put the info in queue for ws
qmsg = {
"ciphered": False,
"payload":
f':information_source: **[{pc.id}] {pc.name}** created this Korp',
"embed": None,
"scope": f'Korp-{pc.korp}'
}
queue.yqueue_put('yarqueue:discord', qmsg)
# We put the info in queue for ws Front
qmsg = {
"ciphered": False,
"payload": korp,
"route": 'mypc/{id1}/korp',
"scope": 'korp'
}
queue.yqueue_put('broadcast', json.loads(jsonify(qmsg).get_data()))
return jsonify({
"success": True,
"msg": f'Korp create OK (pcid:{pc.id},korpid:{pc.korp})',
"payload": korp
}), 201
def action_resolver_skill(pcid, skillmetaid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if not request.is_json:
msg = f'Missing JSON in request'
logger.warn(msg)
return jsonify({"msg": msg, "success": False, "payload": None}), 400
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
if pc.instance is None:
return jsonify({
"success": False,
"msg": f'Creature not in an instance (pcid:{pcid})',
"payload": None
}), 200
try:
cd = cds.get_cd(pc, skillmetaid)
except Exception as e:
msg = f'CDs Query KO (pcid:{pc.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
if cd:
# The skill was already used, and still on CD
msg = f'Skill already on CD (pcid:{pc.id},skillmetaid:{skillmetaid})'
logger.debug(msg)
return jsonify({"success": False, "msg": msg, "payload": cd}), 200
try:
fightEventname = request.json.get('name', None)
fightEventtype = request.json.get('type', None)
fightEventactor = request.json.get('actor', None)
fightEventparams = request.json.get('params', None)
map = instances.get_instance(pc.instance)['map']
creatures = fn_creatures_in_instance(pc.instance)
creatures_effects = effects.get_instance_effects(pc)
creatures_statuses = statuses.get_instance_statuses(pc)
creatures_cds = cds.get_instance_cds(pc)
pas = RedisPa(pc).get()
except Exception as e:
msg = f'ResolverInfo Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
# Everythins if fine, we can build the payload
# Supposedly got all infos
payload = {
"context": {
"map": map,
"instance": pc.instance,
"creatures": creatures,
"effects": creatures_effects,
"status": creatures_statuses,
"cd": creatures_cds,
"pa": pas
},
"fightEvent": {
"name": fightEventname,
"type": fightEventtype,
"actor": fightEventactor,
"params": fightEventparams
}
}
try:
response = requests.post(f'{RESOLVER_URL}/', json=payload)
except Exception as e:
msg = f'Resolver Query KO (pcid:{pc.id},skillmetaid:{skillmetaid}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
# We create the Creature Event
RedisEvent(pc).add(pc.id, None, 'skill',
f'Used a Skill ({skillmetaid})', 30 * 86400)
msg = f'Resolver Query OK (pcid:{pc.id})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"resolver": json.loads(response.text),
"internal": payload
}
}), 200
def action_resolver_move(pcid):
pc = fn_creature_get(None, pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if not request.is_json:
msg = f'Missing JSON in request'
logger.warn(msg)
return jsonify({"msg": msg, "success": False, "payload": None}), 400
if pc is None:
return jsonify({
"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None
}), 200
if pc.account != user.id:
return jsonify({
"success": False,
"msg":
f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None
}), 409
if pc.instance is None:
return jsonify({
"success": False,
"msg": f'Creature not in an instance (pcid:{pcid})',
"payload": None
}), 200
try:
path = request.json.get('path', None)
map = instances.get_instance(pc.instance)['map']
creatures = fn_creatures_in_instance(pc.instance)
creatures_effects = effects.get_instance_effects(pc)
creatures_statuses = statuses.get_instance_statuses(pc)
creatures_cds = cds.get_instance_cds(pc)
pas = RedisPa(pc).get()
except Exception as e:
msg = f'ResolverInfo Query KO [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
# Supposedly got all infos
payload = {
"context": {
"map": map,
"instance": pc.instance,
"creatures": creatures,
"effects": creatures_effects,
"status": creatures_statuses,
"cd": creatures_cds,
"pa": pas
},
"fightEvent": {
"name": "RegularMovesFightClass",
"type": 3,
"actor": 1,
"params": {
"type": "target",
"destinationType": "tile",
"destination": None,
"options": {
"path": path
}
}
}
}
try:
response = requests.post(f'{RESOLVER_URL}/', json=payload)
except Exception as e:
msg = f'Resolver Query KO - Failed (pcid:{pc.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False, "msg": msg, "payload": None}), 200
else:
# We create the Creature Event
RedisEvent(pc).add(pc.id, None, 'action', 'Moved', 30 * 86400)
msg = f'Resolver Query OK (pcid:{pc.id})'
logger.debug(msg)
return jsonify({
"success": True,
"msg": msg,
"payload": {
"resolver": json.loads(response.text),
"internal": payload
}
}), 200
def action_weapon_reload(pcid,weaponid):
pc = fn_creature_get(None,pcid)[3]
user = fn_user_get(get_jwt_identity())
# Pre-flight checks
if pc is None:
return jsonify({"success": False,
"msg": f'Creature not found (pcid:{pcid})',
"payload": None}), 200
if pc.account != user.id:
return jsonify({"success": False,
"msg": f'Token/username mismatch (pcid:{pc.id},username:{user.name})',
"payload": None}), 409
# Retrieving weapon stats
try:
item = fn_item_get_one(weaponid)
except Exception as e:
msg = f'Item Query KO (pcid:{pc.id},weaponid:{weaponid}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
if item is None:
return jsonify({"success": False,
"msg": f'Item not found (pcid:{pc.id},weaponid:{weaponid})',
"payload": None}), 200
itemmeta = dict(list(filter(lambda x:x["id"]==item.metaid,metaWeapons))[0]) # Gruikfix
if itemmeta is None:
return jsonify({"success": False,
"msg": f'ItemMeta not found (pcid:{pcid},weaponid:{item.id})',
"payload": None}), 200
if itemmeta['pas_reload'] is None:
return jsonify({"success": False,
"msg": f'Item is not reloadable (pcid:{pc.id},weaponid:{item.id})',
"payload": None}), 200
if item.ammo == itemmeta['max_ammo']:
return jsonify({"success": False,
"msg": f'Item is already loaded (pcid:{pc.id},weaponid:{item.id})',
"payload": None}), 200
if RedisPa(pc).get()['red']['pa'] < itemmeta['pas_reload']:
# Not enough PA to reload
return jsonify({"success": False,
"msg": f'Not enough PA to reload (pcid:{pc.id})',
"payload": {"red": RedisPa(pc).get()['red'],
"blue": RedisPa(pc).get()['blue'],
"action": None}}), 200
walletammo = fn_wallet_ammo_get(pc,item,itemmeta['caliber'])
neededammo = itemmeta['max_ammo'] - item.ammo
if walletammo < neededammo:
# Not enough ammo to reload
return jsonify({"success": False,
"msg": f'Not enough PA to reload (pcid:{pc.id})',
"payload": None}), 200
try:
# We reload the weapon
fn_item_ammo_set(weaponid,neededammo)
# We remove the ammo from wallet
fn_wallet_ammo_set(pc,itemmeta['caliber'],neededammo * -1)
# We consume the PA
RedisPa(pc).set(itemmeta['pas_reload'],0)
# Wa add HighScore
incr.one(f'highscores:{pc.id}:action:reload')
# We create the Creature Event
RedisEvent(pc).add(pc.id,
None,
'action',
f'Reloaded a weapon',
30*86400)
except Exception as e:
msg = f'Weapon reload KO (pcid:{pc.id},weaponid:{item.id}) [{e}]'
logger.error(msg)
return jsonify({"success": False,
"msg": msg,
"payload": None}), 200
else:
return jsonify({"success": True,
"msg": f'Weapon reload OK (pcid:{pc.id},weaponid:{item.id})',
"payload": {"red": RedisPa(pc).get()['red'],
"blue": RedisPa(pc).get()['blue'],
"weapon": fn_item_get_one(weaponid)}}), 200
