def get(self):
Utils.reset(self) # reset/clean standard variables
start_time = time.time() # start count
self.respn = '{"info":"no notification!"}' # set default response of the action
list = apns.get() # get list of notifications to be sent
parameter = '[]' # set default blank list of notification
if (list): # if any notification
parameter = json.dumps(list)
# then parse all of it to parameters as a list (array) of notification
# send to proxy url, which will connect with apple push notification service via socket
result = urlfetch.fetch(
url=config.apns['proxyurl'],
payload='{"data":' + parameter + ', "time":' + str(start_time) +
',"passwd":"' + config.testing['passwd'] + '"}',
method=urlfetch.POST,
headers={'Content-Type': 'text/json; charset=utf-8'},
validate_certificate=False)
if result.status_code == 200: # if success request
self.respn = result.content # return response message as result
apns.clean() # after all done, clean local list of notification
logging.info(self.respn) # also do log, so we can read in consle log
# calculate time taken and return result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
class UtilsTest(unittest.TestCase):
def setup_method(self, method):
self.utils = Utils()
self.header = self.utils.format_header("TOKEN-XXXXXX1")
def test_contract_format_header(self):
keys = self.header.keys()
# validate number of keys in dict
self.assertEqual(len(keys), 1, 'Testing Length of keys')
# validate the content of key
fake_keys = {'X-Riot-Token': 'TOKEN-XXXXXX1'}.keys()
self.assertEqual(keys, fake_keys, 'Testing contract validation')
def test_remove_slash_in_end_of_string(self):
slash_in_the_end = self.utils.remove_slash_in_end_of_string(
'https://lendico.com.br/')
without_slash_in_the_end = self.utils.remove_slash_in_end_of_string(
'https://lendico.com.br/')
# validate if method remove slash in the end of string
self.assertEqual(slash_in_the_end, 'https://lendico.com.br',
'Testing removing slash in the end of string')
# validate if method dont remove the last char
self.assertEqual(
without_slash_in_the_end, 'https://lendico.com.br',
'Testing dont remove last char when string dont have slash in the end of string'
)
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
lang = Utils.required(self, 'lang')
version = self.request.get('version')
if version is None or version == '':
version = config.dictionary['version']
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
if self.error == '':
data = Data.gettransui(self, float(version))
if data is not None:
try:
self.respn = json.dumps(data.as_obj[lang])
except KeyError:
self.error = 'UI Text for give language was not found!'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
async def job_queue(self):
while True:
try:
await sleep(Utils.seconds_until_cycle())
t = datetime.now().astimezone(utc)
timeframes = Utils.get_accepted_timeframes(t)
isPremium = self.tickerId in [
"EURUSD", "GBPUSD", "AUDJPY", "AUDUSD", "EURJPY", "GBPJPY",
"NZDJPY", "NZDUSD", "CADUSD", "JPYUSD", "ZARUSD"
]
if len(client.guilds) == 1:
refreshRate = "8H"
elif isPremium and len(client.guilds) < 15:
refreshRate = "1H"
else:
refreshRate = "5m"
if refreshRate in timeframes and not self.updatingNickname:
client.loop.create_task(self.update_nicknames())
if "1H" in timeframes:
client.loop.create_task(self.update_properties())
except CancelledError:
return
except Exception:
print(format_exc())
if environ["PRODUCTION_MODE"]: self.logging.report_exception()
def __init__(self):
self.debug = False
self.root_dir = os.path.dirname(os.path.abspath(__file__))
self.mutations_dir = os.path.join(self.root_dir, 'mutations')
self.hangs_dir = os.path.join(self.root_dir, 'hangs')
self.cfg = self._initialize_config()
self.ml = self._initialize_logging()
self.mo = None
# Shared memory
self.shm = None
self.shm_size = 0
self.bitmap_size = 65536
self.fd = 0
# PIN command line
self.cmd_l = []
# Setup helpers
self.ae = Aesthetics(self)
self.utils = Utils(self)
self.fileops = FileOperations(self)
self.crash_analysis = CrashAnalysis(self)
self.rpc_client = BrundleFuzzRpcClient(self)
self._initialize_shared_memory()
self._initialize_pin_cmd()
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
buildings = None
# if error, skip this
if self.error == '':
buildings = Data.getbuildings(self, lang, float(version))
if self.error == '' and buildings is not None:
self.respn = buildings.data
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get_request_handler(self):
"""
Creates the HTTP controller instance from path string
:return:
"""
argpath = self.get_argpath()
args = argpath.split('/')
# TODO: Do a proper way of request path handling
# Now we have context_root in place
if len(args) == 0 or argpath == '/':
#self.err_msg = SimpleHTTPStatusOK()
handler = None
else:
try:
handler_name = Utils.strip_char('/', args[1])
self.__log.info("Handler Name is {}".format(handler_name))
handler_module = self._get_module_path(handler_name)
self.__log.info("Creating HTTP Controller class for {}".format(handler_module))
handler = Utils.create_instance(handler_module, self.config)
except Exception as e:
self.err_msg = SimpleHTTPErrorControllerNotExists()
self.__log.error("Error while creating HTTP Controller instance")
self.__log.error(self.err_msg)
self.__log.error(str(e))
handler = None
#raise
return handler
def get_request_handler(self):
"""
Creates the HTTP controller instance from path string
:return:
"""
argpath = self.get_argpath()
args = argpath.split('/')
# TODO: Do a proper way of request path handling
# Now we have context_root in place
if len(args) == 0 or argpath == '/':
#self.err_msg = SimpleHTTPStatusOK()
handler = None
else:
try:
handler_name = Utils.strip_char('/', args[1])
self.__log.info("Handler Name is {}".format(handler_name))
handler_module = self._get_module_path(handler_name)
self.__log.info("Creating HTTP Controller class for {}".format(
handler_module))
handler = Utils.create_instance(handler_module, self.config)
except Exception as e:
self.err_msg = SimpleHTTPErrorControllerNotExists()
self.__log.error(
"Error while creating HTTP Controller instance")
self.__log.error(self.err_msg)
self.__log.error(str(e))
handler = None
#raise
return handler
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = self.request.get('version')
if version is None or version == '':
version = config.dictionary['version']
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
if self.error == '':
data = Data.gettransui(self, float(version))
if data is not None:
self.respn = '['
for lang in data.as_obj:
self.respn += '{"code":"' + lang + '", "lang":"' + data.as_obj[
lang]['language.name'] + '"},'
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def champion_mastery():
endpoint_without_slash_in_the_end = Utils.remove_slash_in_end_of_string(confs.champion_mastery_endpoint)
endpoint = endpoint_without_slash_in_the_end + '/' + confs.champion_mastery_summoner_id
headers = Utils.format_header(confs.access_key)
champion_mastery_json = RiotExtractor()\
.get_data_from_api(endpoint=endpoint, headers=headers, api_name='champion mastery')
return champion_mastery_json
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
chid = self.request.get('chid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
result = None
if self.error == '' and player is not None:
if chid:
if Challenge.DeleteById(self, chid):
result = '"result":"deleted successfully"'
else:
result = '"result":"Challenge Id=' + chid + ' could not be found, nothing was deleted"}'
else:
if Challenge.DeleteByUserId(self, player.uuid):
result = '"result":"deleted successfully"'
elif Challenge.DeleteByUserId(self, player.fbid):
result = '"result":"deleted successfully"'
else:
result = '"result":"nothing was deleted"'
if self.error == '' and player is not None:
self.respn = '{'
Challenge.ComposeChallenges(self, player)
self.respn += ',' + result
self.respn = self.respn.rstrip(',') + '}'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self)
uuid = Utils.required(self, 'uuid')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
track = 'track.1'
if self.request.get('track'):
lang = self.request.get('track')
score = 0
if self.request.get('score'):
lang = self.request.get('score')
uuid = self.request.get('uuid')
start_time = time.time()
# find the right track in buildings and add the score total to it for collection
player = Player.getplayer(self, uuid)
# get all buildings types
buildings = Data.getbuildings(self, lang, version)
# get player buildings
mybuildings = Building.getmybuildings(self, uuid)
#find the building with the track id and give it cash
if buildings is not None and mybuildings is not None:
self.respn += '"building":['
for mybuilding in mybuildings:
_upd = False
# for example: "itid": "track.1",
if mybuilding.itid == track:
mybuilding.amount += score
Building.setmybuilding(self, mybuilding)
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + '],'
if self.error == '':
self.respn = '{"state":' + player.state + ', "building":['
self.respn = Building.compose_mybuilding(self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self)
# calculate score by linking replay times Race Winnings Data
event1 = '{"start_bonus": [0.1, 0.2, 0.4], "shift_bonus": [0.2, 0.5, 0.8], "drift_bonus": [0.3, 0.1, 0.9]}'
event2 = '{"start_bonus": [0.1, 0.2, 0.4], "shift_bonus": [0.2, 0.5, 0.8], "drift_bonus": [0.3, 0.1, 0.9]}'
laptime1 = 1
laptime2 = 2
self.respn = json.dumps(Score.calculate(self, event1, event2, laptime1, laptime2))
# calculate time taken and return the result
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, 1))
def job_queue(self): while True: try: time.sleep(Utils.seconds_until_cycle()) t = datetime.datetime.now().astimezone(pytz.utc) timeframes = Utils.get_accepted_timeframes(t) if "1h" in timeframes: TickerParserServer.refresh_parser_index() except Exception: print(traceback.format_exc()) if os.environ["PRODUCTION_MODE"]: self.logging.report_exception()
def main():
# checking if output path exists
Utils.create_path_if_not_exists(confs.dest)
# executing master leagues json writer
master = master_leagues()
champion = champion_mastery()
# writer both in file system
Writer().write_json(data=master, file_name="master_leagues", output_path=confs.dest)
Writer().write_json(data=champion, file_name="champion_mastery", output_path=confs.dest)
# plotting and save championPointchart
RiotChampionPointsXChampionID(champion).save_chart_as_image(path=confs.dest)
def get(self):
Utils.reset(self) # reset/clean standard variables
name = self.request.get('name')
if name == '':
name = 'Guest?'
name2 = self.request.get('name2')
if name2 == '':
name2 = 'Guest??'
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
track = Utils.required(self, 'track')
toid = Utils.required(self, 'toid')
image = self.request.get('image')
image2 = self.request.get('image2')
friend = False
if self.request.get('friend'):
friend = bool(self.request.get('friend'))
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
Utils.LogRequest(self)
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
logging.warn('creating new challenge with' + player.uuid)
challenge = Challenge.Create(self, track, player.uuid, toid, name,
name2, image, image2, friend)
if challenge is not None:
self.respn = '{'
Challenge.ComposeActualChallenge(self, challenge)
self.respn = self.respn.rstrip(',') + '}'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def run(self): while self.isServiceAvailable: try: sleep(Utils.seconds_until_cycle()) t = datetime.now().astimezone(utc) timeframes = Utils.get_accepted_timeframes(t) if "1m" in timeframes: self.update_accounts() self.process_price_alerts() except (KeyboardInterrupt, SystemExit): return except Exception: print(format_exc()) if environ["PRODUCTION_MODE"]: self.logging.report_exception()
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
checklist = self.request.get('checklist')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
logging.info(guid + '==' + player.state_obj['guid'])
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
if checklist:
player.state_obj['advice_checklist'] = checklist
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
self.respn = '{"advice_checklist_saved":"true"}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def job_queue(self):
while True:
try:
time.sleep(Utils.seconds_until_cycle())
t = datetime.datetime.now().astimezone(pytz.utc)
timeframes = Utils.get_accepted_timeframes(t)
if "4H" in timeframes:
self.update_popular_tickers()
except (KeyboardInterrupt, SystemExit):
return
except Exception:
print(traceback.format_exc())
if os.environ["PRODUCTION_MODE"]:
self.logging.report_exception()
def get(self):
self.respn = 'Images,ComposeActualChallenge, caradata escaped, Added cardata, name and photo to challenges' \
'Challengedelete now retuns new challenge list' \
'"removed replay -> score code. changed":"Cast [created] to string, delayed cron for 1st",' \
'"version":"3"}'
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, 1))
def do_ssl_certs_exist(self):
"""
Checks if ssl related files exist in the system
:return:
"""
ssl_files = [self.ssl_cafile, self.ssl_certfile, self.ssl_keyfile]
return Utils.do_files_exist(ssl_files, self.__log)
async def job_queue(self):
while True:
try:
await sleep(Utils.seconds_until_cycle())
t = datetime.now().astimezone(utc)
timeframes = Utils.get_accepted_timeframes(t)
if "1m" in timeframes:
await self.update_system_status(t)
if "15m" in timeframes:
client.loop.create_task(self.update_alpha_guild_roles())
except CancelledError:
return
except Exception:
print(format_exc())
if environ["PRODUCTION_MODE"]: self.logging.report_exception()
def execute(self):
if not self._city:
try:
self._city = Utils.get_weather_city(self._user_id)[0]
except:
raise exceptions.CityNotLinkedError
r = requests.get("http://api.openweathermap.org/data/2.5/weather",
params={
"q": self._city,
"APPID": "81d59d3e4bcd5bd5b69f6f95250213ee"
})
if r.status_code != 200:
raise exceptions.ApiRequestError
js = r.json()
if not js or js["cod"] == "404":
raise exceptions.CityNotFoundError
temperature = round(float(js['main']['temp']) - 273)
wind = js['wind']['speed']
descr = self.WEATHER_STATE.get(js['weather'][0]['main'],
js['weather'][0]['main'])
country = js['sys']['country']
humidity = js['main']['humidity']
text = f"{self._city.capitalize()}, {country}\n{descr}\nТемпература: {temperature}°C\nВлажность: {humidity}%\nСкорость ветра: {wind} м/с"
return self.Message(text)
def update_guild_properties(self, settings, changes, timestamp):
"""Updates Discord guild properties
Parameters
----------
settings : [google.cloud.firestore_v1.document.DocumentSnapshot]
complete document snapshot
changes : [google.cloud.firestore_v1.watch.DocumentChange]
database changes in the sent snapshot
timestamp : int
timestamp indicating time of change in the database
"""
try:
for change in changes:
guildId = change.document.id
properties = change.document.to_dict()
if "addons" not in properties:
database.document("discord/properties/guilds/{}".format(guildId)).set(Utils.create_guild_settings(properties))
continue
if properties["addons"]["satellites"].get("count") is not None and not properties["addons"]["satellites"]["enabled"]:
properties["addons"]["satellites"].pop("count", None)
database.document("discord/properties/guilds/{}".format(guildId)).set(properties)
continue
if change.type.name in ["ADDED", "MODIFIED"]:
self.guildProperties[guildId] = properties
else:
self.guildProperties.pop(guildId)
self.serviceStatus[2] = True
except Exception:
print(traceback.format_exc())
if os.environ["PRODUCTION_MODE"]: self.logging.report_exception(user=guildId)
def execute(self):
if not self._user_id:
self._user_id = self._from_id
logging.info("Getting user role.")
message = "Роль: "
if Utils.has_role(self._user_id, Roles.ADMIN):
role = "админ"
elif Utils.has_role(self._user_id, Roles.DONATOR):
expires, role = Utils.get_donator_expire_date(self._user_id)
if role is None:
role = "донатер"
role += f"\nУ вас осталось {expires} команд"
else:
role = "юзер"
message += role
return self.Message(message)
def _get_command_object(self):
command_object = None
if issubclass(self.cmd, staticCommands.StaticCommand):
logging.debug("Static command.")
command_object = self.cmd(key=self._key)
elif issubclass(self.cmd, commands.ILevelCommand):
logging.debug("Level command.")
command_object = self.cmd(
user_id=self.event.from_id,
chat_id=self.event.peer_id,
target_id=Utils.find_user_id(self._value),
amount=Utils.get_experience_amount(self._value))
elif issubclass(self.cmd, commands.ICommandManager):
logging.debug("Commands managing.")
if not Utils.has_role(self.event.from_id,
Roles.DONATOR | Roles.ADMIN):
raise exceptions.AccesDeniesError
command_object = self.cmd(message=self.event.text,
attachments=self.event.attachments,
author_id=self.event.from_id)
elif issubclass(self.cmd, commands.IAdminCommand):
logging.debug("Admin managing.")
if not Utils.is_creator(self.event.from_id):
raise exceptions.AccesDeniesError
user_id = Utils.find_user_id(self.event.text)
command_object = self.cmd(user_id, self.event.from_id)
elif issubclass(self.cmd, commands.IDonatorManager):
logging.debug("Donator managing.")
if not Utils.is_creator(self.event.from_id):
raise exceptions.AccesDeniesError
command_object = self.cmd(self._value, self.event.from_id)
elif issubclass(self.cmd, commands.IOsuCommand):
logging.debug("osu! command")
# Need to get server and username from db
# server, username, user_id dict
params = Utils.get_osu_params(self._value, self.event.from_id)
logging.debug(self.event)
fwd_message = Utils.get_reply_message_from_event(self.event)
if fwd_message is not None:
params["beatmap_id"] = Utils.find_beatmap_id(
fwd_message["text"])
command_object = self.cmd(**params)
else:
logging.debug("Other command.")
command_object = self.cmd(self._value, self.event.from_id)
return command_object
def request_ccxt_quote(self, request):
ticker = request.get_ticker()
exchange = request.get_exchange()
try:
if exchange is None: return None, None
exchange = Exchange(exchange.id)
tf, limitTimestamp, candleOffset = Utils.get_highest_supported_timeframe(exchange.properties, datetime.datetime.now().astimezone(pytz.utc))
try:
rawData = exchange.properties.fetch_ohlcv(ticker.symbol, timeframe=tf.lower(), since=limitTimestamp, limit=300)
if len(rawData) == 0 or rawData[-1][4] is None or rawData[0][1] is None: return None, None
except:
print(traceback.format_exc())
return None, None
price = [rawData[-1][4], rawData[0][1]] if len(rawData) < candleOffset else [rawData[-1][4], rawData[-candleOffset][1]]
if ticker.isReversed: price = [1 / price[0], 1 / price[1]]
volume = None if price[0] is None else sum([candle[5] for candle in rawData if int(candle[0] / 1000) >= int(exchange.properties.milliseconds() / 1000) - 86400]) / (price[0] if exchange.id in ["bitmex", "binancefutures"] else 1)
priceChange = 0 if tf == "1m" or price[1] == 0 else (price[0] / price[1]) * 100 - 100
payload = {
"quotePrice": "{:,.8f}".format(price[0]) if ticker.isReversed else Utils.format_price(exchange.properties, ticker.symbol, price[0]),
"quoteVolume": volume,
"quoteConvertedPrice": "≈ ${:,.6f}".format(price[0] * self.lastBitcoinQuote["quotePrice"][0]) if ticker.quote == "BTC" else None,
"quoteConvertedVolume": "≈ ${:,.4f}".format(volume * self.lastBitcoinQuote["quotePrice"][0]) if ticker.quote == "BTC" else None,
"title": ticker.name,
"baseTicker": "USD" if ticker.base in QuoteProcessor.stableCoinTickers else ticker.base,
"quoteTicker": "USD" if ticker.quote in QuoteProcessor.stableCoinTickers else ticker.quote,
"change": priceChange,
"thumbnailUrl": TickerParser.get_coingecko_image(ticker.base),
"messageColor": "amber" if priceChange == 0 else ("green" if priceChange > 0 else "red"),
"sourceText": "on {}".format(exchange.name),
"platform": "CCXT",
"raw": {
"quotePrice": [price[0]] if tf == "1m" else price[:1],
"quoteVolume": volume,
"ticker": ticker,
"exchange": exchange,
"timestamp": time.time()
}
}
return payload, None
except Exception:
print(traceback.format_exc())
if os.environ["PRODUCTION_MODE"]: self.logging.report_exception()
return None, None
def master_leagues():
endpoint = confs.master_leagues_endpoint
headers = Utils.format_header(confs.access_key)
master_leagues_json = RiotExtractor()\
.get_data_from_api(endpoint=endpoint, headers=headers, api_name='master leagues')
return master_leagues_json
def job_queue(self): while True: try: sleep(Utils.seconds_until_cycle()) t = datetime.now().astimezone(utc) timeframes = Utils.get_accepted_timeframes(t) if "1H" in timeframes: self.refresh_ccxt_index() self.refresh_coingecko_index() self.refresh_serum_index() self.refresh_coingecko_exchange_rates() if "1D" in timeframes: self.refresh_iexc_index() except Exception: print(format_exc()) if environ["PRODUCTION_MODE"]: self.logging.report_exception()
def execute(self):
self._user_id = Utils.find_user_id(self._args[0])
self._role = self._parse_role_name()
logging.info(f"Editing role: {self._user_id} -> {self._role}")
glob.c.execute("UPDATE donators SET role = ? WHERE id = ?",
(self._role, self._user_id))
glob.db.commit()
return self.Message(
f"Роль {self._user_id} была успешно изменена на {self._role}")
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logical variables
player = None
mycars = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
mycars = Car.list(self, uuid)
self.respn = '['
for _car in mycars:
self.respn += Car.compose_mycar('', _car) + ','
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
