async def generate(self, user_id, access_level: int, active: bool = True):
""" Generates API key.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#generateself-user_id-access_level-int-active-bool--true
"""
user_validate = await User(user_id=user_id).exists()
if user_validate.error:
return Response(data="Invalid user")
query = """INSERT INTO api_keys (
user_id,
`key`,
league_id,
access_level,
active
) VALUES (
:user_id,
:key,
:league_id,
:access_level,
:active
)"""
values = {
"user_id": user_id,
"key": secrets.token_urlsafe(24),
"league_id": self.current_league.league_id,
"access_level": access_level,
"active": int(active),
}
await SESSIONS.database.execute(query=query, values=values)
return Response(data={"key": values["key"]})
async def update(self, args: dict):
""" Updates details of league.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#updateself-args-dict
"""
if len(args) > 0:
query = "UPDATE league_info SET "
values = {"league_id": self.league_id}
for key, item in args.items():
if type(item) == bool:
if item:
item = 1
else:
item = 0
values[key] = item
# Don't worry this isn't
# injecting any values.
query += "{}={},".format(key, ":" + key)
query = query[:-1]
query += " WHERE league_id = :league_id"
await SESSIONS.database.execute(query=query, values=values)
return Response(data=args)
return Response(error="No arguments")
def deleteMachine():
postData = request.json
result = Machine.delete(postData["_id"])
if (result):
return Response.Ok()
else:
return Response.Error(result)
def health_check():
try:
result = HealthCheck.version()
return Response(200).body(ResponseBuilder.success(result)).build()
except Exception as e:
logger.exception(e)
return Response(500).body(ResponseBuilder.error(e)).build()
async def get_server(self):
""" Finds a available server for the current league.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#get_serverself
"""
if not CONFIG.server["regions"].get(self.region):
print(self.region)
print(CONFIG.server["regions"])
return Response(error="No server IDs for that region")
region_servers = list(CONFIG.server["regions"][self.region])
region_servers_remove = region_servers.remove
query = """SELECT server_id
FROM scoreboard_total
WHERE server_id IN :server_ids AND status != 0"""
values = {"server_ids": region_servers}
# Removing any server ID being used in an active match.
async for row in SESSIONS.database.iterate(query=query, values=values):
region_servers_remove(row["server_id"])
# Removing any server IDs from our temp blacklist.
for server_id in IN_MEMORY_CACHE.temp_server_blacklist:
if server_id in region_servers:
region_servers_remove(server_id)
if len(region_servers) > 0:
return Response(data=region_servers[0])
else:
return Response(error="No available servers")
async def get(self):
""" Gets base details about the match.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#getself
"""
query = """SELECT match_id, server_id, map_order, player_order, timestamp, status,
map, team_1_name, team_2_name,
team_1_score, team_2_score,
team_1_side, team_2_side, record_statistics
FROM scoreboard_total
WHERE match_id = :match_id
AND league_id = :league_id AND region = :region"""
values = {
"match_id": self.match_id,
"league_id": self.current_league.league_id,
"region": self.current_league.region,
}
row = await SESSIONS.database.fetch_one(
query=query,
values=values
)
if row:
return Response(data=MatchModel(row).full)
else:
return Response(error="No match with that ID")
async def queue_allowed(self):
""" Checks if over the active queue limit.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#queue_allowedself
"""
query = """SELECT COUNT(score.status) AS active_queues,
IFNULL(info.queue_limit, 0) AS queue_limit
FROM league_info AS info
LEFT JOIN scoreboard_total AS score
ON score.league_id = info.league_id
AND score.status != 0
WHERE info.league_id = :league_id"""
row = await SESSIONS.database.fetch_one(query=query,
values={
"league_id":
self.league_id,
})
if row:
# Ensures users can't create another
# queue when another queue is being created
# what would put them over the queue limit.
if IN_MEMORY_CACHE.started_queues.get(self.league_id):
active_queues = row["active_queues"] \
+ IN_MEMORY_CACHE.started_queues[self.league_id]
else:
active_queues = row["active_queues"]
return Response(data=row["queue_limit"] > active_queues)
else:
return Response(error=True)
def test():
try:
message = {'success': "success"}
return Response(message, codeStatus=200).Success()
except Exception as e:
print("Exception ", e.args)
return Response(codeStatus=422, hint=str(e)).Error()
async def details(self):
""" Gets basic details of league.
https://github.com/ModuleLIFT/API/blob/master/docs/modules.md#detailsself
"""
row = await SESSIONS.database.fetch_one(
query="""SELECT league_name, league_website, discord_webhook,
websocket_endpoint, queue_limit,
league_id, discord_prefix,
sm_message_prefix, knife_round,
pause, surrender,
warmup_commands_only, captain_choice_time
FROM league_info WHERE league_id = :league_id""",
values={
"league_id": self.league_id,
})
if row:
formatted_row = {**row}
if formatted_row["pause"] == 0:
formatted_row["pause"] = False
formatted_row["surrender"] = formatted_row["surrender"] == 1
formatted_row["warmup_commands_only"] = \
formatted_row["warmup_commands_only"] == 1
formatted_row["knife_round"] = formatted_row["knife_round"] == 1
return Response(data=formatted_row)
return Response(error="No such league")
def change_password():
"""
修改密码
:param: str: old_pass
:param: str: new_pass
:return:
"""
res = Response()
input_json = request.json
payload = get_jwt_user()
user_id = payload["user_id"]
try:
user = User.get(User.id == user_id)
database_pass = (user.password).encode()
old_pass = bytes(input_json["old_pass"], "utf-8")
if not bcrypt.checkpw(old_pass, database_pass):
res.Code = 403
res.Message = "password does not match"
return jsonify(res.object_to_dict())
new_pass = bytes(input_json["new_pass"], "utf-8")
password = bcrypt.hashpw(new_pass, bcrypt.gensalt())
user = User.update({"password": password.decode()}).where(User.id == user_id)
user.execute()
res.Code = 200
res.Message = 'success'
except:
res.Code = 500
res.Message = "Interval Error"
return jsonify(res.object_to_dict())
def download(url, config, logger=None):
host, port = config.cache_server
# print("going to download" + url);
check = 0
while True:
try:
resp = requests.get(f"http://{host}:{port}/",
params=[("q", f"{url}"),
("u", f"{config.user_agent}")],
timeout=(5, 60))
break
except:
if check == 3:
return None
check += 1
continue
if resp:
# print('download successful')
return Response(cbor.loads(resp.content))
logger.error(f"Spacetime Response error {resp} with url {url}.")
return Response({
"error": f"Spacetime Response error {resp} with url {url}.",
"status": resp.status_code,
"url": url
})
def download_all_teams(database=None):
# call nba_api and get all the teams
all_teams = teams.get_teams()
# intilialize respoinse with the specified database
r = Response(all_teams, database=database)
# extract the team data
r.extract_teams()
def download_all_players(database=None):
# call nba_api and get all the players
all_players = players.get_players()
# initialize response with the specified database
r = Response(all_players, database=database)
# extract the response for only active players
r.extract_active_players()
def videoWatched():
try:
vv = VideoVisited(root_path)
d = vv.updateVideoStatus(request.json)
return Response(d, codeStatus=200).Success()
except Exception as e:
print("Exception ", e.args)
return Response(codeStatus=422, hint=str(e)).Error()
async def _validate_and_format(self, steam_id,
ip, name,
discord_id, pfp):
""" Validates given params & formats. """
exists = await self.external_exists(steam_id, discord_id)
if exists.error:
return exists
steam = await Steam.get_user(steam_id)
if steam.error:
return steam
if not pfp:
pfp = steam.data["avatarfull"]
path = urlparse(pfp).path
file_type = splitext(path)[1][1:]
if file_type not in self.accepted_pfp_types:
return Response(error="File type not supported")
if ip:
alt_detection = await Proxy(ip).alt_detection()
if alt_detection.error:
return alt_detection
if alt_detection.data:
return Response(error="Alt account")
if not name:
name = steam.data["personaname"]
try:
async with SESSIONS.aiohttp.get(pfp) as resp:
if resp.status == 200:
resp_data = await resp.read()
background_task = BackgroundTask(
SESSIONS.cdn.upload,
path_key="pfps",
data=resp_data,
file_name="{}.{}".format(self.user_id, file_type)
)
else:
return Response(error="Invalid pfp")
except ClientError:
return Response(error="Invalid url")
return Response(data={
"steam_id": steam_id,
"discord_id": discord_id,
"name": name,
"file_type": file_type,
"ip": ip,
}, background=background_task)
def create():
try:
_data = dict(request.json)
PixSchema().validate(PixSchema().schema(), _data)
result = PixBusiness().create(_data)
return Response(201).body(result).build()
except Exception as e:
logger.exception(e)
return Response(500).body(ResponseBuilder.error(e)).build()
def download_player_game_log(SEASON, SEASON_TYPE, database=None):
for player_id in database:
# call nba_api and get player game info
pgl = PlayerGameLog(player_id).get_normalized_dict()
# initialize response with the specified database
r = Response(pgl, database=database)
# extract the response for player game log
r.extract_player_game_log(player_id)
def download_common_team_info(database=None):
for team_id, _team in database.db_team.items():
# call nba_api and get common team info
tci = teaminfocommon.TeamInfoCommon(team_id).get_normalized_dict()
# initialize response with the specified database
r = Response(tci, database=database)
# extract the response for team common info
r.extract_team_common_info(team_id)
def user_info():
"""
获取用户信息
:return:
"""
res = Response()
payload = get_jwt_user()
user = User.get_or_none(User.id == payload["user_id"])
if user:
user_dict = {
"id": user.id,
"created_at": user.created_at,
"last_login_at": user.last_login_at,
"role_id": user.role_id,
"status": user.status,
"user_name": user.user_name
}
res.Code = 200
res.Message = "success"
res.Result = {
"data": user_dict
}
return jsonify(res.object_to_dict())
res.Code = 400
res.Message = "user not exist"
return jsonify(res.object_to_dict())
def demo1():
"""
:return:
"""
res = Response()
try:
pass
except Exception as e:
pass
return jsonify(res.object_to_dict())
def searchSolution():
try:
uq = UserQuery(root_path)
# uq.saveMultimidia()
uq.saveQuery()
data = uq.getResult()
return Response(data, codeStatus=200).Success()
except Exception as e:
raise e
print("Exception ", e.args)
return Response(codeStatus=422, hint=str(e)).Error()
def download_common_player_info(database=None):
for player_id in database:
# call nba_api and get common player info
cpi = commonplayerinfo.CommonPlayerInfo(
player_id).get_normalized_dict()
# initialize response with the specified database
r = Response(cpi, database=database)
# extract the response for player common info
r.extract_player_common_info(player_id)
def get(self):
slack = SlackHelper(current_app.config['SLACK_TOKEN'])
players = Player.query.all()
try:
slack_users = slack.get_users(search_term=request.args.get("s"))
except SlackRequestFailed as e:
logging.error('Slack Api Error: {}'.format(str(e)))
return Response.error({'general': [Response.REQUEST_FAILED]}, 503)
players = enrich_slack_users_with_players(slack_users, players)
return Response.success(players_schema.dump(players).data)
def download(url, config, logger=None):
host, port = config.cache_server
resp = requests.get(
f"http://{host}:{port}/",
params=[("q", f"{url}"), ("u", f"{config.user_agent}")])
if resp:
return Response(cbor.loads(resp.content))
logger.error(f"Spacetime Response error {resp} with url {url}.")
return Response({
"error": f"Spacetime Response error {resp} with url {url}.",
"status": resp.status_code,
"url": url})
def addMachine():
try:
machine = Machine()
machine.fromJson(request.json)
result = machine.save()
if (result["status"] == "ok"):
return Response.Ok("successfully inserted", result["id"])
else:
return Response.Error(payload=result["message"])
except Exception, e:
return jsonify(status='ERROR', message=str(e))
def send_message():
try:
if Security.is_authorized(request):
payload = json.loads(request.data)
if Validate.is_valid_payload(payload):
return Response.ok(payload['to'])
else:
return Response.fail(400)
else:
return Response.fail(403)
except Exception as e:
return Response.fail(500)
def categoryGenerator():
try:
"""
this route is used to create list of categories
"""
cs = CategorySet()
result = cs.generator()
data = {"result": result}
return Response(data, codeStatus=200).Success()
except Exception as e:
# raise e
print("ExceptionExceptionExceptionException ", e.args)
return Response(codeStatus=422, hint=str(e)).Error()
async def get_user(self, steam_id):
""" Gets details from steam API about given steam ID. """
async with AIOHTTP.ClientSession.get(
profile_url.format(steam_id)) as resp:
if resp.status == 200:
resp_json = await resp.json()
if "response" in resp_json \
and "players" in resp_json["response"] \
and len(resp_json["response"]["players"]) == 1:
return Response(data=resp_json["response"]["players"][0])
return Response(error="Invalid user or API key")
def account_management():
"""
获取账户的key和secret
:return:
"""
res = Response()
payload = get_jwt_user()
user_id = payload['user_id']
try:
user = User.get_or_none(User.id == user_id)
data = {}
if user:
credentials_data = {"consumerId": user.user_name, "type": "key-auth"}
result = GatewayService().post("/credentials", json=credentials_data)
consumer = json.loads(result.text)
data["key"] = consumer["keyId"]
data["secret"] = consumer["keySecret"]
res.Code = 200
res.Message = "success"
res.Result = {
"data": data
}
except Exception as e:
logging.info("get user %s gateway_info error. %s", user_id, e)
res.Code = 500
res.Message = "Interval Error."
return jsonify(res.object_to_dict())
def questionsCategoryGenerator():
try:
"""
this route is used to create ralation between question_catalog table and
question_category table.
"""
cs = CatalogCategoryMapping()
result = cs.mapper()
data = {"result": result}
return Response(data, codeStatus=200).Success()
except Exception as e:
# raise e
print("ExceptionExceptionExceptionException ", e.args)
return Response(codeStatus=422, hint=str(e)).Error()
def replace(self, *args, **kwargs):
kwargs.setdefault('encoding', getattr(self, '_encoding', None))
return Response.replace(self, *args, **kwargs)